From 30f0bb1d66f016d6d8366aa483ca12a4724bd599 Mon Sep 17 00:00:00 2001 From: gdisirio Date: Tue, 18 Sep 2007 12:40:26 +0000 Subject: git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@9 35acf78f-673a-0410-8e92-d51de3d6d3f4 --- src/chmsg.c | 194 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 src/chmsg.c (limited to 'src/chmsg.c') diff --git a/src/chmsg.c b/src/chmsg.c new file mode 100644 index 000000000..0f71b2216 --- /dev/null +++ b/src/chmsg.c @@ -0,0 +1,194 @@ +/* + ChibiOS/RT - Copyright (C) 2006-2007 Giovanni Di Sirio. + + This file is part of ChibiOS/RT. + + ChibiOS/RT is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + ChibiOS/RT is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ + +/** + * @addtogroup Messages + * @{ + */ +#include + +#ifdef CH_USE_MESSAGES +/** + * Sends a message to the specified thread. The client is stopped until the + * server executes a \p chMsgRelease() after receiving the message. + * + * @param tp the pointer to the thread + * @param msg the message, it can be a pointer to a complex structure + * @return the return message from \p chMsgRelease() + */ +t_msg chMsgSend(Thread *tp, t_msg msg) { + + chSysLock(); + + enqueue(currp, &tp->p_msgqueue); + if (tp->p_state == PRWTMSG) + chSchReadyI(tp); + currp->p_msg = msg; + chSchGoSleepI(PRSNDMSG); + msg = currp->p_rdymsg; + + chSysUnlock(); + return msg; +} + +#ifdef CH_USE_MESSAGES_EVENT +/** + * Sends a message to the specified thread and atomically triggers an event. + * The client is stopped until the server executes a \p chMsgRelease() + * after receiving the message. + * + * @param tp the pointer to the thread + * @param msg the message, it can be a pointer to a complex structure + * @param esp the event source to pulse while sending the message + * @return the return message from \p chMsgRelease() + * @return the message return status from \p chMsgRelease() + * @note This function assumes that the receiving thread is not sleeping into + * a \p chMsgWait(). The use case is that the server thread is waiting + * for both messages AND events while waiting into \p chEvtWait(). + */ +t_msg chMsgSendWithEvent(Thread *tp, t_msg msg, EventSource *esp) { + + chSysLock(); + + enqueue(currp, &tp->p_msgqueue); +// if (tp->p_state == PRWTMSG) +// chSchReadyI(tp); + chEvtSendI(esp); + currp->p_msg = msg; + chSchGoSleepI(PRSNDMSG); + msg = currp->p_rdymsg; + + chSysUnlock(); + return msg; +} +#endif + +#ifdef CH_USE_MESSAGES_TIMEOUT +static void unsend(void *p) { + +// Test removed, it should never happen. +// if (((Thread *)p)->p_state == PRSNDMSG) + chSchReadyI(dequeue(p))->p_rdymsg = RDY_TIMEOUT; +} + +/** + * Sends a message to the specified thread with timeout specification. The + * sender is stopped until the receiver executes a \p chMsgRelease(). + * + * @param tp the pointer to the thread + * @param msg the message. Note that it can be a pointer to a complex + * message structure. + * @param time the number of ticks before the operation fails + * @return the message return status from \p chMsgRelease() or + * \p RDY_TIMEOUT the specified time expired. + * @note The server thread can also return data into the message structure + * if you need messages to be bidirectional, just define the structure + * according your needs. If you dont need complicated messages exchange + * you may just use the \p chMsgRelease() status code as response + * to the message. + */ +t_msg chMsgSendTimeout(Thread *tp, t_msg msg, t_time time) { + VirtualTimer vt; + + chSysLock(); + + chVTSetI(&vt, time, unsend, currp); + enqueue(currp, &tp->p_msgqueue); + if (tp->p_state == PRWTMSG) + chSchReadyI(tp); + currp->p_msg = msg; + chSchGoSleepI(PRSNDMSG); + msg = currp->p_rdymsg; + if (vt.vt_func) + chVTResetI(&vt); + + chSysUnlock(); + return msg; +} +#endif /* CH_USE_MESSAGES_TIMEOUT */ + +/** + * Suspends the thread and waits for an incoming message. + * + * @return the pointer to the message structure. Note, it is always the + * message associated to the thread on the top of the messages queue. + * @note You can assume that the data contained in the message is stable until + * you invoke \p chMsgRelease() because the sending thread is + * suspended until then. Always remember that the message data is not + * copied between the sender and the receiver, just a pointer is passed. + */ +t_msg chMsgWait(void) { + t_msg msg; + + chSysLock(); + + if (!chMsgIsPendingI(currp)) + chSchGoSleepI(PRWTMSG); + msg = chMsgGetI(currp); + + chSysUnlock(); + return msg; +} + +/** + * Returns the next message in the queue. + * + * @return the pointer to the message structure. Note, it is always the + * message associated to the thread on the top of the messages queue. + * If the queue is empty then \p NULL is returned. + * @note You can assume that the data contained in the message is stable until + * you invoke \p chMsgRelease() because the sending thread is + * suspended until then. Always remember that the message data is not + * copied between the sender and the receiver, just a pointer is passed. + */ +t_msg chMsgGet(void) { + t_msg msg; + + chSysLock(); + + msg = chMsgIsPendingI(currp) ? chMsgGetI(currp) : NULL; + + chSysUnlock(); + return msg; +} + +/** + * Releases the thread waiting on top of the messages queue. + * + * @param msg the message returned to the message sender + * @note You can call this function only if there is a message already in the + * queue else the result will be unpredictable (a crash most likely). + * Exiting from the \p chMsgWait() ensures you have at least one + * message in the queue so it is not a big deal.
+ * The condition is not checked in order to make this code as fast as + * possible. + */ +void chMsgRelease(t_msg msg) { + + chSysLock(); + +// if (!chMsgIsPendingI(currp) + chSchWakeupI(dequeue(currp->p_msgqueue.p_next), msg); + + chSysUnlock(); +} + +#endif /* CH_USE_MESSAGES */ + +/** @} */ -- cgit v1.2.3