diff options
| author | gdisirio <gdisirio@35acf78f-673a-0410-8e92-d51de3d6d3f4> | 2013-01-01 15:42:44 +0000 |
|---|---|---|
| committer | gdisirio <gdisirio@35acf78f-673a-0410-8e92-d51de3d6d3f4> | 2013-01-01 15:42:44 +0000 |
| commit | 1be8fe145c836c3f90dc326de2a8678d5e17b628 (patch) | |
| tree | 2b0905200c88b3a3a571af57793a16e694388ab0 /os | |
| parent | 6ffd46f60833fd497fe717709bd77e147e79d3c4 (diff) | |
| download | ChibiOS-1be8fe145c836c3f90dc326de2a8678d5e17b628.tar.gz ChibiOS-1be8fe145c836c3f90dc326de2a8678d5e17b628.tar.bz2 ChibiOS-1be8fe145c836c3f90dc326de2a8678d5e17b628.zip | |
C++ wrapper prototype, not complete yet.
git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@5008 35acf78f-673a-0410-8e92-d51de3d6d3f4
Diffstat (limited to 'os')
| -rw-r--r-- | os/various/ch.cpp | 210 | ||||
| -rw-r--r-- | os/various/ch.hpp | 383 |
2 files changed, 394 insertions, 199 deletions
diff --git a/os/various/ch.cpp b/os/various/ch.cpp index 8b1f66da9..3bd3d6234 100644 --- a/os/various/ch.cpp +++ b/os/various/ch.cpp @@ -32,22 +32,22 @@ namespace chibios_rt { /*------------------------------------------------------------------------*
* chibios_rt::System *
*------------------------------------------------------------------------*/
- void System::Init(void) {
+ void System::init(void) {
chSysInit();
}
- void System::Lock(void) {
+ void System::lock(void) {
chSysLock();
}
- void System::Unlock(void) {
+ void System::unlock(void) {
chSysUnlock();
}
- systime_t System::GetTime(void) {
+ systime_t System::getTime(void) {
return chTimeNow();
}
@@ -55,107 +55,169 @@ namespace chibios_rt { /*------------------------------------------------------------------------*
* chibios_rt::Timer *
*------------------------------------------------------------------------*/
- void Timer::Set(systime_t time, vtfunc_t vtfunc, void *par) {
+ void Timer::setI(systime_t time, vtfunc_t vtfunc, void *par) {
- chVTSetI(&timer, time, vtfunc, par);
+ chVTSetI(&timer_ref, time, vtfunc, par);
}
- void Timer::Reset() {
+ void Timer::resetI() {
- chVTResetI(&timer);
+ if (chVTIsArmedI(&timer_ref))
+ chVTResetI(&timer_ref);
}
- bool Timer::IsArmed(void) {
+ bool Timer::isArmedI(void) {
- return chVTIsArmedI(&timer);
+ return (bool)chVTIsArmedI(&timer_ref);
}
/*------------------------------------------------------------------------*
- * chibios_rt::BaseThread *
+ * chibios_rt::ThreadReference *
*------------------------------------------------------------------------*/
- static msg_t thdstart(void *arg) {
+ msg_t ThreadReference::suspend(void) {
+ msg_t msg;
- return ((BaseThread *)arg)->Main();
+ chSysLock();
+
+ chDbgAssert(thread_ref != NULL,
+ "ThreadReference, #1",
+ "already referenced");
+
+ thread_ref = chThdSelf();
+ chSchGoSleepS(THD_STATE_SUSPENDED);
+ msg = thread_ref->p_u.rdymsg;
+
+ chSysUnlock();
+ return msg;
}
- BaseThread::BaseThread(void *workspace, size_t wsize, tprio_t prio) {
+ msg_t ThreadReference::suspendS(void) {
+
+ chDbgAssert(thread_ref == NULL,
+ "ThreadReference, #2",
+ "already referenced");
- thread_ref = chThdCreateStatic(workspace, wsize, prio, thdstart, this);
+ thread_ref = chThdSelf();
+ chSchGoSleepS(THD_STATE_SUSPENDED);
+ return thread_ref->p_u.rdymsg;
}
- void BaseThread::Exit(msg_t msg) {
+ void ThreadReference::resume(msg_t msg) {
- chThdExit(msg);
+ chSysLock()
+
+ chDbgAssert(thread_ref != NULL,
+ "ThreadReference, #3",
+ "not referenced");
+
+ if (thread_ref) {
+ Thread *tp = thread_ref;
+ thread_ref = NULL;
+ chSchWakeupS(tp, msg);
+ }
+
+ chSysUnlock();
}
-#if CH_USE_WAITEXIT
- msg_t BaseThread::Wait(void) {
+ void ThreadReference::resumeI(msg_t msg) {
- return chThdWait(thread_ref);
+ chDbgAssert(thread_ref != NULL,
+ "ThreadReference, #4",
+ "not referenced");
+
+ if (thread_ref) {
+ Thread *tp = thread_ref;
+ thread_ref = NULL;
+ tp->p_msg = msg;
+ chSchReadyI(tp);
+ }
}
-#endif /* CH_USE_WAITEXIT */
- void BaseThread::SetPriority(tprio_t newprio) {
+ void ThreadReference::requestTerminate(void) {
- chThdSetPriority(newprio);
+ chThdTerminate(thread_ref);
}
- void BaseThread::Resume(void) {
+#if CH_USE_WAITEXIT || defined(__DOXYGEN__)
+ msg_t ThreadReference::wait(void) {
+
+ chDbgAssert(thread_ref != NULL,
+ "ThreadReference, #5",
+ "not referenced");
+
+ msg_t msg = chThdWait(thread_ref);
+ thread_ref = NULL;
+ return msg;
+ }
+#endif /* CH_USE_WAITEXIT */
- chThdResume(thread_ref);
+#if CH_USE_MESSAGES || defined(__DOXYGEN__)
+ msg_t ThreadReference::sendMessage(msg_t msg) {
+
+ chDbgAssert(thread_ref != NULL,
+ "ThreadReference, #6",
+ "not referenced");
+
+ return chMsgSend(thread_ref, msg);
}
- void BaseThread::Terminate(void) {
+ bool ThreadReference::isPendingMessage(void) {
- chThdTerminate(thread_ref);
+ return (bool)chMsgIsPendingI(thread_ref);
}
+#endif /* CH_USE_MESSAGES */
- void BaseThread::Sleep(systime_t n) {
+#if CH_USE_DYNAMIC
+#endif /* CH_USE_DYNAMIC */
+
+ /*------------------------------------------------------------------------*
+ * chibios_rt::BaseThread *
+ *------------------------------------------------------------------------*/
+ BaseThread::BaseThread() : ThreadReference(NULL) {
- chThdSleep(n);
}
- void BaseThread::SleepUntil(systime_t time) {
+ msg_t _thd_start(void *arg) {
- chThdSleepUntil(time);
+ return ((BaseThread *)arg)->Main();
}
-#if CH_USE_MESSAGES
- msg_t BaseThread::SendMessage(::Thread* tp, msg_t msg) {
+ void BaseThread::exit(msg_t msg) {
- return chMsgSend(tp, msg);
+ chThdExit(msg);
}
- msg_t BaseThread::SendMessage(msg_t msg) {
+ tprio_t BaseThread::setPriority(tprio_t newprio) {
- return chMsgSend(thread_ref, msg);
+ return chThdSetPriority(newprio);
}
- Thread *BaseThread::WaitMessage(void) {
+ bool BaseThread::shouldTerminate(void) {
- return chMsgWait();
+ return (bool)chThdShouldTerminate();
}
- msg_t BaseThread::GetMessage(Thread* tp) {
+ void BaseThread::sleep(systime_t interval){
- return chMsgGet(tp);
+ chThdSleep(interval);
}
- void BaseThread::ReleaseMessage(Thread* tp, msg_t msg) {
+ void BaseThread::sleepUntil(systime_t time) {
- chMsgRelease(tp, msg);
+ chThdSleepUntil(time);
}
- bool BaseThread::IsPendingMessage(void) {
+#if CH_USE_MESSAGES
+ msg_t BaseThread::getMessage(ThreadReference* trp) {
- return chMsgIsPendingI(currp);
+ return chMsgGet(trp->thread_ref);
}
-#endif /* CH_USE_MESSAGES */
- msg_t BaseThread::Main(void) {
+ void BaseThread::releaseMessage(ThreadReference* trp, msg_t msg) {
- return 0;
+ chMsgRelease(trp->thread_ref, msg);
}
+#endif /* CH_USE_MESSAGES */
#if CH_USE_SEMAPHORES
/*------------------------------------------------------------------------*
@@ -166,28 +228,28 @@ namespace chibios_rt { chSemInit(&sem, n);
}
- void Semaphore::Reset(cnt_t n) {
+ void Semaphore::reset(cnt_t n) {
chSemReset(&sem, n);
}
- msg_t Semaphore::Wait(void) {
+ msg_t Semaphore::wait(void) {
return chSemWait(&sem);
}
- msg_t Semaphore::WaitTimeout(systime_t time) {
+ msg_t Semaphore::waitTimeout(systime_t time) {
return chSemWaitTimeout(&sem, time);
}
- void Semaphore::Signal(void) {
+ void Semaphore::signal(void) {
chSemSignal(&sem);
}
#if CH_USE_SEMSW
- msg_t Semaphore::SignalWait(Semaphore *ssem, Semaphore *wsem) {
+ msg_t Semaphore::signalWait(Semaphore *ssem, Semaphore *wsem) {
return chSemSignalWait(&ssem->sem, &wsem->sem);
}
@@ -203,22 +265,22 @@ namespace chibios_rt { chMtxInit(&mutex);
}
- bool Mutex::TryLock(void) {
+ bool Mutex::tryLock(void) {
return chMtxTryLock(&mutex);
}
- void Mutex::Lock(void) {
+ void Mutex::lock(void) {
chMtxLock(&mutex);
}
- void Mutex::Unlock(void) {
+ void Mutex::unlock(void) {
chMtxUnlock();
}
- void UnlockAll(void) {
+ void Mutex::unlockAll(void) {
chMtxUnlockAll();
}
@@ -232,23 +294,23 @@ namespace chibios_rt { chCondInit(&condvar);
}
- void CondVar::Signal(void) {
+ void CondVar::signal(void) {
chCondSignal(&condvar);
}
- void CondVar::Broadcast(void) {
+ void CondVar::broadcast(void) {
chCondBroadcast(&condvar);
}
- msg_t CondVar::Wait(void) {
+ msg_t CondVar::wait(void) {
return chCondWait(&condvar);
}
#if CH_USE_CONDVARS_TIMEOUT
- msg_t CondVar::WaitTimeout(systime_t time) {
+ msg_t CondVar::waitTimeout(systime_t time) {
return chCondWaitTimeout(&condvar, time);
}
@@ -265,73 +327,73 @@ namespace chibios_rt { chEvtInit(&event);
}
- void Event::Register(EventListener *elp, eventid_t eid) {
+ void Event::registerOne(EventListener *elp, eventid_t eid) {
chEvtRegister(&event,elp, eid);
}
- void Event::RegisterMask(EventListener *elp, eventmask_t emask) {
+ void Event::registerMask(EventListener *elp, eventmask_t emask) {
chEvtRegisterMask(&event,elp, emask);
}
- void Event::Unregister(EventListener *elp) {
+ void Event::unregister(EventListener *elp) {
chEvtUnregister(&event, elp);
}
- void Event::BroadcastFlags(flagsmask_t flags) {
+ void Event::broadcastFlags(flagsmask_t flags) {
chEvtBroadcastFlags(&event, flags);
}
- flagsmask_t GetAndClearFlags(EventListener *elp) {
+ flagsmask_t Event::getAndClearFlags(EventListener *elp) {
return chEvtGetAndClearFlags(elp);
}
- eventmask_t Event::GetAndClearEvents(eventmask_t mask) {
+ eventmask_t Event::getAndClearEvents(eventmask_t mask) {
return chEvtGetAndClearEvents(mask);
}
- eventmask_t Event::AddEvents(eventmask_t mask) {
+ eventmask_t Event::addEvents(eventmask_t mask) {
return chEvtAddEvents(mask);
}
- void Event::Dispatch(const evhandler_t handlers[], eventmask_t mask) {
+ void Event::dispatch(const evhandler_t handlers[], eventmask_t mask) {
chEvtDispatch(handlers, mask);
}
- eventmask_t Event::WaitOne(eventmask_t ewmask) {
+ eventmask_t Event::waitOne(eventmask_t ewmask) {
return chEvtWaitOne(ewmask);
}
- eventmask_t Event::WaitAny(eventmask_t ewmask) {
+ eventmask_t Event::waitAny(eventmask_t ewmask) {
return chEvtWaitAny(ewmask);
}
- eventmask_t Event::WaitAll(eventmask_t ewmask) {
+ eventmask_t Event::waitAll(eventmask_t ewmask) {
return chEvtWaitAll(ewmask);
}
#if CH_USE_EVENTS_TIMEOUT
- eventmask_t Event::WaitOneTimeout(eventmask_t ewmask, systime_t time) {
+ eventmask_t Event::waitOneTimeout(eventmask_t ewmask, systime_t time) {
return chEvtWaitOneTimeout(ewmask, time);
}
- eventmask_t Event::WaitAnyTimeout(eventmask_t ewmask, systime_t time) {
+ eventmask_t Event::waitAnyTimeout(eventmask_t ewmask, systime_t time) {
return chEvtWaitAnyTimeout(ewmask, time);
}
- eventmask_t Event::WaitAllTimeout(eventmask_t ewmask, systime_t time) {
+ eventmask_t Event::waitAllTimeout(eventmask_t ewmask, systime_t time) {
return chEvtWaitAllTimeout(ewmask, time);
}
diff --git a/os/various/ch.hpp b/os/various/ch.hpp index f58bd4e8c..44bbab278 100644 --- a/os/various/ch.hpp +++ b/os/various/ch.hpp @@ -33,6 +33,9 @@ namespace chibios_rt {
+ /*------------------------------------------------------------------------*
+ * chibios_rt::System *
+ *------------------------------------------------------------------------*/
/**
* @brief Class encapsulating the base system functionalities.
*/
@@ -43,32 +46,43 @@ namespace chibios_rt { * @details The system is initialized, the idle thread is spawned and the
* current instruction flow becomes the main thread with priority
* @p NORMALPRIO.
+ *
+ * @api
*/
- static void Init(void);
+ static void init(void);
/**
* @brief Kernel lock.
- * @note On some ports it is faster to invoke chSysLock() directly because
- * inlining.
+ * @note On some ports it is faster to invoke chSysLock() directly
+ * because inlining.
+ *
+ * @special
*/
- static void Lock(void);
+ static void lock(void);
/**
* @brief Kernel unlock.
* @note On some ports it is faster to invoke chSysUnlock() directly
* because inlining.
+ *
+ * @special
*/
- static void Unlock(void);
+ static void unlock(void);
/**
* @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);
+ static systime_t getTime(void);
};
+ /*------------------------------------------------------------------------*
+ * chibios_rt::Timer *
+ *------------------------------------------------------------------------*/
/**
* @brief Timer class.
*/
@@ -77,7 +91,7 @@ namespace chibios_rt { /**
* @brief Embedded @p VirtualTimer structure.
*/
- struct ::VirtualTimer timer;
+ struct ::VirtualTimer timer_ref;
/**
* @brief Starts the timer.
@@ -87,30 +101,37 @@ namespace chibios_rt { * @param[in] time the time in system ticks
* @param[in] vtfunc the timer callback function
* @param[in] par the parameter for the callback function
+ *
+ * @iclass
*/
- void Set(systime_t time, vtfunc_t vtfunc, void *par);
+ void setI(systime_t time, vtfunc_t vtfunc, void *par);
/**
- * @brief Resets the timer.
- * @note It must be called with the interrupts disabled.
- * @note The timer MUST be active when this function is invoked.
+ * @brief Resets the timer, if armed.
+ *
+ * @iclass
*/
- void Reset();
+ void resetI();
/**
* @brief Returns the timer status.
*
* @retval TRUE The timer is armed.
* @retval FALSE The timer already fired its callback.
+ *
+ * @iclass
*/
- bool IsArmed(void);
+ bool isArmedI(void);
};
+ /*------------------------------------------------------------------------*
+ * chibios_rt::ThreadReference *
+ *------------------------------------------------------------------------*/
/**
- * @brief Base class for a ChibiOS/RT thread.
- * @details The thread body is the virtual function @p Main().
+ * @brief Thread reference class.
+ * @details This class encapsulates a reference to a system thread.
*/
- class BaseThread {
+ class ThreadReference {
public:
/**
* @brief Pointer to the system thread.
@@ -118,169 +139,281 @@ namespace chibios_rt { ::Thread *thread_ref;
/**
- * @brief Thread constructor.
- * @details The thread object is initialized and a system thread is
- * started.
+ * @brief Thread reference constructor.
*
- * @param[in] workspace pointer to the workspace area
- * @param[in] wsize size of the workspace area
- * @param[in] prio thread priority
+ * @param[in] tp the target thread. This parameter can be
+ * @p NULL if the thread is not known at
+ * creation time.
+ *
+ * @api
*/
- BaseThread(void *workspace, size_t wsize, tprio_t prio);
+ ThreadReference(Thread * tp);
/**
- * @brief Thread exit.
+ * @brief Suspends the current thread on the reference.
+ * @details The suspended thread becomes the referenced thread. It is
+ * possible to use this method only if the thread reference
+ * was set to @p NULL.
*
- * @param[in] msg the exit message
+ * @return The incoming message.
+ *
+ * @api
*/
- static void Exit(msg_t msg);
+ msg_t suspend(void);
-#if CH_USE_WAITEXIT
+ /**
+ * @brief Suspends the current thread on the reference.
+ * @details The suspended thread becomes the referenced thread. It is
+ * possible to use this method only if the thread reference
+ * was set to @p NULL.
+ *
+ * @return The incoming message.
+ *
+ * @sclass
+ */
+ msg_t suspendS(void);
+
+ /**
+ * @brief Resumes the currently referenced thread, if any.
+ *
+ * @api
+ */
+ void resume(msg_t msg);
+
+ /**
+ * @brief Resumes the currently referenced thread, if any.
+ *
+ * @iclass
+ */
+ void resumeI(msg_t msg);
+
+ /**
+ * @brief Requests thread termination.
+ * @details A termination flag is added to the thread, it is thread
+ * responsibility to detect it and exit.
+ */
+ void requestTerminate(void);
+
+#if CH_USE_WAITEXIT || defined(__DOXYGEN__)
/**
* @brief Synchronization on Thread exit.
*
* @return The exit message from the thread.
+ *
+ * @api
*/
- msg_t Wait(void);
+ msg_t wait(void);
#endif /* CH_USE_WAITEXIT */
+#if CH_USE_MESSAGES || defined(__DOXYGEN__)
/**
- * @brief Resumes the thread.
- * @details The thread encapsulated into the object is resumed.
+ * @brief Sends a message to the thread and returns the answer.
+ *
+ * @param[in] msg the sent message
+ * @return The returned message.
+ *
+ * @api
*/
- void Resume(void);
+ msg_t sendMessage(msg_t msg);
/**
- * @brief Changes the thread priority.
+ * @brief Returns true if there is at least one message in queue.
*
- * @param[in] newprio The new priority level
+ * @retval true A message is waiting in queue.
+ * @retval false A message is not waiting in queue.
+ *
+ * @api
*/
- static void SetPriority(tprio_t newprio);
+ bool isPendingMessage(void);
+#endif /* CH_USE_MESSAGES */
+
+#if CH_USE_DYNAMIC
+#endif /* CH_USE_DYNAMIC */
+ };
+
+ /*------------------------------------------------------------------------*
+ * chibios_rt::BaseThread *
+ *------------------------------------------------------------------------*/
+ /**
+ * @brief Abstract base class for a ChibiOS/RT thread.
+ * @details The thread body is the virtual function @p Main().
+ */
+ class BaseThread : ThreadReference{
+ public:
/**
- * @brief Requests thread termination.
- * @details A termination flag is pended on the thread, it is thread
- * responsibility to detect it and exit.
+ * @brief BaseThread constructor.
+ *
+ * @api
*/
- void Terminate(void);
+ BaseThread(void);
/**
- * @brief Suspends the thread execution for the specified number of
- * system ticks.
+ * @brief Thread body function.
+ *
+ * @return The exit message.
*
- * @param[in] n the number of system ticks
+ * @api
*/
- static void Sleep(systime_t n);
+ virtual msg_t Main(void);
/**
- * @brief Suspends the thread execution until the specified time arrives.
+ * @brief Creates and starts a system thread.
*
- * @param[in] time the system time
+ * @param[in] tname the name to be assigned to the thread
+ * @param[in] prio thread priority
+ * @return Error flag.
+ * @retval false if the operation failed.
+ * @retval true if the operation succeeded.
+ *
+ * @api
*/
- static void SleepUntil(systime_t time);
+ virtual bool start(const char *tname, tprio_t prio);
-#if CH_USE_MESSAGES
/**
- * @brief Sends a message to the thread and returns the answer.
+ * @brief Thread exit.
*
- * @param[in] tp the target thread
- * @param[in] msg the sent message
- * @return The returned message.
+ * @param[in] msg the exit message
+ *
+ * @api
*/
- static msg_t SendMessage(::Thread *tp, msg_t msg);
+ static void exit(msg_t msg);
+#if CH_USE_WAITEXIT || defined(__DOXYGEN__)
/**
- * @brief Sends a message to the thread and returns the answer.
+ * @brief Synchronization on Thread exit.
*
- * @param[in] msg the sent message
- * @return The returned message.
+ * @return The exit message from the thread.
+ *
+ * @api
*/
- msg_t SendMessage(msg_t msg);
+ msg_t wait(void);
+#endif /* CH_USE_WAITEXIT */
/**
- * @brief Waits for a message.
+ * @brief Changes the current thread priority.
+ *
+ * @param[in] newprio The new priority level
+ * @return The old priority level.
*
- * @return The sebder thread.
+ * @api
*/
- static Thread *WaitMessage(void);
+ static tprio_t setPriority(tprio_t newprio);
/**
- * @brief Returns an enqueued message or @p NULL.
+ * @brief Requests thread termination.
+ * @details A termination flag is added to the thread, it is thread
+ * responsibility to detect it and exit.
*
- * @param[in] tp the sender thread
- * @return The incoming message.
+ * @api
*/
- static msg_t GetMessage(Thread* tp);
+ void requestTerminate(void);
/**
- * @brief Releases the next message in queue with a reply.
+ * @brief Determines if there is a pending termination request.
*
- * @param[in] tp the sender thread
- * @param[in] msg the answer message
+ * @return The termination status.
+ * @retval false if there is no termination request pending.
+ * @retval true if there is a termination request pending.
+ *
+ * @api
*/
- static void ReleaseMessage(Thread* tp, msg_t msg);
+ bool shouldTerminate(void);
/**
- * @brief Returns true if there is at least one message in queue.
+ * @brief Suspends the thread execution for the specified number of
+ * system ticks.
*
- * @retval TRUE A message is waiting in queue.
- * @retval FALSE A message is not waiting in queue.
+ * @param[in] interval the number of system ticks
+ *
+ * @api
*/
- static bool IsPendingMessage(void);
-#endif /* CH_USE_MESSAGES */
+ static void sleep(systime_t interval);
/**
- * @brief Thread body function.
+ * @brief Suspends the thread execution until the specified time arrives.
*
- * @return The exit message.
+ * @param[in] time the system time
+ *
+ * @api
*/
- virtual msg_t Main(void);
+ static void sleepUntil(systime_t time);
+
+#if CH_USE_MESSAGES
+ /**
+ * @brief Waits for a message.
+ *
+ * @return The sender thread.
+ *
+ * @api
+ */
+ static ThreadReference waitMessage(void);
+
+ /**
+ * @brief Returns an enqueued message or @p NULL.
+ *
+ * @param[in] trp the sender thread reference
+ * @return The incoming message.
+ *
+ * @api
+ */
+ static msg_t getMessage(ThreadReference* trp);
+
+ /**
+ * @brief Releases the next message in queue with a reply.
+ *
+ * @param[in] trp the sender thread reference
+ * @param[in] msg the answer message
+ *
+ * @api
+ */
+ static void releaseMessage(ThreadReference* trp, msg_t msg);
+#endif /* CH_USE_MESSAGES */
};
+ /*------------------------------------------------------------------------*
+ * chibios_rt::BaseStaticThread *
+ *------------------------------------------------------------------------*/
/**
- * @brief Enhanced threads template class.
- * @details This class introduces thread names and static working area
- * allocation.
+ * @brief Static threads template class.
+ * @details This class introduces static working area allocation.
*
* @param N the working area size for the thread class
*/
template <int N>
- class EnhancedThread : public BaseThread {
+ class BaseStaticThread : public BaseThread {
protected:
WORKING_AREA(wa, N); // Thread working area.
public:
/**
- * @brief The thread name.
- */
- const char *name;
-
- /**
- * @brief Full constructor.
- * @details This constructor allows to set a priority level for the new
- * thread.
+ * @brief Thread constructor.
+ * @details The thread object is initialized but the thread is not
+ * started here.
*
- * @param[in] tname the name to be assigned to the thread
- * @param[in] prio the priority to be assigned to the thread
+ * @api
*/
- EnhancedThread(const char *tname, tprio_t prio) :
- BaseThread(wa, sizeof wa, prio) {
+ BaseStaticThread(void) : BaseThread() {
- name = tname;
}
+
/**
- * @brief Simplified constructor.
- * @details This constructor allows to create a thread by simply
- * specifying a name. In is assumed @p NORMALPRIO as initial
- * priority.
+ * @brief Creates and starts a system thread.
*
* @param[in] tname the name to be assigned to the thread
+ * @param[in] prio thread priority
+ * @return Error flag.
+ * @retval false if the operation failed.
+ * @retval true if the operation succeeded.
+ *
+ * @api
*/
- EnhancedThread(const char *tname) :
- BaseThread(wa, sizeof wa, NORMALPRIO) {
+ bool start(const char *tname, tprio_t prio) {
+ msg_t _thd_start(void *arg);
- name = tname;
+ thread_ref = chThdCreateStatic(wa, sizeof(wa), prio, _thd_start, this);
+ return thread_ref != NULL;
}
};
@@ -310,7 +443,7 @@ namespace chibios_rt { * @param[in] n the new semaphore counter value, must be
* greater or equal to zero
*/
- void Reset(cnt_t n);
+ void reset(cnt_t n);
/**
* @brief Wait operation on the semaphore.
@@ -318,7 +451,7 @@ namespace chibios_rt { * @retval RDY_OK if the semaphore was signaled or not taken.
* @retval RDY_RESET if the semaphore was reset.
*/
- msg_t Wait(void);
+ msg_t wait(void);
/**
* @brief Wait operation on the semaphore with timeout.
@@ -329,14 +462,14 @@ namespace chibios_rt { * @retval RDY_TIMEOUT if the semaphore was not signaled or reset
* within the specified timeout.
*/
- msg_t WaitTimeout(systime_t time);
+ msg_t waitTimeout(systime_t time);
/**
* @brief Signal operation on the semaphore.
* @details The semaphore is signaled, the next thread in queue, if any,
* is awakened.
*/
- void Signal(void);
+ void signal(void);
#if CH_USE_SEMSW
/**
@@ -347,7 +480,7 @@ namespace chibios_rt { * @retval RDY_OK if the semaphore was signaled or not taken.
* @retval RDY_RESET if the semaphore was reset.
*/
- static msg_t SignalWait(Semaphore *ssem, Semaphore *wsem);
+ static msg_t signalWait(Semaphore *ssem, Semaphore *wsem);
#endif /* CH_USE_SEMSW */
};
#endif /* CH_USE_SEMAPHORES */
@@ -375,7 +508,7 @@ namespace chibios_rt { * @retval TRUE if the mutex was successfully acquired
* @retval FALSE if the lock attempt failed.
*/
- bool TryLock(void);
+ bool tryLock(void);
/**
* @brief Locks the mutex.
@@ -383,14 +516,14 @@ namespace chibios_rt { * already locked then the thread enters the mutex priority
* queue and waits.
*/
- void Lock(void);
+ void lock(void);
/**
* @brief Unlocks the mutex.
* @details Performs an unlock operation on the mutex, the next waiting
* thread, if any, is resumed and locks the mutex.
*/
- static void Unlock(void);
+ static void unlock(void);
/**
* @brief Unlocks all the mutexes owned by the invoking thread.
@@ -399,7 +532,7 @@ namespace chibios_rt { * this function does not have any overhead related to the
* priority inheritance mechanism.
*/
- static void UnlockAll(void);
+ static void unlockAll(void);
};
#if CH_USE_CONDVARS
@@ -423,13 +556,13 @@ namespace chibios_rt { * @brief Signals the CondVar.
* @details The next thread waiting on the @p CondVar, if any, is awakened.
*/
- void Signal(void);
+ void signal(void);
/**
* @brief Broadcasts the CondVar.
* @details All the threads waiting on the @p CondVar, if any, are awakened.
*/
- void Broadcast(void);
+ void broadcast(void);
/**
* @brief Waits on the CondVar while releasing the controlling mutex.
@@ -440,7 +573,7 @@ namespace chibios_rt { * @retval RDY_RESET if the condvar was signaled using
* @p chCondBroadcast().
*/
- msg_t Wait(void);
+ msg_t wait(void);
#if CH_USE_CONDVARS_TIMEOUT
/**
@@ -455,7 +588,7 @@ namespace chibios_rt { * @retval RDY_TIMEOUT if the condvar was not signaled within the
* specified timeout.
*/
- msg_t WaitTimeout(systime_t time);
+ msg_t waitTimeout(systime_t time);
#endif /* CH_USE_CONDVARS_TIMEOUT */
};
#endif /* CH_USE_CONDVARS */
@@ -485,7 +618,7 @@ namespace chibios_rt { * @param[in] eid numeric identifier assigned to the Event
* Listener
*/
- void Register(EventListener *elp, eventid_t eid);
+ void registerOne(EventListener *elp, eventid_t eid);
/**
* @brief Registers an Event Listener on an Event Source.
@@ -495,7 +628,7 @@ namespace chibios_rt { * @param[in] emask the mask of event flags to be pended to the
* thread when the event source is broadcasted
*/
- void RegisterMask(EventListener *elp, eventmask_t emask);
+ void registerMask(EventListener *elp, eventmask_t emask);
/**
* @brief Unregisters a listener.
@@ -504,7 +637,7 @@ namespace chibios_rt { *
* @param[in] elp the listener to be unregistered
*/
- void Unregister(EventListener *elp);
+ void unregister(EventListener *elp);
/**
* @brief Broadcasts an event.
@@ -513,7 +646,7 @@ namespace chibios_rt { * @param[in] flags the flags set to be added to the listener
* flags mask
*/
- void BroadcastFlags(flagsmask_t flags);
+ void broadcastFlags(flagsmask_t flags);
/**
* @brief Clears specified events from the pending events mask.
@@ -523,7 +656,7 @@ namespace chibios_rt { * @return The flags added to the listener by the
* associated event source.
*/
- static flagsmask_t GetAndClearFlags(EventListener *elp);
+ static flagsmask_t getAndClearFlags(EventListener *elp);
/**
* @brief Clears specified events from the pending events mask.
@@ -531,7 +664,7 @@ namespace chibios_rt { * @param[in] mask the events to be cleared
* @return The pending events that were cleared.
*/
- static eventmask_t GetAndClearEvents(eventmask_t mask);
+ static eventmask_t getAndClearEvents(eventmask_t mask);
/**
* @brief Makes an events mask pending in the current thread.
@@ -540,7 +673,7 @@ namespace chibios_rt { * @param[in] mask the events to be pended
* @return The current pending events mask.
*/
- static eventmask_t AddEvents(eventmask_t mask);
+ static eventmask_t addEvents(eventmask_t mask);
/**
* @brief Invokes the event handlers associated with a mask.
@@ -550,7 +683,7 @@ namespace chibios_rt { * have indexes from zero up the higher registered
* event identifier.
*/
- static void Dispatch(const evhandler_t handlers[], eventmask_t mask);
+ static void dispatch(const evhandler_t handlers[], eventmask_t mask);
/**
* @brief Waits for a single event.
@@ -567,7 +700,7 @@ namespace chibios_rt { * @return The mask of the lowest id served and cleared
* event.
*/
- static eventmask_t WaitOne(eventmask_t ewmask);
+ static eventmask_t waitOne(eventmask_t ewmask);
/**
* @brief Waits for any of the specified events.
@@ -579,7 +712,7 @@ namespace chibios_rt { * wait for, @p ALL_EVENTS enables all the events
* @return The mask of the served and cleared events.
*/
- static eventmask_t WaitAny(eventmask_t ewmask);
+ static eventmask_t waitAny(eventmask_t ewmask);
/**
* @brief Waits for all the specified event flags then clears them.
@@ -590,7 +723,7 @@ namespace chibios_rt { * wait for
* @return The mask of the served and cleared events.
*/
- static eventmask_t WaitAll(eventmask_t ewmask);
+ static eventmask_t waitAll(eventmask_t ewmask);
#if CH_USE_EVENTS_TIMEOUT
/**
@@ -611,7 +744,7 @@ namespace chibios_rt { * event.
* @retval 0 if the specified timeout expired.
*/
- static eventmask_t WaitOneTimeout(eventmask_t ewmask, systime_t time);
+ static eventmask_t waitOneTimeout(eventmask_t ewmask, systime_t time);
/**
* @brief Waits for any of the specified events.
@@ -626,7 +759,7 @@ namespace chibios_rt { * @return The mask of the served and cleared events.
* @retval 0 if the specified timeout expired.
*/
- static eventmask_t WaitAnyTimeout(eventmask_t ewmask, systime_t time);
+ static eventmask_t waitAnyTimeout(eventmask_t ewmask, systime_t time);
/**
* @brief Waits for all the specified event flags then clears them.
@@ -640,7 +773,7 @@ namespace chibios_rt { * @return The mask of the served and cleared events.
* @retval 0 if the specified timeout expired.
*/
- static eventmask_t WaitAllTimeout(eventmask_t ewmask, systime_t time);
+ static eventmask_t waitAllTimeout(eventmask_t ewmask, systime_t time);
#endif /* CH_USE_EVENTS_TIMEOUT */
};
|