git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@2184 35acf78f-673a-0410-8e92-d51de3d6d3f4
parent
16855e1a4e
commit
07351222e6
|
@ -189,7 +189,27 @@ TAB_SIZE = 2
|
|||
# will result in a user-defined paragraph with heading "Side Effects:".
|
||||
# You can put \n's in the value part of an alias to insert newlines.
|
||||
|
||||
ALIASES =
|
||||
ALIASES = "iclass=@par Function Class:\n This is an \
|
||||
<b>I-Class</b> API, this function can be \
|
||||
invoked from within a system lock zone by both \
|
||||
threads and interrupt handlers." \
|
||||
"sclass=@par Function Class:\n This is an \
|
||||
<b>S-Class</b> API, this function can be \
|
||||
invoked from within a system lock zone by threads \
|
||||
only." \
|
||||
"api=@par Function Class:\n Normal API, this \
|
||||
function can be invoked by regular system threads \
|
||||
but not from within a lock zone." \
|
||||
"notapi=@par Function Class:\n Not an API, this \
|
||||
function is for internal use only." \
|
||||
"isr=@par Function Class:\n Interrupt handler, \
|
||||
this function should not be directly invoked." \
|
||||
"init=@par Function Class:\n Initializer, this \
|
||||
function just initializes an object and can be \
|
||||
invoked before the kernel is initialized." \
|
||||
"special=@par Function Class:\n Special function, \
|
||||
this function has special requirements see the \
|
||||
notes."
|
||||
|
||||
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
|
||||
# sources only. Doxygen will then generate output that is more tailored for C.
|
||||
|
|
|
@ -137,7 +137,7 @@ static void serve_interrupt(SerialDriver *sdp) {
|
|||
case IIR_SRC_TIMEOUT:
|
||||
case IIR_SRC_RX:
|
||||
chSysLockFromIsr();
|
||||
if (chIQIsEmpty(&sdp->iqueue))
|
||||
if (chIQIsEmptyI(&sdp->iqueue))
|
||||
chEvtBroadcastI(&sdp->ievent);
|
||||
chSysUnlockFromIsr();
|
||||
while (u->LSR & LSR_RBR_FULL) {
|
||||
|
|
|
@ -137,7 +137,7 @@ static void serve_interrupt(SerialDriver *sdp) {
|
|||
case IIR_SRC_TIMEOUT:
|
||||
case IIR_SRC_RX:
|
||||
chSysLockFromIsr();
|
||||
if (chIQIsEmpty(&sdp->iqueue))
|
||||
if (chIQIsEmptyI(&sdp->iqueue))
|
||||
chEvtBroadcastI(&sdp->ievent);
|
||||
chSysUnlockFromIsr();
|
||||
while (u->LSR & LSR_RBR_FULL) {
|
||||
|
|
|
@ -144,7 +144,7 @@ static void serve_interrupt(SerialDriver *sdp) {
|
|||
case IIR_SRC_TIMEOUT:
|
||||
case IIR_SRC_RX:
|
||||
chSysLockFromIsr();
|
||||
if (chIQIsEmpty(&sdp->iqueue))
|
||||
if (chIQIsEmptyI(&sdp->iqueue))
|
||||
chEvtBroadcastI(&sdp->ievent);
|
||||
chSysUnlockFromIsr();
|
||||
while (u->UART_LSR & LSR_RBR_FULL) {
|
||||
|
|
|
@ -61,12 +61,12 @@ static size_t reads(void *ip, uint8_t *bp, size_t n) {
|
|||
|
||||
static bool_t putwouldblock(void *ip) {
|
||||
|
||||
return chOQIsFull(&((SerialDriver *)ip)->oqueue);
|
||||
return chOQIsFullI(&((SerialDriver *)ip)->oqueue);
|
||||
}
|
||||
|
||||
static bool_t getwouldblock(void *ip) {
|
||||
|
||||
return chIQIsEmpty(&((SerialDriver *)ip)->iqueue);
|
||||
return chIQIsEmptyI(&((SerialDriver *)ip)->iqueue);
|
||||
}
|
||||
|
||||
static msg_t putt(void *ip, uint8_t b, systime_t timeout) {
|
||||
|
@ -192,7 +192,7 @@ void sdIncomingDataI(SerialDriver *sdp, uint8_t b) {
|
|||
|
||||
chDbgCheck(sdp != NULL, "sdIncomingDataI");
|
||||
|
||||
if (chIQIsEmpty(&sdp->iqueue))
|
||||
if (chIQIsEmptyI(&sdp->iqueue))
|
||||
chEvtBroadcastI(&sdp->ievent);
|
||||
if (chIQPutI(&sdp->iqueue, b) < Q_OK)
|
||||
sdAddFlagsI(sdp, SD_OVERRUN_ERROR);
|
||||
|
|
|
@ -91,6 +91,8 @@ typedef struct {
|
|||
* - @a FALSE, the initial state is not taken.
|
||||
* - @a TRUE, the initial state is taken.
|
||||
* .
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
#define chBSemInit(bsp, taken) chSemInit(&bsp->bs_sem, taken ? 0 : 1)
|
||||
|
||||
|
@ -98,9 +100,13 @@ typedef struct {
|
|||
* @brief Wait operation on the binary semaphore.
|
||||
*
|
||||
* @param[in] bsp pointer to a @p BinarySemaphore structure
|
||||
* @retval RDY_OK if the binary semaphore had been successfully taken.
|
||||
* @return A message specifying how the invoking thread has been
|
||||
* released from the semaphore.
|
||||
* @retval RDY_OK if the binary semaphore has been successfully taken.
|
||||
* @retval RDY_RESET if the binary semaphore has been reset using
|
||||
* @p bsemReset().
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chBSemWait(bsp) chSemWait(&bsp->bs_sem)
|
||||
|
||||
|
@ -108,9 +114,13 @@ typedef struct {
|
|||
* @brief Wait operation on the binary semaphore.
|
||||
*
|
||||
* @param[in] bsp pointer to a @p BinarySemaphore structure
|
||||
* @retval RDY_OK if the binary semaphore had been successfully taken.
|
||||
* @return A message specifying how the invoking thread has been
|
||||
* released from the semaphore.
|
||||
* @retval RDY_OK if the binary semaphore has been successfully taken.
|
||||
* @retval RDY_RESET if the binary semaphore has been reset using
|
||||
* @p bsemReset().
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#define chBSemWaitS(bsp) chSemWaitS(&bsp->bs_sem)
|
||||
|
||||
|
@ -123,11 +133,15 @@ typedef struct {
|
|||
* - @a TIME_IMMEDIATE immediate timeout.
|
||||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @retval RDY_OK if the binary semaphore had been successfully taken.
|
||||
* @return A message specifying how the invoking thread has been
|
||||
* released from the semaphore.
|
||||
* @retval RDY_OK if the binary semaphore has been successfully taken.
|
||||
* @retval RDY_RESET if the binary semaphore has been reset using
|
||||
* @p bsemReset().
|
||||
* @retval RDY_TIMEOUT if the binary semaphore was not signaled or reset
|
||||
* @retval RDY_TIMEOUT if the binary semaphore has not been signaled or reset
|
||||
* within the specified timeout.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chBSemWaitTimeout(bsp, time) chSemWaitTimeout(&bsp->bs_sem, time)
|
||||
|
||||
|
@ -140,11 +154,15 @@ typedef struct {
|
|||
* - @a TIME_IMMEDIATE immediate timeout.
|
||||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @retval RDY_OK if the binary semaphore had been successfully taken.
|
||||
* @return A message specifying how the invoking thread has been
|
||||
* released from the semaphore.
|
||||
* @retval RDY_OK if the binary semaphore has been successfully taken.
|
||||
* @retval RDY_RESET if the binary semaphore has been reset using
|
||||
* @p bsemReset().
|
||||
* @retval RDY_TIMEOUT if the binary semaphore was not signaled or reset
|
||||
* @retval RDY_TIMEOUT if the binary semaphore has not been signaled or reset
|
||||
* within the specified timeout.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#define chBSemWaitTimeoutS(bsp, time) chSemWaitTimeoutS(&bsp->bs_sem, time)
|
||||
|
||||
|
@ -159,6 +177,8 @@ typedef struct {
|
|||
* - @a FALSE, the new state is not taken.
|
||||
* - @a TRUE, the new state is taken.
|
||||
* .
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chBSemReset(bsp, taken) chSemReset(&bsp->bs_sem, taken ? 0 : 1)
|
||||
|
||||
|
@ -174,6 +194,8 @@ typedef struct {
|
|||
* - @a FALSE, the new state is not taken.
|
||||
* - @a TRUE, the new state is taken.
|
||||
* .
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chBSemResetI(bsp, taken) chSemResetI(&bsp->bs_sem, taken ? 0 : 1)
|
||||
|
||||
|
@ -181,6 +203,8 @@ typedef struct {
|
|||
* @brief Performs a signal operation on a binary semaphore.
|
||||
*
|
||||
* @param[in] bsp pointer to a @p BinarySemaphore structure
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chBSemSignal(bsp) { \
|
||||
chSysLock(); \
|
||||
|
@ -194,6 +218,8 @@ typedef struct {
|
|||
* @note This function does not reschedule.
|
||||
*
|
||||
* @param[in] bsp pointer to a @p BinarySemaphore structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chBSemSignalI(bsp) { \
|
||||
if (bsp->bs_sem.s_cnt < 1) \
|
||||
|
@ -207,6 +233,8 @@ typedef struct {
|
|||
* @return The binary semaphore current state.
|
||||
* @retval FALSE if the binary semaphore is not taken.
|
||||
* @retval TRUE if the binary semaphore is taken.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chBSemGetStateI(bsp) ((bsp)->bs_sem.s_cnt > 0 ? 0 : 1)
|
||||
|
||||
|
|
|
@ -91,6 +91,8 @@ typedef struct {
|
|||
*
|
||||
* @param[in] c the condition to be verified to be true
|
||||
* @param[in] func the undecorated function name
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chDbgCheck(c, func) { \
|
||||
if (!(c)) \
|
||||
|
@ -117,6 +119,8 @@ typedef struct {
|
|||
* @param[in] c the condition to be verified to be true
|
||||
* @param[in] m the text message
|
||||
* @param[in] r a remark string
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chDbgAssert(c, m, r) { \
|
||||
if (!(c)) \
|
||||
|
|
|
@ -90,6 +90,8 @@ typedef struct EventSource {
|
|||
* function.
|
||||
* The value must range between zero and the size, in bit,
|
||||
* of the @p eventid_t type minus one.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chEvtRegister(esp, elp, eid) \
|
||||
chEvtRegisterMask(esp, elp, EVENT_MASK(eid))
|
||||
|
@ -100,17 +102,20 @@ typedef struct EventSource {
|
|||
* because it just prepares a @p EventSource structure.
|
||||
*
|
||||
* @param[in] esp pointer to the @p EventSource structure
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
#define chEvtInit(esp) \
|
||||
((esp)->es_next = (EventListener *)(void *)(esp))
|
||||
|
||||
/**
|
||||
* @brief Verifies if there is at least one @p EventListener registered.
|
||||
* @note Can be called with interrupts disabled or enabled.
|
||||
*
|
||||
* @param[in] esp pointer to the @p EventSource structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chEvtIsListening(esp) \
|
||||
#define chEvtIsListeningI(esp) \
|
||||
((void *)(esp) != (void *)(esp)->es_next)
|
||||
|
||||
/**
|
||||
|
|
|
@ -96,6 +96,8 @@ typedef struct {
|
|||
* @details The function closes a file stream.
|
||||
*
|
||||
* @param[in] ip pointer to a @p BaseFileStream or derived class
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chFileStreamClose(ip) ((ip)->vmt->close(ip))
|
||||
|
||||
|
@ -103,6 +105,8 @@ typedef struct {
|
|||
* @brief Returns an implementation dependent error code.
|
||||
*
|
||||
* @param[in] ip pointer to a @p BaseFileStream or derived class
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chFileStreamGetError ((ip)->vmt->geterror(ip))
|
||||
|
||||
|
@ -110,6 +114,8 @@ typedef struct {
|
|||
* @brief Returns the current file size.
|
||||
*
|
||||
* @param[in] ip pointer to a @p BaseFileStream or derived class
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chFileStreamGetSize ((ip)->vmt->getposition(ip))
|
||||
|
||||
|
@ -117,6 +123,8 @@ typedef struct {
|
|||
* @brief Returns the current file pointer position.
|
||||
*
|
||||
* @param[in] ip pointer to a @p BaseFileStream or derived class
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chFileStreamGetPosition ((ip)->vmt->getposition(ip))
|
||||
|
||||
|
@ -125,6 +133,8 @@ typedef struct {
|
|||
*
|
||||
* @param[in] ip pointer to a @p BaseFileStream or derived class
|
||||
* @param[in] offset new absolute position
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chFileStreamSeek ((ip)->vmt->lseek(ip, offset))
|
||||
|
||||
|
|
|
@ -91,11 +91,13 @@ typedef struct {
|
|||
* block.
|
||||
*
|
||||
* @param[in] ip pointer to a @p BaseChannel or derived class
|
||||
* @return The output queue status:
|
||||
* @return The output queue status.
|
||||
* @retval FALSE if the output queue has space and would not block a
|
||||
* write operation.
|
||||
* @retval TRUE if the output queue is full and would block a write
|
||||
* operation.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOPutWouldBlock(ip) ((ip)->vmt->putwouldblock(ip))
|
||||
|
||||
|
@ -105,11 +107,13 @@ typedef struct {
|
|||
* block.
|
||||
*
|
||||
* @param[in] ip pointer to a @p BaseChannel or derived class
|
||||
* @return The input queue status:
|
||||
* @return The input queue status.
|
||||
* @retval FALSE if the input queue contains data and would not block a
|
||||
* read operation.
|
||||
* @retval TRUE if the input queue is empty and would block a read
|
||||
* operation.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOGetWouldBlock(ip) ((ip)->vmt->getwouldblock(ip))
|
||||
|
||||
|
@ -120,9 +124,11 @@ typedef struct {
|
|||
*
|
||||
* @param[in] ip pointer to a @p BaseChannel or derived class
|
||||
* @param[in] b the byte value to be written to the channel
|
||||
* @return The operation status:
|
||||
* @return The operation status.
|
||||
* @retval Q_OK if the operation succeeded.
|
||||
* @retval Q_RESET if the channel associated queue (if any) was reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOPut(ip, b) ((ip)->vmt->put(ip, b, TIME_INFINITE))
|
||||
|
||||
|
@ -138,10 +144,12 @@ typedef struct {
|
|||
* - @a TIME_IMMEDIATE immediate timeout.
|
||||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @return The operation status:
|
||||
* @return The operation status.
|
||||
* @retval Q_OK if the operation succeeded.
|
||||
* @retval Q_TIMEOUT if the specified time expired.
|
||||
* @retval Q_RESET if the channel associated queue (if any) was reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOPutTimeout(ip, b, time) ((ip)->vmt->put(ip, b, time))
|
||||
|
||||
|
@ -151,8 +159,11 @@ typedef struct {
|
|||
* is not available then the calling thread is suspended.
|
||||
*
|
||||
* @param[in] ip pointer to a @p BaseChannel or derived class
|
||||
* @return A byte value from the queue or:
|
||||
* @retval Q_RESET if the channel associated queue (if any) was reset.
|
||||
* @return A byte value from the queue.
|
||||
* @retval Q_RESET if the channel associated queue (if any) has been
|
||||
* reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOGet(ip) ((ip)->vmt->get(ip, TIME_INFINITE))
|
||||
|
||||
|
@ -167,9 +178,12 @@ typedef struct {
|
|||
* - @a TIME_IMMEDIATE immediate timeout.
|
||||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @return A byte value from the queue or:
|
||||
* @return A byte value from the queue.
|
||||
* @retval Q_TIMEOUT if the specified time expired.
|
||||
* @retval Q_RESET if the channel associated queue (if any) was reset.
|
||||
* @retval Q_RESET if the channel associated queue (if any) has been
|
||||
* reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOGetTimeout(ip, time) ((ip)->vmt->get(ip, time))
|
||||
|
||||
|
@ -187,6 +201,8 @@ typedef struct {
|
|||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @return The number of bytes transferred.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOWriteTimeout(ip, bp, n, time) \
|
||||
((ip)->vmt->writet(ip, bp, n, time))
|
||||
|
@ -205,6 +221,8 @@ typedef struct {
|
|||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @return The number of bytes transferred.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOReadTimeout(ip, bp, n, time) \
|
||||
((ip)->vmt->readt(ip, bp, n, time))
|
||||
|
@ -255,6 +273,8 @@ typedef struct {
|
|||
* @param[in] ip pointer to a @p BaseAsynchronousChannel or derived
|
||||
* class
|
||||
* @return A pointer to an @p EventSource object.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOGetWriteEventSource(ip) (&((ip)->vmt->oevent))
|
||||
|
||||
|
@ -267,6 +287,8 @@ typedef struct {
|
|||
* @param[in] ip pointer to a @p BaseAsynchronousChannel or derived
|
||||
* class
|
||||
* @return A pointer to an @p EventSource object.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIOGetReadEventSource(ip) (&((ip)->vmt->ievent))
|
||||
|
||||
|
|
|
@ -35,23 +35,31 @@ typedef struct Thread Thread;
|
|||
|
||||
/**
|
||||
* @brief Threads queue initialization.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
#define queue_init(tqp) ((tqp)->p_next = (tqp)->p_prev = (Thread *)(tqp));
|
||||
|
||||
/**
|
||||
* @brief Threads list initialization.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
#define list_init(tlp) ((tlp)->p_next = (Thread *)(tlp))
|
||||
|
||||
/**
|
||||
* @brief Evaluates to @p TRUE if the specified threads queue or list is
|
||||
* empty.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
#define isempty(p) ((p)->p_next == (Thread *)(p))
|
||||
|
||||
/**
|
||||
* @brief Evaluates to @p TRUE if the specified threads queue or list is
|
||||
* not empty.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
#define notempty(p) ((p)->p_next != (Thread *)(p))
|
||||
|
||||
|
|
|
@ -72,8 +72,10 @@ extern "C" {
|
|||
* @brief Returns the mailbox buffer size.
|
||||
*
|
||||
* @param[in] mbp the pointer to an initialized Mailbox object
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chMBSize(mbp) \
|
||||
#define chMBSizeI(mbp) \
|
||||
((mbp)->mb_top - (mbp)->mb_buffer)
|
||||
|
||||
/**
|
||||
|
@ -85,8 +87,10 @@ extern "C" {
|
|||
*
|
||||
* @param[in] mbp the pointer to an initialized Mailbox object
|
||||
* @return The number of empty message slots.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chMBGetEmpty(mbp) chSemGetCounterI(&(mbp)->mb_emptysem)
|
||||
#define chMBGetEmptyI(mbp) chSemGetCounterI(&(mbp)->mb_emptysem)
|
||||
|
||||
/**
|
||||
* @brief Returns the number of messages into the mailbox.
|
||||
|
@ -97,8 +101,10 @@ extern "C" {
|
|||
*
|
||||
* @param[in] mbp the pointer to an initialized Mailbox object
|
||||
* @return The number of queued messages.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chMBGetFull(mbp) chSemGetCounterI(&(mbp)->mb_fullsem)
|
||||
#define chMBGetFullI(mbp) chSemGetCounterI(&(mbp)->mb_fullsem)
|
||||
|
||||
/**
|
||||
* @brief Returns the next message in the queue without removing it.
|
||||
|
@ -106,8 +112,10 @@ extern "C" {
|
|||
* or it would return garbage. The correct way to use this macro is
|
||||
* to use @p chMBGetFull() and then use this macro, all within a
|
||||
* lock state.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chMBPeek(mbp) (*(mbp)->mb_rdptr)
|
||||
#define chMBPeekI(mbp) (*(mbp)->mb_rdptr)
|
||||
|
||||
/**
|
||||
* @brief Data part of a static mailbox initializer.
|
||||
|
|
|
@ -32,12 +32,16 @@
|
|||
|
||||
/**
|
||||
* @brief Evaluates to TRUE if the thread has pending messages.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chMsgIsPendingI(tp) \
|
||||
((tp)->p_msgqueue.p_next != (Thread *)&(tp)->p_msgqueue)
|
||||
|
||||
/**
|
||||
* @brief Returns the first message in the queue.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chMsgGetI(tp) \
|
||||
((tp)->p_msgqueue.p_next->p_msg)
|
||||
|
|
|
@ -78,6 +78,8 @@ extern "C" {
|
|||
/**
|
||||
* @brief Returns @p TRUE if the mutex queue contains at least a waiting
|
||||
* thread.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#define chMtxQueueNotEmptyS(mp) notempty(&(mp)->m_queue)
|
||||
|
||||
|
|
|
@ -72,8 +72,10 @@ typedef struct {
|
|||
|
||||
/**
|
||||
* @brief Returns the queue's buffer size.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chQSize(q) ((q)->q_top - (q)->q_buffer)
|
||||
#define chQSizeI(q) ((q)->q_top - (q)->q_buffer)
|
||||
|
||||
/**
|
||||
* @brief Queue space.
|
||||
|
@ -81,8 +83,10 @@ typedef struct {
|
|||
* space if used on an Output Queue.
|
||||
* @note The returned value can be less than zero when there are waiting
|
||||
* threads on the internal semaphore.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chQSpace(q) chSemGetCounterI(&(q)->q_sem)
|
||||
#define chQSpaceI(q) chSemGetCounterI(&(q)->q_sem)
|
||||
|
||||
/**
|
||||
* @extends GenericQueue
|
||||
|
@ -97,11 +101,19 @@ typedef struct {
|
|||
*/
|
||||
typedef GenericQueue InputQueue;
|
||||
|
||||
/** @brief Evaluates to @p TRUE if the specified Input Queue is empty.*/
|
||||
#define chIQIsEmpty(q) ((bool_t)(chQSpace(q) <= 0))
|
||||
/**
|
||||
* @brief Evaluates to @p TRUE if the specified Input Queue is empty.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chIQIsEmptyI(q) ((bool_t)(chQSpaceI(q) <= 0))
|
||||
|
||||
/** @brief Evaluates to @p TRUE if the specified Input Queue is full.*/
|
||||
#define chIQIsFull(q) ((bool_t)(chQSpace(q) >= chQSize(q)))
|
||||
/**
|
||||
* @brief Evaluates to @p TRUE if the specified Input Queue is full.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chIQIsFullI(q) ((bool_t)(chQSpaceI(q) >= chQSizeI(q)))
|
||||
|
||||
/**
|
||||
* @brief Input queue read.
|
||||
|
@ -110,8 +122,10 @@ typedef GenericQueue InputQueue;
|
|||
* in the queue.
|
||||
*
|
||||
* @param[in] iqp pointer to an @p InputQueue structure
|
||||
* @return A byte value from the queue or:
|
||||
* @return A byte value from the queue.
|
||||
* @retval Q_RESET if the queue was reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chIQGet(iqp) chIQGetTimeout(iqp, TIME_INFINITE)
|
||||
|
||||
|
@ -162,13 +176,17 @@ typedef GenericQueue OutputQueue;
|
|||
|
||||
/**
|
||||
* @brief Evaluates to @p TRUE if the specified Output Queue is empty.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chOQIsEmpty(q) ((bool_t)(chQSpace(q) >= chQSize(q)))
|
||||
#define chOQIsEmptyI(q) ((bool_t)(chQSpaceI(q) >= chQSizeI(q)))
|
||||
|
||||
/**
|
||||
* @brief Evaluates to @p TRUE if the specified Output Queue is full.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chOQIsFull(q) ((bool_t)(chQSpace(q) <= 0))
|
||||
#define chOQIsFullI(q) ((bool_t)(chQSpaceI(q) <= 0))
|
||||
|
||||
/**
|
||||
* @brief Output queue write.
|
||||
|
@ -178,9 +196,11 @@ typedef GenericQueue OutputQueue;
|
|||
*
|
||||
* @param[in] oqp pointer to an @p OutputQueue structure
|
||||
* @param[in] b the byte value to be written in the queue
|
||||
* @return The operation status:
|
||||
* @return The operation status.
|
||||
* @retval Q_OK if the operation succeeded.
|
||||
* @retval Q_RESET if the queue was reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chOQPut(oqp, b) chOQPutTimeout(oqp, b, TIME_INFINITE)
|
||||
|
||||
|
|
|
@ -58,6 +58,8 @@
|
|||
|
||||
/**
|
||||
* @brief Returns the priority of the first thread on the given ready list.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
#define firstprio(rlp) ((rlp)->p_next->p_prio)
|
||||
|
||||
|
@ -111,6 +113,8 @@ register Thread *currp asm(CH_CURRP_REGISTER_CACHE);
|
|||
* @brief Current thread pointer change macro.
|
||||
* @note This macro is not meant to be used in the application code but
|
||||
* only from within the kernel.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_SETCURRP) || defined(__DOXYGEN__)
|
||||
#define setcurrp(tp) (currp = (tp))
|
||||
|
@ -152,6 +156,8 @@ extern "C" {
|
|||
* @brief Determines if the current thread must reschedule.
|
||||
* @details This function returns @p TRUE if there is a ready thread with
|
||||
* higher priority.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_ISRESCHREQUIREDI) || defined(__DOXYGEN__)
|
||||
#define chSchIsRescRequiredI() (firstprio(&rlist.r_queue) > currp->p_prio)
|
||||
|
@ -161,6 +167,8 @@ extern "C" {
|
|||
* @brief Determines if yielding is possible.
|
||||
* @details This function returns @p TRUE if there is a ready thread with
|
||||
* equal or higher priority.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_CANYIELDS) || defined(__DOXYGEN__)
|
||||
#define chSchCanYieldS() (firstprio(&rlist.r_queue) >= currp->p_prio)
|
||||
|
@ -170,6 +178,8 @@ extern "C" {
|
|||
* @brief Yields the time slot.
|
||||
* @details Yields the CPU control to the next thread in the ready list with
|
||||
* equal or higher priority, if any.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_DOYIELDS) || defined(__DOXYGEN__)
|
||||
#define chSchDoYieldS() { \
|
||||
|
|
|
@ -83,17 +83,24 @@ extern "C" {
|
|||
/**
|
||||
* @brief Decreases the semaphore counter.
|
||||
* @details This macro can be used when the counter is known to be positive.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chSemFastWaitI(sp) ((sp)->s_cnt--)
|
||||
|
||||
/**
|
||||
* @brief Increases the semaphore counter.
|
||||
* @details This macro can be used when the counter is known to be not negative.
|
||||
* @details This macro can be used when the counter is known to be not
|
||||
* negative.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chSemFastSignalI(sp) ((sp)->s_cnt++)
|
||||
|
||||
/**
|
||||
* @brief Returns the semaphore counter current value.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chSemGetCounterI(sp) ((sp)->s_cnt)
|
||||
|
||||
|
|
|
@ -83,6 +83,8 @@ typedef struct {
|
|||
* be less than the specified number of bytes if the
|
||||
* stream reaches a physical end of file and cannot be
|
||||
* extended.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chSequentialStreamWrite(ip, bp, n) ((ip)->vmt->write(ip, bp, n))
|
||||
|
||||
|
@ -96,6 +98,8 @@ typedef struct {
|
|||
* @return The number of bytes transferred. The return value can
|
||||
* be less than the specified number of bytes if the
|
||||
* stream reaches the end of the available data.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chSequentialStreamRead(ip, bp, n) ((ip)->vmt->read(ip, bp, n))
|
||||
|
||||
|
|
|
@ -35,6 +35,8 @@
|
|||
* object.
|
||||
*
|
||||
* @return Pointer to the idle thread,
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chSysGetIdleThread() ((Thread *)_idle_thread_wa)
|
||||
|
||||
|
@ -44,6 +46,9 @@
|
|||
* unrecoverable error is detected, as 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.
|
||||
*
|
||||
* @special
|
||||
*/
|
||||
#if !defined(SYSTEM_HALT_HOOK) || defined(__DOXYGEN__)
|
||||
#define chSysHalt() port_halt()
|
||||
|
@ -56,9 +61,12 @@
|
|||
|
||||
/**
|
||||
* @brief Performs a context switch.
|
||||
* @note This function should nevel be used from user code directly.
|
||||
*
|
||||
* @param[in] ntp the thread to be switched in
|
||||
* @param[in] otp the thread to be switched out
|
||||
*
|
||||
* @special
|
||||
*/
|
||||
#define chSysSwitchI(ntp, otp) port_switch(ntp, otp)
|
||||
|
||||
|
@ -66,9 +74,9 @@
|
|||
* @brief Raises the system interrupt priority mask to the maximum level.
|
||||
* @details All the maskable interrupt sources are disabled regardless their
|
||||
* hardware priority.
|
||||
* @note The implementation is architecture dependent, it may just disable
|
||||
* the interrupts or be exactly equivalent to @p chSysDisable().
|
||||
* @note Do not invoke this API from within a kernel lock.
|
||||
*
|
||||
* @special
|
||||
*/
|
||||
#define chSysDisable() port_disable()
|
||||
|
||||
|
@ -77,22 +85,22 @@
|
|||
* @details The interrupt sources that should not be able to preempt the kernel
|
||||
* are disabled, interrupt sources with higher priority are still
|
||||
* enabled.
|
||||
* @note The implementation is architecture dependent, it may just disable
|
||||
* the interrupts.
|
||||
* @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
|
||||
*/
|
||||
#define chSysSuspend() port_suspend()
|
||||
|
||||
/**
|
||||
* @brief Lowers the system interrupt priority mask to user level.
|
||||
* @details All the interrupt sources are enabled.
|
||||
* @note The implementation is architecture dependent, it may just enable
|
||||
* the interrupts.
|
||||
* @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
|
||||
*/
|
||||
#define chSysEnable() port_enable()
|
||||
|
||||
|
@ -101,6 +109,8 @@
|
|||
* @note The use of kernel lock mode is not recommended in the user code,
|
||||
* it is a better idea to use the semaphores or mutexes instead.
|
||||
* @see CH_USE_NESTED_LOCKS
|
||||
*
|
||||
* @special
|
||||
*/
|
||||
#if CH_USE_NESTED_LOCKS || defined(__DOXYGEN__)
|
||||
#if CH_OPTIMIZE_SPEED || defined(__DOXYGEN__)
|
||||
|
@ -118,6 +128,8 @@
|
|||
* @note The use of kernel lock mode is not recommended in the user code,
|
||||
* it is a better idea to use the semaphores or mutexes instead.
|
||||
* @see CH_USE_NESTED_LOCKS
|
||||
*
|
||||
* @special
|
||||
*/
|
||||
#if CH_USE_NESTED_LOCKS || defined(__DOXYGEN__)
|
||||
#if CH_OPTIMIZE_SPEED || defined(__DOXYGEN__)
|
||||
|
@ -139,6 +151,8 @@
|
|||
* 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
|
||||
*/
|
||||
#define chSysLockFromIsr() port_lock_from_isr()
|
||||
|
||||
|
@ -151,7 +165,9 @@
|
|||
* 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.
|
||||
* @note This API must be invoked exclusively from interrupt handlers.
|
||||
*
|
||||
* @special
|
||||
*/
|
||||
#define chSysUnlockFromIsr() port_unlock_from_isr()
|
||||
|
||||
|
|
|
@ -244,11 +244,15 @@ extern "C" {
|
|||
|
||||
/**
|
||||
* @brief Returns a pointer to the current @p Thread.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdSelf() currp
|
||||
|
||||
/**
|
||||
* @brief Returns the current thread priority.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdGetPriority() (currp->p_prio)
|
||||
|
||||
|
@ -258,11 +262,15 @@ extern "C" {
|
|||
* @p CH_DBG_THREADS_PROFILING configuration option is enabled.
|
||||
*
|
||||
* @param[in] tp the pointer to the thread
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdGetTicks(tp) ((tp)->p_time)
|
||||
|
||||
/**
|
||||
* @brief Returns the pointer to the @p Thread local storage area, if any.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdLS() (void *)(currp + 1)
|
||||
|
||||
|
@ -272,6 +280,8 @@ extern "C" {
|
|||
* @param[in] tp the pointer to the thread
|
||||
* @retval TRUE thread terminated.
|
||||
* @retval FALSE thread not terminated.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdTerminated(tp) ((tp)->p_state == THD_STATE_FINAL)
|
||||
|
||||
|
@ -280,6 +290,8 @@ extern "C" {
|
|||
*
|
||||
* @retval TRUE termination request pended.
|
||||
* @retval FALSE termination request not pended.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdShouldTerminate() (currp->p_flags & THD_TERMINATE)
|
||||
|
||||
|
@ -287,6 +299,8 @@ extern "C" {
|
|||
* @brief Resumes a thread created with @p chThdInit().
|
||||
*
|
||||
* @param[in] tp the pointer to the thread
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chThdResumeI(tp) chSchReadyI(tp)
|
||||
|
||||
|
@ -301,6 +315,8 @@ extern "C" {
|
|||
* interpreted as a normal time specification not as
|
||||
* an immediate timeout specification.
|
||||
* .
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#define chThdSleepS(time) chSchGoSleepTimeoutS(THD_STATE_SLEEPING, time)
|
||||
|
||||
|
@ -311,6 +327,8 @@ extern "C" {
|
|||
* @note The maximum specified value is implementation dependent.
|
||||
*
|
||||
* @param[in] sec the time in seconds
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdSleepSeconds(sec) chThdSleep(S2ST(sec))
|
||||
|
||||
|
@ -322,6 +340,8 @@ extern "C" {
|
|||
* @note The maximum specified value is implementation dependent.
|
||||
*
|
||||
* @param[in] msec the time in milliseconds
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdSleepMilliseconds(msec) chThdSleep(MS2ST(msec))
|
||||
|
||||
|
@ -333,6 +353,8 @@ extern "C" {
|
|||
* @note The maximum specified value is implementation dependent.
|
||||
*
|
||||
* @param[in] usec the time in microseconds
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chThdSleepMicroseconds(usec) chThdSleep(US2ST(usec))
|
||||
|
||||
|
|
|
@ -94,6 +94,8 @@ extern VTList vtlist;
|
|||
|
||||
/**
|
||||
* @brief Virtual timers ticker.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chVTDoTickI() { \
|
||||
vtlist.vt_systime++; \
|
||||
|
@ -127,6 +129,8 @@ extern "C" {
|
|||
|
||||
/**
|
||||
* @brief Returns TRUE if the speciified timer is armed.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#define chVTIsArmedI(vtp) ((vtp)->vt_func != NULL)
|
||||
|
||||
|
@ -138,6 +142,8 @@ extern "C" {
|
|||
* @note This function is designed to work with the @p chThdSleepUntil().
|
||||
*
|
||||
* @return The system time in ticks.r
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
#define chTimeNow() (vtlist.vt_systime)
|
||||
|
||||
|
|
|
@ -43,10 +43,10 @@
|
|||
|
||||
/**
|
||||
* @brief Initializes s @p CondVar structure.
|
||||
* @note This function can be invoked before the kernel is initialized
|
||||
* because it just prepares a @p CondVar structure.
|
||||
*
|
||||
* @param[out] cp pointer to a @p CondVar structure
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chCondInit(CondVar *cp) {
|
||||
|
||||
|
@ -59,6 +59,8 @@ void chCondInit(CondVar *cp) {
|
|||
* @brief Signals one thread that is waiting on the condition variable.
|
||||
*
|
||||
* @param[in] cp pointer to the @p CondVar structure
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chCondSignal(CondVar *cp) {
|
||||
|
||||
|
@ -78,6 +80,8 @@ void chCondSignal(CondVar *cp) {
|
|||
* reschedule must not be performed in ISRs.
|
||||
*
|
||||
* @param[in] cp pointer to the @p CondVar structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chCondSignalI(CondVar *cp) {
|
||||
|
||||
|
@ -91,6 +95,8 @@ void chCondSignalI(CondVar *cp) {
|
|||
* @brief Signals all threads that are waiting on the condition variable.
|
||||
*
|
||||
* @param[in] cp pointer to the @p CondVar structure
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chCondBroadcast(CondVar *cp) {
|
||||
|
||||
|
@ -108,6 +114,8 @@ void chCondBroadcast(CondVar *cp) {
|
|||
* reschedule must not be performed in ISRs.
|
||||
*
|
||||
* @param[in] cp pointer to the @p CondVar structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chCondBroadcastI(CondVar *cp) {
|
||||
|
||||
|
@ -134,6 +142,8 @@ void chCondBroadcastI(CondVar *cp) {
|
|||
* @p chCondSignal().
|
||||
* @retval RDY_RESET if the condvar has been signaled using
|
||||
* @p chCondBroadcast().
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chCondWait(CondVar *cp) {
|
||||
msg_t msg;
|
||||
|
@ -158,6 +168,8 @@ msg_t chCondWait(CondVar *cp) {
|
|||
* @p chCondSignal().
|
||||
* @retval RDY_RESET if the condvar has been signaled using
|
||||
* @p chCondBroadcast().
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chCondWaitS(CondVar *cp) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -204,6 +216,8 @@ msg_t chCondWaitS(CondVar *cp) {
|
|||
* @p chCondBroadcast().
|
||||
* @retval RDY_TIMEOUT if the condvar has not been signaled within the
|
||||
* specified timeout.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chCondWaitTimeout(CondVar *cp, systime_t time) {
|
||||
msg_t msg;
|
||||
|
@ -239,6 +253,8 @@ msg_t chCondWaitTimeout(CondVar *cp, systime_t time) {
|
|||
* @p chCondBroadcast().
|
||||
* @retval RDY_TIMEOUT if the condvar has not been signaled within the
|
||||
* specified timeout.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chCondWaitTimeoutS(CondVar *cp, systime_t time) {
|
||||
Mutex *mp;
|
||||
|
|
|
@ -55,6 +55,8 @@ void trace_init(void) {
|
|||
* @brief Inserts in the circular debug trace buffer a context switch record.
|
||||
*
|
||||
* @param[in] otp the thread being switched out
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void chDbgTrace(Thread *otp) {
|
||||
|
||||
|
|
|
@ -68,6 +68,8 @@
|
|||
* @param[in] elp pointer to the @p EventListener structure
|
||||
* @param[in] mask the mask of event flags to be ORed to the thread when
|
||||
* the event source is broadcasted
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chEvtRegisterMask(EventSource *esp, EventListener *elp, eventmask_t mask) {
|
||||
|
||||
|
@ -91,6 +93,8 @@ void chEvtRegisterMask(EventSource *esp, EventListener *elp, eventmask_t mask) {
|
|||
*
|
||||
* @param[in] esp pointer to the @p EventSource structure
|
||||
* @param[in] elp pointer to the @p EventListener structure
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chEvtUnregister(EventSource *esp, EventListener *elp) {
|
||||
EventListener *p;
|
||||
|
@ -114,6 +118,8 @@ void chEvtUnregister(EventSource *esp, EventListener *elp) {
|
|||
*
|
||||
* @param[in] mask the events to be cleared
|
||||
* @return The pending events that were cleared.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
eventmask_t chEvtClearFlags(eventmask_t mask) {
|
||||
eventmask_t m;
|
||||
|
@ -133,6 +139,8 @@ eventmask_t chEvtClearFlags(eventmask_t mask) {
|
|||
*
|
||||
* @param[in] mask the event flags to be ORed
|
||||
* @return The current pending events mask.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
eventmask_t chEvtAddFlags(eventmask_t mask) {
|
||||
|
||||
|
@ -149,6 +157,8 @@ eventmask_t chEvtAddFlags(eventmask_t mask) {
|
|||
*
|
||||
* @param[in] tp the thread to be signaled
|
||||
* @param[in] mask the event flags set to be ORed
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chEvtSignal(Thread *tp, eventmask_t mask) {
|
||||
|
||||
|
@ -169,6 +179,8 @@ void chEvtSignal(Thread *tp, eventmask_t mask) {
|
|||
*
|
||||
* @param[in] tp the thread to be signaled
|
||||
* @param[in] mask the event flags set to be ORed
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chEvtSignalI(Thread *tp, eventmask_t mask) {
|
||||
|
||||
|
@ -188,6 +200,8 @@ void chEvtSignalI(Thread *tp, eventmask_t mask) {
|
|||
* Source.
|
||||
*
|
||||
* @param[in] esp pointer to the @p EventSource structure
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chEvtBroadcast(EventSource *esp) {
|
||||
|
||||
|
@ -206,6 +220,8 @@ void chEvtBroadcast(EventSource *esp) {
|
|||
* reschedule must not be performed in ISRs.
|
||||
*
|
||||
* @param[in] esp pointer to the @p EventSource structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chEvtBroadcastI(EventSource *esp) {
|
||||
EventListener *elp;
|
||||
|
@ -225,6 +241,8 @@ void chEvtBroadcastI(EventSource *esp) {
|
|||
* @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
|
||||
*/
|
||||
void chEvtDispatch(const evhandler_t *handlers, eventmask_t mask) {
|
||||
eventid_t eid;
|
||||
|
@ -258,6 +276,8 @@ void chEvtDispatch(const evhandler_t *handlers, eventmask_t mask) {
|
|||
* @param[in] mask mask of the event flags 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
|
||||
*/
|
||||
eventmask_t chEvtWaitOne(eventmask_t mask) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -285,6 +305,8 @@ eventmask_t chEvtWaitOne(eventmask_t mask) {
|
|||
* @param[in] mask mask of the event flags that the function should wait
|
||||
* for, @p ALL_EVENTS enables all the events
|
||||
* @return The mask of the served and cleared events.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
eventmask_t chEvtWaitAny(eventmask_t mask) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -311,6 +333,8 @@ eventmask_t chEvtWaitAny(eventmask_t mask) {
|
|||
* @param[in] mask mask of the event flags that the function should wait
|
||||
* for, @p ALL_EVENTS requires all the events
|
||||
* @return The mask of the served and cleared events.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
eventmask_t chEvtWaitAll(eventmask_t mask) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -348,6 +372,8 @@ eventmask_t chEvtWaitAll(eventmask_t mask) {
|
|||
* .
|
||||
* @return The mask of the lowest id served and cleared event.
|
||||
* @retval 0 if the operation has timed out.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
eventmask_t chEvtWaitOneTimeout(eventmask_t mask, systime_t time) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -385,6 +411,8 @@ eventmask_t chEvtWaitOneTimeout(eventmask_t mask, systime_t time) {
|
|||
* .
|
||||
* @return The mask of the served and cleared events.
|
||||
* @retval 0 if the operation has timed out.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
eventmask_t chEvtWaitAnyTimeout(eventmask_t mask, systime_t time) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -420,6 +448,8 @@ eventmask_t chEvtWaitAnyTimeout(eventmask_t mask, systime_t time) {
|
|||
* .
|
||||
* @return The mask of the served and cleared events.
|
||||
* @retval 0 if the operation has timed out.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
eventmask_t chEvtWaitAllTimeout(eventmask_t mask, systime_t time) {
|
||||
Thread *ctp = currp;
|
||||
|
|
|
@ -61,7 +61,8 @@ static MemoryHeap default_heap;
|
|||
|
||||
/**
|
||||
* @brief Initializes the default heap.
|
||||
* @note Internal use only.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void heap_init(void) {
|
||||
default_heap.h_provider = chCoreAlloc;
|
||||
|
@ -82,6 +83,8 @@ void heap_init(void) {
|
|||
* @param[out] heapp pointer to the memory heap descriptor to be initialized
|
||||
* @param[in] buf heap buffer base
|
||||
* @param[in] size heap size
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chHeapInit(MemoryHeap *heapp, void *buf, size_t size) {
|
||||
union heap_header *hp;
|
||||
|
@ -113,6 +116,8 @@ void chHeapInit(MemoryHeap *heapp, void *buf, size_t size) {
|
|||
* size for alignment and fragmentation reasons.
|
||||
* @return A pointer to the allocated block.
|
||||
* @retval NULL if the block cannot be allocated.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void *chHeapAlloc(MemoryHeap *heapp, size_t size) {
|
||||
union heap_header *qp, *hp, *fp;
|
||||
|
@ -173,6 +178,8 @@ void *chHeapAlloc(MemoryHeap *heapp, size_t size) {
|
|||
* @brief Frees a previously allocated memory block.
|
||||
*
|
||||
* @param[in] p pointer to the memory block to be freed
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chHeapFree(void *p) {
|
||||
union heap_header *qp, *hp;
|
||||
|
@ -227,6 +234,8 @@ void chHeapFree(void *p) {
|
|||
* @param[in] sizep pointer to a variable that will receive the total
|
||||
* fragmented free space
|
||||
* @return The number of fragments in the heap.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
size_t chHeapStatus(MemoryHeap *heapp, size_t *sizep) {
|
||||
union heap_header *qp;
|
||||
|
|
|
@ -23,7 +23,7 @@
|
|||
*
|
||||
* @addtogroup internals
|
||||
* @details All the functions present in this module, while public, are not
|
||||
* an OS API and should not be directly used in the user applications
|
||||
* OS APIs and should not be directly used in the user applications
|
||||
* code.
|
||||
* @{
|
||||
*/
|
||||
|
@ -32,12 +32,13 @@
|
|||
#if !CH_OPTIMIZE_SPEED || defined(__DOXYGEN__)
|
||||
/**
|
||||
* @brief Inserts a thread into a priority ordered queue.
|
||||
* @note The insertion is done by scanning the list from the highest priority
|
||||
* toward the lowest.
|
||||
* @note This function is @b not an API.
|
||||
* @note The insertion is done by scanning the list from the highest
|
||||
* priority toward the lowest.
|
||||
*
|
||||
* @param[in] tp the pointer to the thread to be inserted in the list
|
||||
* @param[in] tqp the pointer to the threads list header
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void prio_insert(Thread *tp, ThreadsQueue *tqp) {
|
||||
|
||||
|
@ -56,10 +57,11 @@ void prio_insert(Thread *tp, ThreadsQueue *tqp) {
|
|||
|
||||
/**
|
||||
* @brief Inserts a Thread into a queue.
|
||||
* @note This function is @b not an API.
|
||||
*
|
||||
* @param[in] tp the pointer to the thread to be inserted in the list
|
||||
* @param[in] tqp the pointer to the threads list header
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void queue_insert(Thread *tp, ThreadsQueue *tqp) {
|
||||
|
||||
|
@ -72,10 +74,11 @@ void queue_insert(Thread *tp, ThreadsQueue *tqp) {
|
|||
* @brief Removes the first-out Thread from a queue and returns it.
|
||||
* @note If the queue is priority ordered then this function returns the
|
||||
* thread with the highest priority.
|
||||
* @note This function is @b not an API.
|
||||
*
|
||||
* @param[in] tqp the pointer to the threads list header
|
||||
* @return The removed thread pointer.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
Thread *fifo_remove(ThreadsQueue *tqp) {
|
||||
Thread *tp = tqp->p_next;
|
||||
|
@ -88,10 +91,11 @@ Thread *fifo_remove(ThreadsQueue *tqp) {
|
|||
* @brief Removes the last-out Thread from a queue and returns it.
|
||||
* @note If the queue is priority ordered then this function returns the
|
||||
* thread with the lowest priority.
|
||||
* @note This function is @b not an API.
|
||||
*
|
||||
* @param[in] tqp the pointer to the threads list header
|
||||
* @return The removed thread pointer.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
Thread *lifo_remove(ThreadsQueue *tqp) {
|
||||
Thread *tp = tqp->p_prev;
|
||||
|
@ -104,10 +108,11 @@ Thread *lifo_remove(ThreadsQueue *tqp) {
|
|||
* @brief Removes a Thread from a queue and returns it.
|
||||
* @details The thread is removed from the queue regardless of its relative
|
||||
* position and regardless the used insertion method.
|
||||
* @note This function is @b not an API.
|
||||
*
|
||||
* @param[in] tp the pointer to the thread to be removed from the queue
|
||||
* @return The removed thread pointer.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
Thread *dequeue(Thread *tp) {
|
||||
|
||||
|
@ -118,10 +123,11 @@ Thread *dequeue(Thread *tp) {
|
|||
|
||||
/**
|
||||
* @brief Pushes a Thread on top of a stack list.
|
||||
* @note This function is @b not an API.
|
||||
*
|
||||
* @param[in] tp the pointer to the thread to be inserted in the list
|
||||
* @param[in] tlp the pointer to the threads list header
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void list_insert(Thread *tp, ThreadsList *tlp) {
|
||||
|
||||
|
@ -131,11 +137,12 @@ void list_insert(Thread *tp, ThreadsList *tlp) {
|
|||
|
||||
/**
|
||||
* @brief Pops a Thread from the top of a stack list and returns it.
|
||||
* @note The list must be non-empty before calling this function.
|
||||
* @note This function is @b not an API.
|
||||
* @pre The list must be non-empty before calling this function.
|
||||
*
|
||||
* @param[in] tlp the pointer to the threads list header
|
||||
* @return The removed thread pointer.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
Thread *list_remove(ThreadsList *tlp) {
|
||||
|
||||
|
|
|
@ -54,12 +54,12 @@
|
|||
#if CH_USE_MAILBOXES || defined(__DOXYGEN__)
|
||||
/**
|
||||
* @brief Initializes a Mailbox object.
|
||||
* @note This function can be invoked before the kernel is initialized
|
||||
* because it just prepares a @p Mailbox structure.
|
||||
*
|
||||
* @param[out] mbp the pointer to the Mailbox structure to be initialized
|
||||
* @param[in] buf the circular messages buffer
|
||||
* @param[in] n the buffer size as number of @p msg_t
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chMBInit(Mailbox *mbp, msg_t *buf, cnt_t n) {
|
||||
|
||||
|
@ -77,6 +77,8 @@ void chMBInit(Mailbox *mbp, msg_t *buf, cnt_t n) {
|
|||
* the queued messages are lost.
|
||||
*
|
||||
* @param[in] mbp the pointer to an initialized Mailbox object
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chMBReset(Mailbox *mbp) {
|
||||
|
||||
|
@ -106,6 +108,8 @@ void chMBReset(Mailbox *mbp) {
|
|||
* @retval RDY_OK if a message has been correctly posted.
|
||||
* @retval RDY_RESET if the mailbox has been reset while waiting.
|
||||
* @retval RDY_TIMEOUT if the operation has timed out.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chMBPost(Mailbox *mbp, msg_t msg, systime_t time) {
|
||||
msg_t rdymsg;
|
||||
|
@ -132,6 +136,8 @@ msg_t chMBPost(Mailbox *mbp, msg_t msg, systime_t time) {
|
|||
* @retval RDY_OK if a message has been correctly posted.
|
||||
* @retval RDY_RESET if the mailbox has been reset while waiting.
|
||||
* @retval RDY_TIMEOUT if the operation has timed out.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chMBPostS(Mailbox *mbp, msg_t msg, systime_t time) {
|
||||
msg_t rdymsg;
|
||||
|
@ -165,6 +171,8 @@ msg_t chMBPostS(Mailbox *mbp, msg_t msg, systime_t time) {
|
|||
* @retval RDY_OK if a message has been correctly posted.
|
||||
* @retval RDY_RESET if the mailbox has been reset while waiting.
|
||||
* @retval RDY_TIMEOUT if the operation has timed out.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chMBPostAhead(Mailbox *mbp, msg_t msg, systime_t time) {
|
||||
msg_t rdymsg;
|
||||
|
@ -191,6 +199,8 @@ msg_t chMBPostAhead(Mailbox *mbp, msg_t msg, systime_t time) {
|
|||
* @retval RDY_OK if a message has been correctly posted.
|
||||
* @retval RDY_RESET if the mailbox has been reset while waiting.
|
||||
* @retval RDY_TIMEOUT if the operation has timed out.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chMBPostAheadS(Mailbox *mbp, msg_t msg, systime_t time) {
|
||||
msg_t rdymsg;
|
||||
|
@ -224,6 +234,8 @@ msg_t chMBPostAheadS(Mailbox *mbp, msg_t msg, systime_t time) {
|
|||
* @retval RDY_OK if a message has been correctly fetched.
|
||||
* @retval RDY_RESET if the mailbox has been reset while waiting.
|
||||
* @retval RDY_TIMEOUT if the operation has timed out.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chMBFetch(Mailbox *mbp, msg_t *msgp, systime_t time) {
|
||||
msg_t rdymsg;
|
||||
|
@ -250,6 +262,8 @@ msg_t chMBFetch(Mailbox *mbp, msg_t *msgp, systime_t time) {
|
|||
* @retval RDY_OK if a message has been correctly fetched.
|
||||
* @retval RDY_RESET if the mailbox has been reset while waiting.
|
||||
* @retval RDY_TIMEOUT if the operation has timed out.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chMBFetchS(Mailbox *mbp, msg_t *msgp, systime_t time) {
|
||||
msg_t rdymsg;
|
||||
|
|
|
@ -50,7 +50,8 @@ static uint8_t *endmem;
|
|||
|
||||
/**
|
||||
* @brief Low level memory manager initialization.
|
||||
* @note Internal use only.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void core_init(void) {
|
||||
#if CH_MEMCORE_SIZE == 0
|
||||
|
@ -76,6 +77,8 @@ void core_init(void) {
|
|||
* @param[in] size the size of the block to be allocated
|
||||
* @return A pointer to the allocated memory block.
|
||||
* @retval NULL allocation failed, core memory exhausted.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void *chCoreAlloc(size_t size) {
|
||||
void *p;
|
||||
|
@ -95,6 +98,8 @@ void *chCoreAlloc(size_t size) {
|
|||
* @param[in] size the size of the block to be allocated.
|
||||
* @return A pointer to the allocated memory block.
|
||||
* @retval NULL allocation failed, core memory exhausted.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void *chCoreAllocI(size_t size) {
|
||||
void *p;
|
||||
|
@ -111,6 +116,8 @@ void *chCoreAllocI(size_t size) {
|
|||
* @brief Core memory status.
|
||||
*
|
||||
* @return The size, in bytes, of the free core memory.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
size_t chCoreStatus(void) {
|
||||
|
||||
|
|
|
@ -37,8 +37,6 @@
|
|||
#if CH_USE_MEMPOOLS || defined(__DOXYGEN__)
|
||||
/**
|
||||
* @brief Initializes an empty memory pool.
|
||||
* @note This function can be invoked before the kernel is initialized
|
||||
* because it just prepares a @p MemoryPool structure.
|
||||
* @note The size is internally aligned to be a multiple of the
|
||||
* @p stkalign_t type size.
|
||||
*
|
||||
|
@ -49,6 +47,8 @@
|
|||
* @param[in] provider memory provider function for the memory pool or
|
||||
* @p NULL if the pool is not allowed to grow
|
||||
* automatically
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chPoolInit(MemoryPool *mp, size_t size, memgetfunc_t provider) {
|
||||
|
||||
|
@ -65,6 +65,8 @@ void chPoolInit(MemoryPool *mp, size_t size, memgetfunc_t provider) {
|
|||
* @param[in] mp pointer to a @p MemoryPool structure
|
||||
* @return The pointer to the allocated object.
|
||||
* @retval NULL if pool is empty.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void *chPoolAllocI(MemoryPool *mp) {
|
||||
void *objp;
|
||||
|
@ -86,6 +88,8 @@ void *chPoolAllocI(MemoryPool *mp) {
|
|||
* @param[in] mp pointer to a @p MemoryPool structure
|
||||
* @return The pointer to the allocated object.
|
||||
* @retval NULL if pool is empty.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void *chPoolAlloc(MemoryPool *mp) {
|
||||
void *objp;
|
||||
|
@ -105,6 +109,8 @@ void *chPoolAlloc(MemoryPool *mp) {
|
|||
*
|
||||
* @param[in] mp pointer to a @p MemoryPool structure
|
||||
* @param[in] objp the pointer to the object to be released or added
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chPoolFreeI(MemoryPool *mp, void *objp) {
|
||||
struct pool_header *php = objp;
|
||||
|
@ -125,6 +131,8 @@ void chPoolFreeI(MemoryPool *mp, void *objp) {
|
|||
*
|
||||
* @param[in] mp pointer to a @p MemoryPool structure
|
||||
* @param[in] objp the pointer to the object to be released or added
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chPoolFree(MemoryPool *mp, void *objp) {
|
||||
|
||||
|
|
|
@ -61,6 +61,8 @@
|
|||
* @param[in] tp the pointer to the thread
|
||||
* @param[in] msg the message
|
||||
* @return The answer message from @p chMsgRelease().
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chMsgSend(Thread *tp, msg_t msg) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -88,6 +90,8 @@ msg_t chMsgSend(Thread *tp, msg_t msg) {
|
|||
* because the sending thread is suspended until then.
|
||||
*
|
||||
* @return The message.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chMsgWait(void) {
|
||||
msg_t msg;
|
||||
|
@ -114,6 +118,8 @@ msg_t chMsgWait(void) {
|
|||
*
|
||||
* @return The message.
|
||||
* @retval 0 if the queue is empty.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chMsgGet(void) {
|
||||
msg_t msg;
|
||||
|
@ -130,6 +136,8 @@ msg_t chMsgGet(void) {
|
|||
* using @p chMsgWait() or @p chMsgGet().
|
||||
*
|
||||
* @param[in] msg the message returned to the message sender
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chMsgRelease(msg_t msg) {
|
||||
|
||||
|
|
|
@ -70,10 +70,10 @@
|
|||
|
||||
/**
|
||||
* @brief Initializes s @p Mutex structure.
|
||||
* @note This function can be invoked before the kernel is initialized
|
||||
* because it just prepares a @p Mutex structure.
|
||||
*
|
||||
* @param[out] mp pointer to a @p Mutex structure
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chMtxInit(Mutex *mp) {
|
||||
|
||||
|
@ -89,6 +89,8 @@ void chMtxInit(Mutex *mp) {
|
|||
* mutexes.
|
||||
*
|
||||
* @param[in] mp pointer to the @p Mutex structure
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chMtxLock(Mutex *mp) {
|
||||
|
||||
|
@ -105,6 +107,8 @@ void chMtxLock(Mutex *mp) {
|
|||
* mutexes.
|
||||
*
|
||||
* @param[in] mp pointer to the @p Mutex structure
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
void chMtxLockS(Mutex *mp) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -184,6 +188,8 @@ void chMtxLockS(Mutex *mp) {
|
|||
* @return The operation status.
|
||||
* @retval TRUE if the mutex has been successfully acquired
|
||||
* @retval FALSE if the lock attempt failed.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
bool_t chMtxTryLock(Mutex *mp) {
|
||||
bool_t b;
|
||||
|
@ -210,6 +216,8 @@ bool_t chMtxTryLock(Mutex *mp) {
|
|||
* @return The operation status.
|
||||
* @retval TRUE if the mutex has been successfully acquired
|
||||
* @retval FALSE if the lock attempt failed.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
bool_t chMtxTryLockS(Mutex *mp) {
|
||||
|
||||
|
@ -230,6 +238,8 @@ bool_t chMtxTryLockS(Mutex *mp) {
|
|||
* owned mutexes.
|
||||
*
|
||||
* @return A pointer to the unlocked mutex.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Mutex *chMtxUnlock(void) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -288,6 +298,8 @@ Mutex *chMtxUnlock(void) {
|
|||
* function must be performed before unlocking the kernel.
|
||||
*
|
||||
* @return A pointer to the unlocked mutex.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
Mutex *chMtxUnlockS(void) {
|
||||
Thread *ctp = currp;
|
||||
|
@ -342,6 +354,8 @@ Mutex *chMtxUnlockS(void) {
|
|||
* 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
|
||||
*/
|
||||
void chMtxUnlockAll(void) {
|
||||
Thread *ctp = currp;
|
||||
|
|
|
@ -50,8 +50,6 @@
|
|||
* @brief Initializes an input queue.
|
||||
* @details A Semaphore is internally initialized and works as a counter of
|
||||
* the bytes contained in the queue.
|
||||
* @note This function can be invoked before the kernel is initialized
|
||||
* because it just prepares a @p InputQueue structure.
|
||||
* @note The callback is invoked from within the S-Locked system state,
|
||||
* see @ref system_states.
|
||||
*
|
||||
|
@ -60,6 +58,8 @@
|
|||
* @param[in] size size of the queue buffer
|
||||
* @param[in] infy pointer to a callback function that is invoked when
|
||||
* data is read from the queue. The value can be @p NULL.
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chIQInit(InputQueue *iqp, uint8_t *bp, size_t size, qnotify_t infy) {
|
||||
|
||||
|
@ -77,6 +77,8 @@ void chIQInit(InputQueue *iqp, uint8_t *bp, size_t size, qnotify_t infy) {
|
|||
* obtain immediate attention from the high level layers.
|
||||
*
|
||||
* @param[in] iqp pointer to an @p InputQueue structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chIQResetI(InputQueue *iqp) {
|
||||
|
||||
|
@ -94,10 +96,12 @@ void chIQResetI(InputQueue *iqp) {
|
|||
* @retval Q_OK if the operation has been completed with success.
|
||||
* @retval Q_FULL if the queue is full and the operation cannot be
|
||||
* completed.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
msg_t chIQPutI(InputQueue *iqp, uint8_t b) {
|
||||
|
||||
if (chIQIsFull(iqp))
|
||||
if (chIQIsFullI(iqp))
|
||||
return Q_FULL;
|
||||
|
||||
*iqp->q_wrptr++ = b;
|
||||
|
@ -122,6 +126,8 @@ msg_t chIQPutI(InputQueue *iqp, uint8_t b) {
|
|||
* @return A byte value from the queue.
|
||||
* @retval Q_TIMEOUT if the specified time expired.
|
||||
* @retval Q_RESET if the queue was reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chIQGetTimeout(InputQueue *iqp, systime_t time) {
|
||||
uint8_t b;
|
||||
|
@ -165,6 +171,8 @@ msg_t chIQGetTimeout(InputQueue *iqp, systime_t time) {
|
|||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @return The number of bytes effectively transferred.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
size_t chIQReadTimeout(InputQueue *iqp, uint8_t *bp,
|
||||
size_t n, systime_t time) {
|
||||
|
@ -175,7 +183,7 @@ size_t chIQReadTimeout(InputQueue *iqp, uint8_t *bp,
|
|||
|
||||
chSysLock();
|
||||
while (TRUE) {
|
||||
if (chIQIsEmpty(iqp)) {
|
||||
if (chIQIsEmptyI(iqp)) {
|
||||
if (nfy)
|
||||
nfy();
|
||||
if ((chSemWaitTimeoutS(&iqp->q_sem, time) != RDY_OK)) {
|
||||
|
@ -207,8 +215,6 @@ size_t chIQReadTimeout(InputQueue *iqp, uint8_t *bp,
|
|||
* @brief Initializes an output queue.
|
||||
* @details A Semaphore is internally initialized and works as a counter of
|
||||
* the free bytes in the queue.
|
||||
* @note This function can be invoked before the kernel is initialized
|
||||
* because it just prepares a @p OutputQueue structure.
|
||||
* @note The callback is invoked from within the S-Locked system state,
|
||||
* see @ref system_states.
|
||||
*
|
||||
|
@ -217,6 +223,8 @@ size_t chIQReadTimeout(InputQueue *iqp, uint8_t *bp,
|
|||
* @param[in] size size of the queue buffer
|
||||
* @param[in] onfy pointer to a callback function that is invoked when
|
||||
* data is written to the queue. The value can be @p NULL.
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chOQInit(OutputQueue *oqp, uint8_t *bp, size_t size, qnotify_t onfy) {
|
||||
|
||||
|
@ -234,6 +242,8 @@ void chOQInit(OutputQueue *oqp, uint8_t *bp, size_t size, qnotify_t onfy) {
|
|||
* obtain immediate attention from the high level layers.
|
||||
*
|
||||
* @param[in] oqp pointer to an @p OutputQueue structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chOQResetI(OutputQueue *oqp) {
|
||||
|
||||
|
@ -258,6 +268,8 @@ void chOQResetI(OutputQueue *oqp) {
|
|||
* @retval Q_OK if the operation succeeded.
|
||||
* @retval Q_TIMEOUT if the specified time expired.
|
||||
* @retval Q_RESET if the queue was reset.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chOQPutTimeout(OutputQueue *oqp, uint8_t b, systime_t time) {
|
||||
msg_t msg;
|
||||
|
@ -285,11 +297,13 @@ msg_t chOQPutTimeout(OutputQueue *oqp, uint8_t b, systime_t time) {
|
|||
* @param[in] oqp pointer to an @p OutputQueue structure
|
||||
* @return The byte value from the queue.
|
||||
* @retval Q_EMPTY if the queue is empty.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
msg_t chOQGetI(OutputQueue *oqp) {
|
||||
uint8_t b;
|
||||
|
||||
if (chOQIsEmpty(oqp))
|
||||
if (chOQIsEmptyI(oqp))
|
||||
return Q_EMPTY;
|
||||
|
||||
b = *oqp->q_rdptr++;
|
||||
|
@ -320,6 +334,8 @@ msg_t chOQGetI(OutputQueue *oqp) {
|
|||
* - @a TIME_INFINITE no timeout.
|
||||
* .
|
||||
* @return The number of bytes effectively transferred.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
size_t chOQWriteTimeout(OutputQueue *oqp, const uint8_t *bp,
|
||||
size_t n, systime_t time) {
|
||||
|
@ -330,7 +346,7 @@ size_t chOQWriteTimeout(OutputQueue *oqp, const uint8_t *bp,
|
|||
|
||||
chSysLock();
|
||||
while (TRUE) {
|
||||
if (chOQIsFull(oqp)) {
|
||||
if (chOQIsFullI(oqp)) {
|
||||
if (nfy)
|
||||
nfy();
|
||||
if ((chSemWaitTimeoutS(&oqp->q_sem, time) != RDY_OK)) {
|
||||
|
|
|
@ -58,6 +58,8 @@
|
|||
* least one thread in the system.
|
||||
*
|
||||
* @return A reference to the most ancient thread.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chRegFirstThread(void) {
|
||||
Thread *tp;
|
||||
|
@ -79,6 +81,8 @@ Thread *chRegFirstThread(void) {
|
|||
* @param[in] tp pointer to the thread
|
||||
* @return A reference to the next thread.
|
||||
* @retval NULL if there is no next thread.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chRegNextThread(Thread *tp) {
|
||||
Thread *ntp;
|
||||
|
|
|
@ -41,7 +41,8 @@ ReadyList rlist;
|
|||
|
||||
/**
|
||||
* @brief Scheduler initialization.
|
||||
* @note Internally invoked by the @p chSysInit(), not an API.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void scheduler_init(void) {
|
||||
|
||||
|
@ -66,6 +67,8 @@ void scheduler_init(void) {
|
|||
*
|
||||
* @param[in] tp the thread to be made ready
|
||||
* @return The thread pointer.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_READYI) || defined(__DOXYGEN__)
|
||||
#if CH_OPTIMIZE_SPEED
|
||||
|
@ -101,6 +104,8 @@ Thread *chSchReadyI(Thread *tp) {
|
|||
* @ref thread_states are defined into @p threads.h.
|
||||
*
|
||||
* @param[in] newstate the new thread state
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_GOSLEEPS) || defined(__DOXYGEN__)
|
||||
void chSchGoSleepS(tstate_t newstate) {
|
||||
|
@ -163,6 +168,8 @@ static void wakeup(void *p) {
|
|||
* .
|
||||
* @return The wakeup message.
|
||||
* @retval RDY_TIMEOUT if a timeout occurs.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time) {
|
||||
|
||||
|
@ -194,6 +201,8 @@ msg_t chSchGoSleepTimeoutS(tstate_t newstate, systime_t time) {
|
|||
*
|
||||
* @param[in] ntp the Thread to be made ready
|
||||
* @param[in] msg message to the awakened thread
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_WAKEUPS) || defined(__DOXYGEN__)
|
||||
void chSchWakeupS(Thread *ntp, msg_t msg) {
|
||||
|
@ -222,6 +231,8 @@ void chSchWakeupS(Thread *ntp, msg_t msg) {
|
|||
* @brief Switches to the first thread on the runnable queue.
|
||||
* @note It is intended to be called if @p chSchRescRequiredI() evaluates
|
||||
* to @p TRUE.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_DORESCHEDULEI) || defined(__DOXYGEN__)
|
||||
void chSchDoRescheduleI(void) {
|
||||
|
@ -244,6 +255,8 @@ void chSchDoRescheduleI(void) {
|
|||
* @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.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_RESCHEDULES) || defined(__DOXYGEN__)
|
||||
void chSchRescheduleS(void) {
|
||||
|
@ -262,6 +275,8 @@ void chSchRescheduleS(void) {
|
|||
*
|
||||
* @retval TRUE if there is a thread that should go in running state.
|
||||
* @retval FALSE if a reschedule is not required.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
#if !defined(PORT_OPTIMIZED_ISRESCHREQUIREDEXI) || defined(__DOXYGEN__)
|
||||
bool_t chSchIsRescRequiredExI(void) {
|
||||
|
|
|
@ -68,12 +68,12 @@
|
|||
|
||||
/**
|
||||
* @brief Initializes a semaphore with the specified counter value.
|
||||
* @note This function can be invoked before the kernel is initialized
|
||||
* because it just prepares a @p Semaphore structure.
|
||||
*
|
||||
* @param[out] sp pointer to a @p Semaphore structure
|
||||
* @param[in] n initial value of the semaphore counter. Must be
|
||||
* non-negative.
|
||||
*
|
||||
* @init
|
||||
*/
|
||||
void chSemInit(Semaphore *sp, cnt_t n) {
|
||||
|
||||
|
@ -95,6 +95,8 @@ void chSemInit(Semaphore *sp, cnt_t n) {
|
|||
* @param[in] sp pointer to a @p Semaphore structure
|
||||
* @param[in] n the new value of the semaphore counter. The value must
|
||||
* be non-negative.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chSemReset(Semaphore *sp, cnt_t n) {
|
||||
|
||||
|
@ -120,6 +122,8 @@ void chSemReset(Semaphore *sp, cnt_t n) {
|
|||
* @param[in] sp pointer to a @p Semaphore structure
|
||||
* @param[in] n the new value of the semaphore counter. The value must
|
||||
* be non-negative.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chSemResetI(Semaphore *sp, cnt_t n) {
|
||||
cnt_t cnt;
|
||||
|
@ -146,6 +150,8 @@ void chSemResetI(Semaphore *sp, cnt_t n) {
|
|||
* @retval RDY_OK if the thread has not stopped on the semaphore or the
|
||||
* semaphore has been signaled.
|
||||
* @retval RDY_RESET if the semaphore has been reset using @p chSemReset().
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chSemWait(Semaphore *sp) {
|
||||
msg_t msg;
|
||||
|
@ -165,6 +171,8 @@ msg_t chSemWait(Semaphore *sp) {
|
|||
* @retval RDY_OK if the thread has not stopped on the semaphore or the
|
||||
* semaphore has been signaled.
|
||||
* @retval RDY_RESET if the semaphore has been reset using @p chSemReset().
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chSemWaitS(Semaphore *sp) {
|
||||
|
||||
|
@ -200,6 +208,8 @@ msg_t chSemWaitS(Semaphore *sp) {
|
|||
* @retval RDY_RESET if the semaphore has been reset using @p chSemReset().
|
||||
* @retval RDY_TIMEOUT if the semaphore has not been signaled or reset within
|
||||
* the specified timeout.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chSemWaitTimeout(Semaphore *sp, systime_t time) {
|
||||
msg_t msg;
|
||||
|
@ -226,6 +236,8 @@ msg_t chSemWaitTimeout(Semaphore *sp, systime_t time) {
|
|||
* @retval RDY_RESET if the semaphore has been reset using @p chSemReset().
|
||||
* @retval RDY_TIMEOUT if the semaphore has not been signaled or reset within
|
||||
* the specified timeout.
|
||||
*
|
||||
* @sclass
|
||||
*/
|
||||
msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time) {
|
||||
|
||||
|
@ -252,6 +264,8 @@ msg_t chSemWaitTimeoutS(Semaphore *sp, systime_t time) {
|
|||
* @brief Performs a signal operation on a semaphore.
|
||||
*
|
||||
* @param[in] sp pointer to a @p Semaphore structure
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chSemSignal(Semaphore *sp) {
|
||||
|
||||
|
@ -276,6 +290,8 @@ void chSemSignal(Semaphore *sp) {
|
|||
* reschedule must not be performed in ISRs.
|
||||
*
|
||||
* @param[in] sp pointer to a @p Semaphore structure
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chSemSignalI(Semaphore *sp) {
|
||||
|
||||
|
@ -308,6 +324,8 @@ void chSemSignalI(Semaphore *sp) {
|
|||
* @retval RDY_OK if the thread has not stopped on the semaphore or the
|
||||
* semaphore has been signaled.
|
||||
* @retval RDY_RESET if the semaphore has been reset using @p chSemReset().
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chSemSignalWait(Semaphore *sps, Semaphore *spw) {
|
||||
msg_t msg;
|
||||
|
|
|
@ -66,6 +66,10 @@ void _idle_thread(void *p) {
|
|||
* @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
|
||||
*/
|
||||
void chSysInit(void) {
|
||||
static Thread mainthread;
|
||||
|
@ -100,10 +104,11 @@ void chSysInit(void) {
|
|||
* @details Decrements the remaining time quantum of the running thread
|
||||
* and preempts it when the quantum is used up. Increments system
|
||||
* time and manages the timers.
|
||||
*
|
||||
* @note The frequency of the timer determines the system tick granularity
|
||||
* and, together with the @p CH_TIME_QUANTUM macro, the round robin
|
||||
* interval.
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chSysTimerHandlerI(void) {
|
||||
|
||||
|
|
|
@ -64,6 +64,8 @@
|
|||
* @param[in] tp pointer to the thread
|
||||
* @param[in] prio the priority level for the new thread
|
||||
* @return The same thread pointer passed as parameter.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
Thread *init_thread(Thread *tp, tprio_t prio) {
|
||||
|
||||
|
@ -128,6 +130,8 @@ static void memfill(uint8_t *startp, uint8_t *endp, uint8_t v) {
|
|||
* @p NULL.
|
||||
* @return The pointer to the @p Thread structure allocated for
|
||||
* the thread into the working space area.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chThdInit(void *wsp, size_t size, tprio_t prio, tfunc_t pf, void *arg) {
|
||||
/* Thread structure is layed out in the lower part of the thread workspace */
|
||||
|
@ -158,6 +162,8 @@ Thread *chThdInit(void *wsp, size_t size, tprio_t prio, tfunc_t pf, void *arg) {
|
|||
* @p NULL.
|
||||
* @return The pointer to the @p Thread structure allocated for
|
||||
* the thread into the working space area.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chThdCreateStatic(void *wsp, size_t size,
|
||||
tprio_t prio, tfunc_t pf, void *arg) {
|
||||
|
@ -185,6 +191,8 @@ Thread *chThdCreateStatic(void *wsp, size_t size,
|
|||
* @return The pointer to the @p Thread structure allocated for
|
||||
* the thread into the working space area.
|
||||
* @retval NULL if the memory cannot be allocated.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chThdCreateFromHeap(MemoryHeap *heapp, size_t size,
|
||||
tprio_t prio, tfunc_t pf, void *arg) {
|
||||
|
@ -219,6 +227,8 @@ Thread *chThdCreateFromHeap(MemoryHeap *heapp, size_t size,
|
|||
* @return The pointer to the @p Thread structure allocated for
|
||||
* the thread into the working space area.
|
||||
* @retval NULL if the memory pool is empty.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chThdCreateFromMemoryPool(MemoryPool *mp, tprio_t prio,
|
||||
tfunc_t pf, void *arg) {
|
||||
|
@ -246,6 +256,8 @@ Thread *chThdCreateFromMemoryPool(MemoryPool *mp, tprio_t prio,
|
|||
*
|
||||
* @param[in] newprio the new priority level of the running thread
|
||||
* @return The old priority level.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
tprio_t chThdSetPriority(tprio_t newprio) {
|
||||
tprio_t oldprio;
|
||||
|
@ -278,6 +290,8 @@ tprio_t chThdSetPriority(tprio_t newprio) {
|
|||
*
|
||||
* @param[in] tp pointer to the thread
|
||||
* @return The pointer to the thread.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chThdResume(Thread *tp) {
|
||||
|
||||
|
@ -299,6 +313,8 @@ Thread *chThdResume(Thread *tp) {
|
|||
* condition.
|
||||
*
|
||||
* @param[in] tp pointer to the thread
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chThdTerminate(Thread *tp) {
|
||||
|
||||
|
@ -318,6 +334,8 @@ void chThdTerminate(Thread *tp) {
|
|||
* interpreted as a normal time specification not as an
|
||||
* immediate timeout specification.
|
||||
* .
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chThdSleep(systime_t time) {
|
||||
|
||||
|
@ -333,6 +351,8 @@ void chThdSleep(systime_t time) {
|
|||
* specified value.
|
||||
*
|
||||
* @param[in] time absolute system time
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chThdSleepUntil(systime_t time) {
|
||||
|
||||
|
@ -346,6 +366,8 @@ void chThdSleepUntil(systime_t time) {
|
|||
* @brief Yields the time slot.
|
||||
* @details Yields the CPU control to the next thread in the ready list with
|
||||
* equal priority, if any.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chThdYield(void) {
|
||||
|
||||
|
@ -360,9 +382,13 @@ void chThdYield(void) {
|
|||
* 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.
|
||||
* 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
|
||||
*/
|
||||
void chThdExit(msg_t msg) {
|
||||
Thread *tp = currp;
|
||||
|
@ -391,6 +417,8 @@ void chThdExit(msg_t msg) {
|
|||
* @param[in] tp pointer to the thread
|
||||
* @return The same thread pointer passed as parameter
|
||||
* representing the new reference.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
Thread *chThdAddRef(Thread *tp) {
|
||||
|
||||
|
@ -411,6 +439,8 @@ Thread *chThdAddRef(Thread *tp) {
|
|||
* @note Static threads are not affected.
|
||||
*
|
||||
* @param[in] tp pointer to the thread
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
void chThdRelease(Thread *tp) {
|
||||
trefs_t refs;
|
||||
|
@ -469,6 +499,8 @@ void chThdRelease(Thread *tp) {
|
|||
*
|
||||
* @param[in] tp pointer to the thread
|
||||
* @return The exit code from the terminated thread.
|
||||
*
|
||||
* @api
|
||||
*/
|
||||
msg_t chThdWait(Thread *tp) {
|
||||
msg_t msg;
|
||||
|
|
|
@ -36,6 +36,8 @@ VTList vtlist;
|
|||
/**
|
||||
* @brief Virtual Timers initialization.
|
||||
* @note Internal use only.
|
||||
*
|
||||
* @notapi
|
||||
*/
|
||||
void vt_init(void) {
|
||||
|
||||
|
@ -58,6 +60,8 @@ void vt_init(void) {
|
|||
* be disposed or reused.
|
||||
* @param[in] par a parameter that will be passed to the callback
|
||||
* function
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chVTSetI(VirtualTimer *vtp, systime_t time, vtfunc_t vtfunc, void *par) {
|
||||
VirtualTimer *p;
|
||||
|
@ -85,6 +89,8 @@ void chVTSetI(VirtualTimer *vtp, systime_t time, vtfunc_t vtfunc, void *par) {
|
|||
* @note The timer MUST be active when this function is invoked.
|
||||
*
|
||||
* @param[in] vtp the @p VirtualTimer structure pointer
|
||||
*
|
||||
* @iclass
|
||||
*/
|
||||
void chVTResetI(VirtualTimer *vtp) {
|
||||
|
||||
|
@ -110,6 +116,8 @@ void chVTResetI(VirtualTimer *vtp) {
|
|||
* @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
|
||||
*/
|
||||
bool_t chTimeIsWithin(systime_t start, systime_t end) {
|
||||
|
||||
|
|
|
@ -111,9 +111,15 @@
|
|||
- OPT: Removed an unused field in the VTList structure.
|
||||
- OPT: Speed optimizations of the STM32 SPI driver, improved latency.
|
||||
- OPT: Speed optimizations of the STM32 ADC driver.
|
||||
- CHANGE: The mailboxes macros chMBSize(), chMBGetEmpty(), chMBGetFull(),
|
||||
chMBPeek() have been renamed to chMBSizeI(), chMBGetEmptyI(),
|
||||
chMBGetFullI(), chMBPeekI().
|
||||
- CHANGE: The queue APIs chQSize(), chQSpace(), chIQIsEmpty(), chIQIsFull(),
|
||||
chOQIsEmpty(), chOQIsFull() have been renamed to chQSizeI(), chQSpaceI(),
|
||||
chIQIsEmptyI(), chIQIsFullI(), chOQIsEmptyI(), chOQIsFullI().
|
||||
- CHANGE: The event APIs chEvtPend() and chEvtClear() have been renamed
|
||||
to chEvtAddFlags() and chEvtClearFlags() for consistency and correct
|
||||
English.
|
||||
English. Changed the macro chEvtIsListening() in chEvtIsListeningI().
|
||||
- CHANGE: Added a parameter to the UART driver callbacks, the pointer to the
|
||||
driver itself.
|
||||
- CHANGE: In the UART driver now an error does not automatically brings the
|
||||
|
|
|
@ -94,11 +94,11 @@ static void evt1_execute(void) {
|
|||
chEvtInit(&es1);
|
||||
chEvtRegisterMask(&es1, &el1, 1);
|
||||
chEvtRegisterMask(&es1, &el2, 2);
|
||||
test_assert(1, chEvtIsListening(&es1), "no listener");
|
||||
test_assert(1, chEvtIsListeningI(&es1), "no listener");
|
||||
chEvtUnregister(&es1, &el1);
|
||||
test_assert(2, chEvtIsListening(&es1), "no listener");
|
||||
test_assert(2, chEvtIsListeningI(&es1), "no listener");
|
||||
chEvtUnregister(&es1, &el2);
|
||||
test_assert(3, !chEvtIsListening(&es1), "stuck listener");
|
||||
test_assert(3, !chEvtIsListeningI(&es1), "stuck listener");
|
||||
|
||||
/*
|
||||
* Testing chEvtDispatch().
|
||||
|
@ -220,8 +220,8 @@ static void evt2_execute(void) {
|
|||
test_wait_threads();
|
||||
chEvtUnregister(&es1, &el1);
|
||||
chEvtUnregister(&es2, &el2);
|
||||
test_assert(14, !chEvtIsListening(&es1), "stuck listener");
|
||||
test_assert(15, !chEvtIsListening(&es2), "stuck listener");
|
||||
test_assert(14, !chEvtIsListeningI(&es1), "stuck listener");
|
||||
test_assert(15, !chEvtIsListeningI(&es2), "stuck listener");
|
||||
}
|
||||
|
||||
ROMCONST struct testcase testevt2 = {
|
||||
|
|
|
@ -83,7 +83,7 @@ static void mbox1_execute(void) {
|
|||
/*
|
||||
* Testing initial space.
|
||||
*/
|
||||
test_assert(1, chMBGetEmpty(&mb1) == MB_SIZE, "wrong size");
|
||||
test_assert(1, chMBGetEmptyI(&mb1) == MB_SIZE, "wrong size");
|
||||
|
||||
/*
|
||||
* Testing enqueuing and backward circularity.
|
||||
|
@ -104,8 +104,8 @@ static void mbox1_execute(void) {
|
|||
/*
|
||||
* Testing final conditions.
|
||||
*/
|
||||
test_assert(5, chMBGetEmpty(&mb1) == 0, "still empty");
|
||||
test_assert(6, chMBGetFull(&mb1) == MB_SIZE, "not full");
|
||||
test_assert(5, chMBGetEmptyI(&mb1) == 0, "still empty");
|
||||
test_assert(6, chMBGetFullI(&mb1) == MB_SIZE, "not full");
|
||||
test_assert(7, mb1.mb_rdptr == mb1.mb_wrptr, "pointers not aligned");
|
||||
|
||||
/*
|
||||
|
@ -137,8 +137,8 @@ static void mbox1_execute(void) {
|
|||
/*
|
||||
* Testing final conditions.
|
||||
*/
|
||||
test_assert(15, chMBGetEmpty(&mb1) == MB_SIZE, "not empty");
|
||||
test_assert(16, chMBGetFull(&mb1) == 0, "still full");
|
||||
test_assert(15, chMBGetEmptyI(&mb1) == MB_SIZE, "not empty");
|
||||
test_assert(16, chMBGetFullI(&mb1) == 0, "still full");
|
||||
test_assert(17, mb1.mb_rdptr == mb1.mb_wrptr, "pointers not aligned");
|
||||
|
||||
/*
|
||||
|
@ -149,8 +149,8 @@ static void mbox1_execute(void) {
|
|||
/*
|
||||
* Re-testing final conditions.
|
||||
*/
|
||||
test_assert(18, chMBGetEmpty(&mb1) == MB_SIZE, "not empty");
|
||||
test_assert(19, chMBGetFull(&mb1) == 0, "still full");
|
||||
test_assert(18, chMBGetEmptyI(&mb1) == MB_SIZE, "not empty");
|
||||
test_assert(19, chMBGetFullI(&mb1) == 0, "still full");
|
||||
test_assert(20, mb1.mb_buffer == mb1.mb_wrptr, "write pointer not aligned to base");
|
||||
test_assert(21, mb1.mb_buffer == mb1.mb_rdptr, "read pointer not aligned to base");
|
||||
}
|
||||
|
|
|
@ -86,18 +86,18 @@ static void queues1_execute(void) {
|
|||
size_t n;
|
||||
|
||||
/* Initial empty state */
|
||||
test_assert(1, chIQIsEmpty(&iq), "not empty");
|
||||
test_assert(1, chIQIsEmptyI(&iq), "not empty");
|
||||
|
||||
/* Queue filling */
|
||||
for (i = 0; i < TEST_QUEUES_SIZE; i++)
|
||||
chIQPutI(&iq, 'A' + i);
|
||||
test_assert(2, chIQIsFull(&iq), "still has space");
|
||||
test_assert(2, chIQIsFullI(&iq), "still has space");
|
||||
test_assert(3, chIQPutI(&iq, 0) == Q_FULL, "failed to report Q_FULL");
|
||||
|
||||
/* Queue emptying */
|
||||
for (i = 0; i < TEST_QUEUES_SIZE; i++)
|
||||
test_emit_token(chIQGet(&iq));
|
||||
test_assert(4, chIQIsEmpty(&iq), "still full");
|
||||
test_assert(4, chIQIsEmptyI(&iq), "still full");
|
||||
test_assert_sequence(5, "ABCD");
|
||||
|
||||
/* Queue filling again */
|
||||
|
@ -107,7 +107,7 @@ static void queues1_execute(void) {
|
|||
/* Reading the whole thing */
|
||||
n = chIQReadTimeout(&iq, wa[1], TEST_QUEUES_SIZE * 2, TIME_IMMEDIATE);
|
||||
test_assert(6, n == TEST_QUEUES_SIZE, "wrong returned size");
|
||||
test_assert(7, chIQIsEmpty(&iq), "still full");
|
||||
test_assert(7, chIQIsEmptyI(&iq), "still full");
|
||||
|
||||
/* Queue filling again */
|
||||
for (i = 0; i < TEST_QUEUES_SIZE; i++)
|
||||
|
@ -118,12 +118,12 @@ static void queues1_execute(void) {
|
|||
test_assert(8, n == TEST_QUEUES_SIZE / 2, "wrong returned size");
|
||||
n = chIQReadTimeout(&iq, wa[1], TEST_QUEUES_SIZE / 2, TIME_IMMEDIATE);
|
||||
test_assert(9, n == TEST_QUEUES_SIZE / 2, "wrong returned size");
|
||||
test_assert(10, chIQIsEmpty(&iq), "still full");
|
||||
test_assert(10, chIQIsEmptyI(&iq), "still full");
|
||||
|
||||
/* Testing reset */
|
||||
chIQPutI(&iq, 0);
|
||||
chIQResetI(&iq);
|
||||
test_assert(11, chIQIsEmpty(&iq), "still full");
|
||||
test_assert(11, chIQIsEmptyI(&iq), "still full");
|
||||
|
||||
/* Timeout */
|
||||
test_assert(12, chIQGetTimeout(&iq, 10) == Q_TIMEOUT, "wrong timeout return");
|
||||
|
@ -155,35 +155,35 @@ static void queues2_execute(void) {
|
|||
size_t n;
|
||||
|
||||
/* Initial empty state */
|
||||
test_assert(1, chOQIsEmpty(&oq), "not empty");
|
||||
test_assert(1, chOQIsEmptyI(&oq), "not empty");
|
||||
|
||||
/* Queue filling */
|
||||
for (i = 0; i < TEST_QUEUES_SIZE; i++)
|
||||
chOQPut(&oq, 'A' + i);
|
||||
test_assert(2, chOQIsFull(&oq), "still has space");
|
||||
test_assert(2, chOQIsFullI(&oq), "still has space");
|
||||
|
||||
/* Queue emptying */
|
||||
for (i = 0; i < TEST_QUEUES_SIZE; i++)
|
||||
test_emit_token(chOQGetI(&oq));
|
||||
test_assert(3, chOQIsEmpty(&oq), "still full");
|
||||
test_assert(3, chOQIsEmptyI(&oq), "still full");
|
||||
test_assert_sequence(4, "ABCD");
|
||||
test_assert(5, chOQGetI(&oq) == Q_EMPTY, "failed to report Q_EMPTY");
|
||||
|
||||
/* Writing the whole thing */
|
||||
n = chOQWriteTimeout(&oq, wa[1], TEST_QUEUES_SIZE * 2, TIME_IMMEDIATE);
|
||||
test_assert(6, n == TEST_QUEUES_SIZE, "wrong returned size");
|
||||
test_assert(7, chOQIsFull(&oq), "not full");
|
||||
test_assert(7, chOQIsFullI(&oq), "not full");
|
||||
|
||||
/* Testing reset */
|
||||
chOQResetI(&oq);
|
||||
test_assert(8, chOQIsEmpty(&oq), "still full");
|
||||
test_assert(8, chOQIsEmptyI(&oq), "still full");
|
||||
|
||||
/* Partial writes */
|
||||
n = chOQWriteTimeout(&oq, wa[1], TEST_QUEUES_SIZE / 2, TIME_IMMEDIATE);
|
||||
test_assert(9, n == TEST_QUEUES_SIZE / 2, "wrong returned size");
|
||||
n = chOQWriteTimeout(&oq, wa[1], TEST_QUEUES_SIZE / 2, TIME_IMMEDIATE);
|
||||
test_assert(10, n == TEST_QUEUES_SIZE / 2, "wrong returned size");
|
||||
test_assert(11, chOQIsFull(&oq), "not full");
|
||||
test_assert(11, chOQIsFullI(&oq), "not full");
|
||||
|
||||
/* Timeout */
|
||||
test_assert(12, chOQPutTimeout(&oq, 0, 10) == Q_TIMEOUT, "wrong timeout return");
|
||||
|
|
Loading…
Reference in New Issue