rusefi
/
ChibiOS
mirror of https://github.com/rusefi/ChibiOS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Documentation related fixes. 

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@5298 35acf78f-673a-0410-8e92-d51de3d6d3f4
This commit is contained in:
gdisirio 2013-02-22 11:34:04 +00:00
parent 4149bab2ca
commit d4c246e1bf
11 changed files with 407 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
os/hal/dox/io_block.dox Normal file
View File

@ -0,0 +1,101 @@
/*
ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
2011,2012,2013 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 <http://www.gnu.org/licenses/>.
*/
/**
* @defgroup IO_BLOCK Abstract I/O Block Device
* @ingroup IO
*
* @section io_block_1 Driver State Machine
* The drivers implementing this interface shall implement the following
* state machine internally. Not all the driver functionalities can be used
* in any moment, any transition not explicitly shown in the following
* diagram has to be considered an error and shall be captured by an
* assertion (if enabled).
* @if LATEX_PDF
* @dot
digraph example {
size="5, 7";
rankdir="LR";
node [shape=circle, fontname=Sans, fontsize=8, fixedsize="true", width="0.9", height="0.9"];
edge [fontname=Sans, fontsize=8];
stop [label="BLK_STOP\nLow Power"];
uninit [label="BLK_UNINIT", style="bold"];
ready [label="BLK_READY\nClock Enabled"];
connecting [label="BLK_CONN.ING\nConnecting"];
disconnecting [label="BLK_DISC.ING\nDisconnecting"];
active [label="BLK_ACTIVE\nCard Ready"];
reading [label="BLK_READING\nReading"];
writing [label="BLK_WRITING\nWriting"];
uninit -> stop [label=" blkInit()", constraint=false];
stop -> stop [label="\nblkStop()"];
stop -> ready [label="\nblkStart()"];
ready -> stop [label="\nblkStop()"];
ready -> ready [label="\nblkStart()\nblkDisconnect()"];
ready -> connecting [label="\nblkConnect()"];
connecting -> active [label="\nconnection\nsuccessful"];
connecting -> active [label="\nblkConnect()", dir="back"];
connecting -> ready [label="\nconnection\nfailed"];
disconnecting -> active [label="\nblkDisconnect()", dir="back"];
ready -> disconnecting [label="\ndisconnection\nfinished", dir="back"];
active -> reading [label="\nblkRead()"];
reading -> active [label="\nread finished\nread error"];
active -> writing [label="\nblkWrite()"];
writing -> active [label="\nwrite finished\nwrite error"];
}
* @enddot
* @else
* @dot
digraph example {
rankdir="LR";
node [shape=circle, fontname=Sans, fontsize=8, fixedsize="true", width="0.9", height="0.9"];
edge [fontname=Sans, fontsize=8];
stop [label="BLK_STOP\nLow Power"];
uninit [label="BLK_UNINIT", style="bold"];
ready [label="BLK_READY\nClock Enabled"];
connecting [label="BLK_CONN.ING\nConnecting"];
disconnecting [label="BLK_DISC.ING\nDisconnecting"];
active [label="BLK_ACTIVE\nCard Ready"];
reading [label="BLK_READING\nReading"];
writing [label="BLK_WRITING\nWriting"];
uninit -> stop [label=" blkInit()", constraint=false];
stop -> stop [label="\nblkStop()"];
stop -> ready [label="\nblkStart()"];
ready -> stop [label="\nblkStop()"];
ready -> ready [label="\nblkStart()\nblkDisconnect()"];
ready -> connecting [label="\nblkConnect()"];
connecting -> active [label="\nconnection\nsuccessful"];
connecting -> active [label="\nblkConnect()", dir="back"];
connecting -> ready [label="\nconnection\nfailed"];
disconnecting -> active [label="\nblkDisconnect()", dir="back"];
ready -> disconnecting [label="\ndisconnection\nfinished", dir="back"];
active -> reading [label="\nblkRead()"];
reading -> active [label="\nread finished\nread error"];
active -> writing [label="\nblkWrite()"];
writing -> active [label="\nwrite finished\nwrite error"];
}
* @enddot
* @endif
*/

24
os/hal/dox/io_channel.dox Normal file
View File

@ -0,0 +1,24 @@
/*
ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
2011,2012,2013 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 <http://www.gnu.org/licenses/>.
*/
/**
* @defgroup IO_CHANNEL Abstract I/O Channel
* @ingroup IO
*/

92
os/hal/dox/mmc_spi.dox
View File

@ -28,92 +28,12 @@
* @p HAL_USE_SPI options must be enabled in @p halconf.h.
*
* @section mmc_spi_1 Driver State Machine
* The driver implements a state machine internally, not all the driver
* functionalities can be used in any moment, any transition not explicitly
* shown in the following diagram has to be considered an error and shall
* be captured by an assertion (if enabled).
* @if LATEX_PDF
* @dot
digraph example {
size="5, 7";
rankdir="LR";
node [shape=circle, fontname=Helvetica, fontsize=8, fixedsize="true", width="0.9", height="0.9"];
edge [fontname=Helvetica, fontsize=8];
any [label="Any State"];
stop2 [label="MMC_STOP\nLow Power"];
uninit [label="MMC_UNINIT", style="bold"];
stop [label="MMC_STOP\nLow Power"];
wait [label="MMC_WAIT\nWaiting Card"];
inserted [label="MMC_INSERTED\nCard Inserted"];
ready [label="MMC_READY\nCard Ready"];
reading [label="MMC_READING\nReading"];
writing [label="MMC_WRITING\nWriting"];
uninit -> stop [label="mmcInit()"];
stop -> wait [label="mmcStart()", constraint=false];
wait -> inserted [label="insertion (inserted event)"];
inserted -> inserted [label="mmcDisconnect()"];
inserted -> ready [label="mmcConnect()"];
ready -> ready [label="mmcConnect()"];
ready -> inserted [label="mmcDisconnect()"];
ready -> reading [label="mmcStartSequentialRead()"];
reading -> reading [label="mmcSequentialRead()"];
reading -> ready [label="mmcStopSequentialRead()"];
reading -> ready [label="read error"];
ready -> writing [label="mmcStartSequentialWrite()"];
writing -> writing [label="mmcSequentialWrite()"];
writing -> ready [label="mmcStopSequentialWrite()"];
writing -> ready [label="write error"];
inserted -> wait [label="removal (removed event)"];
ready -> wait [label="removal (removed event)"];
reading -> wait [label="removal (removed event)"];
writing -> wait [label="removal (removed event)"];
any -> stop2 [label="mmcStop()"];
}
* @enddot
* @else
* @dot
digraph example {
rankdir="LR";
node [shape=circle, fontname=Helvetica, fontsize=8, fixedsize="true", width="0.9", height="0.9"];
edge [fontname=Helvetica, fontsize=8];
any [label="Any State"];
stop2 [label="MMC_STOP\nLow Power"];
uninit [label="MMC_UNINIT", style="bold"];
stop [label="MMC_STOP\nLow Power"];
wait [label="MMC_WAIT\nWaiting Card"];
inserted [label="MMC_INSERTED\nCard Inserted"];
ready [label="MMC_READY\nCard Ready"];
reading [label="MMC_READING\nReading"];
writing [label="MMC_WRITING\nWriting"];
uninit -> stop [label="mmcInit()"];
stop -> wait [label="mmcStart()", constraint=false];
wait -> inserted [label="insertion (inserted event)"];
inserted -> inserted [label="mmcDisconnect()"];
inserted -> ready [label="mmcConnect()"];
ready -> ready [label="mmcConnect()"];
ready -> inserted [label="mmcDisconnect()"];
ready -> reading [label="mmcStartSequentialRead()"];
reading -> reading [label="mmcSequentialRead()"];
reading -> ready [label="mmcStopSequentialRead()"];
reading -> ready [label="read error"];
ready -> writing [label="mmcStartSequentialWrite()"];
writing -> writing [label="mmcSequentialWrite()"];
writing -> ready [label="mmcStopSequentialWrite()"];
writing -> ready [label="write error"];
inserted -> wait [label="removal (removed event)"];
ready -> wait [label="removal (removed event)"];
reading -> wait [label="removal (removed event)"];
writing -> wait [label="removal (removed event)"];
any -> stop2 [label="mmcStop()"];
}
* @enddot
* @endif
* This driver implements a state machine internally, see the @ref IO_BLOCK
* module documentation for details.
*
* @section mmc_spi_2 Driver Operations
* This driver allows to read or write single or multiple 512 bytes blocks
* on a SD Card.
*
* @ingroup IO
*/

28
os/hal/dox/mmcsd.dox Normal file
View File

@ -0,0 +1,28 @@
/*
ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
2011,2012,2013 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 <http://www.gnu.org/licenses/>.
*/
/**
* @defgroup MMCSD MMC/SD Block Device
* @details This module implements a common ancestor for all device drivers
* accessing MMC or SD cards. This interface inherits the state
* machine and the interface from the @ref IO_BLOCK module.
*
* @ingroup IO
*/

78
os/hal/dox/sdc.dox
View File

@ -26,82 +26,10 @@
* must be enabled in @p halconf.h.
*
* @section sdc_1 Driver State Machine
* The driver implements a state machine internally, not all the driver
* functionalities can be used in any moment, any transition not explicitly
* shown in the following diagram has to be considered an error and shall
* be captured by an assertion (if enabled).
* @if LATEX_PDF
* @dot
digraph example {
size="5, 7";
rankdir="LR";
node [shape=circle, fontname=Sans, fontsize=8, fixedsize="true", width="0.9", height="0.9"];
edge [fontname=Sans, fontsize=8];
stop [label="SDC_STOP\nLow Power"];
uninit [label="SDC_UNINIT", style="bold"];
ready [label="SDC_READY\nClock Enabled"];
connecting [label="SDC_CONN.ING\nConnecting"];
disconnecting [label="SDC_DISC.ING\nDisconnecting"];
active [label="SDC_ACTIVE\nCard Ready"];
reading [label="SDC_READING\nReading"];
writing [label="SDC_WRITING\nWriting"];
uninit -> stop [label=" sdcInit()", constraint=false];
stop -> stop [label="\nsdcStop()"];
stop -> ready [label="\nsdcStart()"];
ready -> stop [label="\nsdcStop()"];
ready -> ready [label="\nsdcStart()\nsdcDisconnect()"];
ready -> connecting [label="\nsdcConnect()"];
connecting -> active [label="\nconnection\nsuccessful"];
connecting -> active [label="\nsdcConnect()", dir="back"];
connecting -> ready [label="\nconnection\nfailed"];
disconnecting -> active [label="\nsdcDisconnect()", dir="back"];
ready -> disconnecting [label="\ndisconnection\nfinished", dir="back"];
active -> reading [label="\nsdcRead()"];
reading -> active [label="\nread finished\nread error"];
active -> writing [label="\nsdcWrite()"];
writing -> active [label="\nwrite finished\nwrite error"];
}
* @enddot
* @else
* @dot
digraph example {
rankdir="LR";
node [shape=circle, fontname=Sans, fontsize=8, fixedsize="true", width="0.9", height="0.9"];
edge [fontname=Sans, fontsize=8];
stop [label="SDC_STOP\nLow Power"];
uninit [label="SDC_UNINIT", style="bold"];
ready [label="SDC_READY\nClock Enabled"];
connecting [label="SDC_CONN.ING\nConnecting"];
disconnecting [label="SDC_DISC.ING\nDisconnecting"];
active [label="SDC_ACTIVE\nCard Ready"];
reading [label="SDC_READING\nReading"];
writing [label="SDC_WRITING\nWriting"];
uninit -> stop [label=" sdcInit()", constraint=false];
stop -> stop [label="\nsdcStop()"];
stop -> ready [label="\nsdcStart()"];
ready -> stop [label="\nsdcStop()"];
ready -> ready [label="\nsdcStart()\nsdcDisconnect()"];
ready -> connecting [label="\nsdcConnect()"];
connecting -> active [label="\nconnection\nsuccessful"];
connecting -> active [label="\nsdcConnect()", dir="back"];
connecting -> ready [label="\nconnection\nfailed"];
disconnecting -> active [label="\nsdcDisconnect()", dir="back"];
ready -> disconnecting [label="\ndisconnection\nfinished", dir="back"];
active -> reading [label="\nsdcRead()"];
reading -> active [label="\nread finished\nread error"];
active -> writing [label="\nsdcWrite()"];
writing -> active [label="\nwrite finished\nwrite error"];
}
* @enddot
* @endif
* This driver implements a state machine internally, see the @ref IO_BLOCK
* module documentation for details.
*
* @section sdc_2 SDC Operations.
* @section sdc_2 Driver Operations
* This driver allows to read or write single or multiple 512 bytes blocks
* on a SD Card.
*

17
os/hal/hal.dox
View File

@ -81,20 +81,3 @@
*
* @ingroup IO
*/
/**
* @defgroup IO_CHANNEL Abstract I/O Channels
* @ingroup IO
*/
/**
* @defgroup IO_BLOCK Abstract I/O Block Device
* @ingroup IO
*/
/**
* @defgroup MMCSD MMC/SD Block Devices common ancestor
* @details This module implements a common ancestor for all device drivers
* accessing MMC or SD cards.
* @ingroup IO
*/

6
os/hal/include/io_block.h
View File

@ -21,12 +21,12 @@
/**
* @file io_block.h
* @brief I/O block devices access.
* @details This header defines abstract interfaces useful to access generic
* @details This header defines an abstract interface useful to access generic
* I/O block devices in a standardized way.
*
* @addtogroup IO_BLOCK
* @details This module define an abstract interface for accessing generic
* block devices.
* @details This module defines an abstract interface for accessing generic
* block devices.<br>
* Note that no code is present, just abstract interfaces-like
* structures, you should look at the system as to a set of
* abstract C++ classes (even if written in C). This system

13
os/hal/include/io_channel.h
View File

@ -21,16 +21,17 @@
/**
* @file io_channel.h
* @brief I/O channels access.
* @details This header defines abstract interfaces useful to access generic
* @details This header defines an abstract interface useful to access generic
* I/O serial devices in a standardized way.
*
* @addtogroup IO_CHANNEL
* @details This module defines an abstract interface for I/O channels by
* extending the @p BaseSequentialStream interface. Note that no code
* is present, I/O channels are just abstract interface like
* structures, you should look at the systems as to a set of abstract
* C++ classes (even if written in C). Specific device drivers can
* use/extend the interface and implement them.<br>
* extending the @p BaseSequentialStream interface.<br>
* Note that no code is present, I/O channels are just abstract
* interface like structures, you should look at the systems as
* to a set of abstract C++ classes (even if written in C).
* Specific device drivers can use/extend the interface and
* implement them.<br>
* This system has the advantage to make the access to channels
* independent from the implementation logic.
* @{

2
os/hal/include/mmcsd.h
View File

@ -21,6 +21,8 @@
/**
* @file mmcsd.h
* @brief MMC/SD cards common header.
* @details This header defines an abstract interface useful to access MMC/SD
* I/O block devices in a standardized way.
*
* @addtogroup MMCSD
* @{

7
os/ports/GCC/PPC/chcore.c
View File

@ -63,11 +63,10 @@ void port_halt(void) {
* is responsible for the context switch between 2 threads.
* @note The implementation of this code affects <b>directly</b> the context
* switch performance so optimize here as much as you can.
*
* @param[in] ntp the thread to be switched in
* @param[in] otp the thread to be switched out
*/
#if !defined(__DOXYGEN__)
__attribute__((naked))
#endif
void port_dummy1(void) {
asm (".global _port_switch");
@ -96,7 +95,9 @@ void port_dummy1(void) {
* @details If the work function returns @p chThdExit() is automatically
* invoked.
*/
#if !defined(__DOXYGEN__)
__attribute__((naked))
#endif
void port_dummy2(void) {
asm (".global _port_thread_start");

427
os/various/cpp_wrappers/ch.hpp
View File

@ -192,15 +192,15 @@ namespace chibios_rt {
* @brief Enables a virtual timer.
* @note The associated function is invoked from interrupt context.
*
* @param[in] time the number of ticks before the operation timeouts, the
* special values are handled as follow:
* @param[in] time the number of ticks before the operation timeouts,
* the special values are handled as follow:
* - @a TIME_INFINITE is allowed but interpreted as a
* normal time specification.
* - @a TIME_IMMEDIATE this value is not allowed.
* .
* @param[in] vtfunc the timer callback function. After invoking the
* callback the timer is disabled and the structure can
* be disposed or reused.
* callback the timer is disabled and the structure
* can be disposed or reused.
* @param[in] par a parameter that will be passed to the callback
* function
*
@ -289,6 +289,8 @@ namespace chibios_rt {
/**
* @brief Resumes the currently referenced thread, if any.
*
* @param[in] msg the wakeup message
*
* @api
*/
void resume(msg_t msg);
@ -296,6 +298,8 @@ namespace chibios_rt {
/**
* @brief Resumes the currently referenced thread, if any.
*
* @param[in] msg the wakeup message
*
* @iclass
*/
void resumeI(msg_t msg);
@ -305,8 +309,8 @@ namespace chibios_rt {
* @pre The target thread must be written to invoke periodically
* @p chThdShouldTerminate() and terminate cleanly if it returns
* @p TRUE.
* @post The specified thread will terminate after detecting the termination
* condition.
* @post The specified thread will terminate after detecting the
* termination condition.
*
* @api
*/
@ -317,10 +321,11 @@ namespace chibios_rt {
* @brief Blocks the execution of the invoking thread until the specified
* thread terminates then the exit code is returned.
* @details This function waits for the specified thread to terminate then
* decrements its reference counter, if the counter reaches zero then
* the thread working area is returned to the proper allocator.<br>
* The memory used by the exited thread is handled in different ways
* depending on the API that spawned the thread:
* decrements its reference counter, if the counter reaches zero
* then the thread working area is returned to the proper
* allocator.<br>
* The memory used by the exited thread is handled in different
* ways depending on the API that spawned the thread:
* - If the thread was spawned by @p chThdCreateStatic() or by
* @p chThdCreateI() then nothing happens and the thread working
* area is not released or modified in any way. This is the
@ -334,12 +339,12 @@ namespace chibios_rt {
* order to use this function.
* @post Enabling @p chThdWait() requires 2-4 (depending on the
* architecture) extra bytes in the @p Thread structure.
* @post After invoking @p chThdWait() the thread pointer becomes invalid
* and must not be used as parameter for further system calls.
* @note If @p CH_USE_DYNAMIC is not specified this function just waits for
* the thread termination, no memory allocators are involved.
* @post After invoking @p chThdWait() the thread pointer becomes
* invalid and must not be used as parameter for further system
* calls.
* @note If @p CH_USE_DYNAMIC is not specified this function just waits
* for the thread termination, no memory allocators are involved.
*
* @param[in] tp pointer to the thread
* @return The exit code from the terminated thread.
*
* @api
@ -371,7 +376,6 @@ namespace chibios_rt {
/**
* @brief Returns an enqueued message or @p NULL.
*
* @param[in] trp the sender thread reference
* @return The incoming message.
*
* @api
@ -381,7 +385,6 @@ namespace chibios_rt {
/**
* @brief Releases the next message in queue with a reply.
*
* @param[in] trp the sender thread reference
* @param[in] msg the answer message
*
* @api
@ -414,7 +417,7 @@ namespace chibios_rt {
};
/*------------------------------------------------------------------------*
* chibios_rt::BaseThread *
* chibios_rt::BaseThread *
*------------------------------------------------------------------------*/
/**
* @brief Abstract base class for a ChibiOS/RT thread.
@ -454,7 +457,7 @@ namespace chibios_rt {
* @pre This function only stores the pointer to the name if the option
* @p CH_USE_REGISTRY is enabled else no action is performed.
*
* @param[in] p thread name as a zero terminated string
* @param[in] tname thread name as a zero terminated string
*
* @api
*/
@ -507,7 +510,8 @@ namespace chibios_rt {
static void exitS(msg_t msg);
/**
* @brief Verifies if the current thread has a termination request pending.
* @brief Verifies if the current thread has a termination request
* pending.
* @note Can be invoked in any context.
*
* @retval TRUE termination request pending.
@ -520,10 +524,10 @@ namespace chibios_rt {
/**
* @brief Suspends the invoking thread for the specified time.
*
* @param[in] time the delay in system ticks, the special values are
* @param[in] interval the delay in system ticks, the special values are
* handled as follow:
* - @a TIME_INFINITE the thread enters an infinite sleep
* state.
* - @a TIME_INFINITE the thread enters an infinite
* sleep state.
* - @a TIME_IMMEDIATE this value is not allowed.
* .
*
@ -532,8 +536,8 @@ namespace chibios_rt {
static void sleep(systime_t interval);
/**
* @brief Suspends the invoking thread until the system time arrives to the
* specified value.
* @brief Suspends the invoking thread until the system time arrives to
* the specified value.
*
* @param[in] time absolute system time
*
@ -543,8 +547,8 @@ namespace chibios_rt {
/**
* @brief Yields the time slot.
* @details Yields the CPU control to the next thread in the ready list with
* equal priority, if any.
* @details Yields the CPU control to the next thread in the ready list
* with equal priority, if any.
*
* @api
*/
@ -574,7 +578,8 @@ namespace chibios_rt {
/**
* @brief Adds (OR) a set of event flags on the current thread, this is
* @b much faster than using @p chEvtBroadcast() or @p chEvtSignal().
* @b much faster than using @p chEvtBroadcast() or
* @p chEvtSignal().
*
* @param[in] mask the event flags to be added
* @return The current pending events mask.
@ -643,7 +648,8 @@ namespace chibios_rt {
* @param[in] ewmask mask of the events that the function should
* wait for, @p ALL_EVENTS enables all the events
*
* @param[in] time the number of ticks before the operation timouts
* @param[in] time the number of ticks before the operation
* timouts
* @return The mask of the lowest id served and cleared
* event.
* @retval 0 if the specified timeout expired.
@ -693,8 +699,8 @@ namespace chibios_rt {
* @brief Invokes the event handlers associated to an event flags mask.
*
* @param[in] mask mask of the event flags to be dispatched
* @param[in] handlers an array of @p evhandler_t. The array must have size
* equal to the number of bits in eventmask_t.
* @param[in] handlers an array of @p evhandler_t. The array must have
* size equal to the number of bits in eventmask_t.
*
* @api
*/
@ -735,8 +741,8 @@ namespace chibios_rt {
* mutexes are unlocked.
* @note This function is <b>MUCH MORE</b> efficient than releasing the
* mutexes one by one and not just because the call overhead,
* this function does not have any overhead related to the priority
* inheritance mechanism.
* this function does not have any overhead related to the
* priority inheritance mechanism.
*
* @api
*/
@ -756,7 +762,7 @@ namespace chibios_rt {
template <int N>
class BaseStaticThread : public BaseThread {
protected:
WORKING_AREA(wa, N); // Thread working area.
WORKING_AREA(wa, N);
public:
/**
@ -815,14 +821,14 @@ namespace chibios_rt {
/**
* @brief Performs a reset operation on the semaphore.
* @post After invoking this function all the threads waiting on the
* semaphore, if any, are released and the semaphore counter is set
* to the specified, non negative, value.
* @note The released threads can recognize they were waked up by a reset
* rather than a signal because the @p chSemWait() will return
* @p RDY_RESET instead of @p RDY_OK.
* semaphore, if any, are released and the semaphore counter is
* set to the specified, non negative, value.
* @note The released threads can recognize they were waked up by a
* reset rather than a signal because the @p chSemWait() will
* return @p RDY_RESET instead of @p RDY_OK.
*
* @param[in] n the new value of the semaphore counter. The value must
* be non-negative.
* @param[in] n the new value of the semaphore counter. The value
* must be non-negative.
*
* @api
*/
@ -831,18 +837,18 @@ namespace chibios_rt {
/**
* @brief Performs a reset operation on the semaphore.
* @post After invoking this function all the threads waiting on the
* semaphore, if any, are released and the semaphore counter is set
* to the specified, non negative, value.
* semaphore, if any, are released and the semaphore counter is
* set to the specified, non negative, value.
* @post This function does not reschedule so a call to a rescheduling
* function must be performed before unlocking the kernel. Note that
* interrupt handlers always reschedule on exit so an explicit
* reschedule must not be performed in ISRs.
* @note The released threads can recognize they were waked up by a reset
* rather than a signal because the @p chSemWait() will return
* @p RDY_RESET instead of @p RDY_OK.
* function must be performed before unlocking the kernel. Note
* that interrupt handlers always reschedule on exit so an
* explicit reschedule must not be performed in ISRs.
* @note The released threads can recognize they were waked up by a
* reset rather than a signal because the @p chSemWait() will
* return @p RDY_RESET instead of @p RDY_OK.
*
* @param[in] n the new value of the semaphore counter. The value must
* be non-negative.
* @param[in] n the new value of the semaphore counter. The value
* must be non-negative.
*
* @iclass
*/
@ -851,11 +857,12 @@ namespace chibios_rt {
/**
* @brief Performs a wait operation on a semaphore.
*
* @return A message specifying how the invoking thread has been
* released from the semaphore.
* @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().
* @return A message specifying how the invoking thread has
* been released from the semaphore.
* @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
*/
@ -864,51 +871,56 @@ namespace chibios_rt {
/**
* @brief Performs a wait operation on a semaphore.
*
* @return A message specifying how the invoking thread has been
* released from the semaphore.
* @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().
* @return A message specifying how the invoking thread has
* been released from the semaphore.
* @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 waitS(void);
/**
* @brief Performs a wait operation on a semaphore with timeout specification.
* @brief Performs a wait operation on a semaphore with timeout
* specification.
*
* @param[in] time the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
* .
* @return A message specifying how the invoking thread has been
* released from the semaphore.
* @retval 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().
* @retval RDY_TIMEOUT if the semaphore has not been signaled or reset within
* the specified timeout.
* @return A message specifying how the invoking thread has
* been released from the semaphore.
* @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().
* @retval RDY_TIMEOUT if the semaphore has not been signaled or reset
* within the specified timeout.
*
* @api
*/
msg_t waitTimeout(systime_t time);
/**
* @brief Performs a wait operation on a semaphore with timeout specification.
* @brief Performs a wait operation on a semaphore with timeout
* specification.
*
* @param[in] time the number of ticks before the operation timeouts,
* the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
* .
* @return A message specifying how the invoking thread has been
* released from the semaphore.
* @retval 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().
* @retval RDY_TIMEOUT if the semaphore has not been signaled or reset within
* the specified timeout.
* @return A message specifying how the invoking thread has
* been released from the semaphore.
* @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().
* @retval RDY_TIMEOUT if the semaphore has not been signaled or reset
* within the specified timeout.
*
* @sclass
*/
@ -924,9 +936,9 @@ namespace chibios_rt {
/**
* @brief Performs a signal operation on a semaphore.
* @post This function does not reschedule so a call to a rescheduling
* function must be performed before unlocking the kernel. Note that
* interrupt handlers always reschedule on exit so an explicit
* reschedule must not be performed in ISRs.
* function must be performed before unlocking the kernel. Note
* that interrupt handlers always reschedule on exit so an
* explicit reschedule must not be performed in ISRs.
*
* @iclass
*/
@ -935,12 +947,12 @@ namespace chibios_rt {
/**
* @brief Adds the specified value to the semaphore counter.
* @post This function does not reschedule so a call to a rescheduling
* function must be performed before unlocking the kernel. Note that
* interrupt handlers always reschedule on exit so an explicit
* function must be performed before unlocking the kernel. Note
* that interrupt handlers always reschedule on exit so an explicit
* reschedule must not be performed in ISRs.
*
* @param[in] n value to be added to the semaphore counter. The value
* must be positive.
* @param[in] n value to be added to the semaphore counter. The
* value must be positive.
*
* @iclass
*/
@ -949,6 +961,8 @@ namespace chibios_rt {
/**
* @brief Returns the semaphore counter value.
*
* @return The semaphore counter value.
*
* @iclass
*/
cnt_t getCounterI(void);
@ -959,11 +973,12 @@ namespace chibios_rt {
*
* @param[in] ssem @p Semaphore object to be signaled
* @param[in] wsem @p Semaphore object to wait on
* @return A message specifying how the invoking thread has been
* released from the semaphore.
* @retval 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().
* @return A message specifying how the invoking thread
* has been released from the semaphore.
* @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
*/
@ -1000,9 +1015,10 @@ namespace chibios_rt {
/**
* @brief Wait operation on the binary semaphore.
*
* @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.
* @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().
*
@ -1013,9 +1029,10 @@ namespace chibios_rt {
/**
* @brief Wait operation on the binary semaphore.
*
* @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.
* @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().
*
@ -1031,13 +1048,14 @@ namespace chibios_rt {
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
* .
* @return A message specifying how the invoking thread has been
* released from the semaphore.
* @retval RDY_OK if the binary semaphore has 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 has not been signaled or reset
* within the specified timeout.
* @retval RDY_TIMEOUT if the binary semaphore has not been signaled
* or reset within the specified timeout.
*
* @api
*/
@ -1051,13 +1069,14 @@ namespace chibios_rt {
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
* .
* @return A message specifying how the invoking thread has been
* released from the semaphore.
* @retval RDY_OK if the binary semaphore has 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 has not been signaled or reset
* within the specified timeout.
* @retval RDY_TIMEOUT if the binary semaphore has not been signaled
* or reset within the specified timeout.
*
* @sclass
*/
@ -1065,9 +1084,9 @@ namespace chibios_rt {
/**
* @brief Reset operation on the binary semaphore.
* @note The released threads can recognize they were waked up by a reset
* rather than a signal because the @p bsemWait() will return
* @p RDY_RESET instead of @p RDY_OK.
* @note The released threads can recognize they were waked up by a
* reset rather than a signal because the @p bsemWait() will
* return @p RDY_RESET instead of @p RDY_OK.
*
* @param[in] taken new state of the binary semaphore
* - @a FALSE, the new state is not taken.
@ -1080,9 +1099,9 @@ namespace chibios_rt {
/**
* @brief Reset operation on the binary semaphore.
* @note The released threads can recognize they were waked up by a reset
* rather than a signal because the @p bsemWait() will return
* @p RDY_RESET instead of @p RDY_OK.
* @note The released threads can recognize they were waked up by a
* reset rather than a signal because the @p bsemWait() will
* return @p RDY_RESET instead of @p RDY_OK.
* @note This function does not reschedule.
*
* @param[in] taken new state of the binary semaphore
@ -1147,9 +1166,10 @@ namespace chibios_rt {
/**
* @brief Tries to lock a mutex.
* @details This function attempts to lock a mutex, if the mutex is already
* locked by another thread then the function exits without waiting.
* @post The mutex is locked and inserted in the per-thread stack of owned
* mutexes.
* locked by another thread then the function exits without
* waiting.
* @post The mutex is locked and inserted in the per-thread stack of
* owned mutexes.
* @note This function does not have any overhead related to the
* priority inheritance mechanism because it does not try to
* enter a sleep state.
@ -1165,9 +1185,10 @@ namespace chibios_rt {
/**
* @brief Tries to lock a mutex.
* @details This function attempts to lock a mutex, if the mutex is already
* taken by another thread then the function exits without waiting.
* @post The mutex is locked and inserted in the per-thread stack of owned
* mutexes.
* taken by another thread then the function exits without
* waiting.
* @post The mutex is locked and inserted in the per-thread stack of
* owned mutexes.
* @note This function does not have any overhead related to the
* priority inheritance mechanism because it does not try to
* enter a sleep state.
@ -1182,8 +1203,8 @@ namespace chibios_rt {
/**
* @brief Locks the specified mutex.
* @post The mutex is locked and inserted in the per-thread stack of owned
* mutexes.
* @post The mutex is locked and inserted in the per-thread stack of
* owned mutexes.
*
* @api
*/
@ -1191,8 +1212,8 @@ namespace chibios_rt {
/**
* @brief Locks the specified mutex.
* @post The mutex is locked and inserted in the per-thread stack of owned
* mutexes.
* @post The mutex is locked and inserted in the per-thread stack of
* owned mutexes.
*
* @sclass
*/
@ -1231,9 +1252,9 @@ namespace chibios_rt {
/**
* @brief Signals one thread that is waiting on the condition variable.
* @post This function does not reschedule so a call to a rescheduling
* function must be performed before unlocking the kernel. Note that
* interrupt handlers always reschedule on exit so an explicit
* reschedule must not be performed in ISRs.
* function must be performed before unlocking the kernel. Note
* that interrupt handlers always reschedule on exit so an
* explicit reschedule must not be performed in ISRs.
*
* @iclass
*/
@ -1249,9 +1270,9 @@ namespace chibios_rt {
/**
* @brief Signals all threads that are waiting on the condition variable.
* @post This function does not reschedule so a call to a rescheduling
* function must be performed before unlocking the kernel. Note that
* interrupt handlers always reschedule on exit so an explicit
* reschedule must not be performed in ISRs.
* function must be performed before unlocking the kernel. Note
* that interrupt handlers always reschedule on exit so an
* explicit reschedule must not be performed in ISRs.
*
* @iclass
*/
@ -1260,12 +1281,12 @@ namespace chibios_rt {
/**
* @brief Waits on the condition variable releasing the mutex lock.
* @details Releases the currently owned mutex, waits on the condition
* variable, and finally acquires the mutex again. All the sequence
* is performed atomically.
* variable, and finally acquires the mutex again. All the
* sequence is performed atomically.
* @pre The invoking thread <b>must</b> have at least one owned mutex.
*
* @return A message specifying how the invoking thread has been
* released from the condition variable.
* @return A message specifying how the invoking thread has
* been released from the condition variable.
* @retval RDY_OK if the condvar has been signaled using
* @p chCondSignal().
* @retval RDY_RESET if the condvar has been signaled using
@ -1278,12 +1299,12 @@ namespace chibios_rt {
/**
* @brief Waits on the condition variable releasing the mutex lock.
* @details Releases the currently owned mutex, waits on the condition
* variable, and finally acquires the mutex again. All the sequence
* is performed atomically.
* variable, and finally acquires the mutex again. All the
* sequence is performed atomically.
* @pre The invoking thread <b>must</b> have at least one owned mutex.
*
* @return A message specifying how the invoking thread has been
* released from the condition variable.
* @return A message specifying how the invoking thread has
* been released from the condition variable.
* @retval RDY_OK if the condvar has been signaled using
* @p chCondSignal().
* @retval RDY_RESET if the condvar has been signaled using
@ -1316,7 +1337,7 @@ namespace chibios_rt {
#if CH_USE_EVENTS || defined(__DOXYGEN__)
/*------------------------------------------------------------------------*
* chibios_rt::EvtListener *
* chibios_rt::EvtListener *
*------------------------------------------------------------------------*/
/**
* @brief Class encapsulating an event listener.
@ -1324,14 +1345,13 @@ namespace chibios_rt {
class EvtListener {
public:
/**
* @brief Embedded @p ::EvtListener structure.
* @brief Embedded @p ::EventListener structure.
*/
struct ::EventListener ev_listener;
/**
* @brief Returns the pending flags from the listener and clears them.
*
* @param[in] flags the events to be cleared
* @return The flags added to the listener by the
* associated event source.
*
@ -1353,7 +1373,7 @@ namespace chibios_rt {
};
/*------------------------------------------------------------------------*
* chibios_rt::EvtSource *
* chibios_rt::EvtSource *
*------------------------------------------------------------------------*/
/**
* @brief Class encapsulating an event source.
@ -1361,13 +1381,13 @@ namespace chibios_rt {
class EvtSource {
public:
/**
* @brief Embedded @p ::EvtSource structure.
* @brief Embedded @p ::EventSource structure.
*/
struct ::EventSource ev_source;
/**
* @brief EvtSource object constructor.
* @details The embedded @p ::EvtSource structure is initialized.
* @details The embedded @p ::EventSource structure is initialized.
*
* @init
*/
@ -1454,7 +1474,8 @@ namespace chibios_rt {
* @param[in] bp pointer to a memory area allocated as queue buffer
* @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.
* data is read from the queue. The value can be
* @p NULL.
* @param[in] link application defined pointer
*
* @init
@ -1529,9 +1550,9 @@ namespace chibios_rt {
/**
* @brief Input queue read.
* @details This function reads a byte value from an input queue. If the queue
* is empty then the calling thread is suspended until a byte arrives
* in the queue.
* @details This function reads a byte value from an input queue. If the
* queue is empty then the calling thread is suspended until a
* byte arrives in the queue.
*
* @return A byte value from the queue.
* @retval Q_RESET if the queue has been reset.
@ -1542,9 +1563,9 @@ namespace chibios_rt {
/**
* @brief Input queue read with timeout.
* @details This function reads a byte value from an input queue. If the queue
* is empty then the calling thread is suspended until a byte arrives
* in the queue or a timeout occurs.
* @details This function reads a byte value from an input queue. If the
* queue is empty then the calling thread is suspended until a
* byte arrives in the queue or a timeout occurs.
* @note The callback is invoked before reading the character from the
* buffer or before entering the state @p THD_STATE_WTQUEUE.
*
@ -1567,8 +1588,8 @@ namespace chibios_rt {
* operation completes when the specified amount of data has been
* transferred or after the specified timeout or if the queue has
* been reset.
* @note The function is not atomic, if you need atomicity it is suggested
* to use a semaphore or a mutex for mutual exclusion.
* @note The function is not atomic, if you need atomicity it is
* suggested to use a semaphore or a mutex for mutual exclusion.
* @note The callback is invoked before reading each character from the
* buffer or before entering the state @p THD_STATE_WTQUEUE.
*
@ -1604,6 +1625,9 @@ namespace chibios_rt {
/**
* @brief InQueueBuffer constructor.
*
* @param[in] infy input notify callback function
* @param[in] link parameter to be passed to the callback
*
* @init
*/
InQueueBuffer(qnotify_t infy, void *link) : InQueue(iq_buf, N,
@ -1631,7 +1655,8 @@ namespace chibios_rt {
* @param[in] bp pointer to a memory area allocated as queue buffer
* @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.
* data is written to the queue. The value can be
* @p NULL.
* @param[in] link application defined pointer
*
* @init
@ -1682,10 +1707,10 @@ namespace chibios_rt {
/**
* @brief Resets an output queue.
* @details All the data in the output queue is erased and lost, any waiting
* thread is resumed with status @p Q_RESET.
* @note A reset operation can be used by a low level driver in order to
* obtain immediate attention from the high level layers.
* @details All the data in the output queue is erased and lost, any
* waiting thread is resumed with status @p Q_RESET.
* @note A reset operation can be used by a low level driver in order
* to obtain immediate attention from the high level layers.
*
* @iclass
*/
@ -1693,9 +1718,9 @@ namespace chibios_rt {
/**
* @brief Output queue write.
* @details This function writes a byte value to an output queue. If the queue
* is full then the calling thread is suspended until there is space
* in the queue.
* @details This function writes a byte value to an output queue. If the
* queue is full then the calling thread is suspended until there
* is space in the queue.
*
* @param[in] b the byte value to be written in the queue
* @return The operation status.
@ -1708,9 +1733,9 @@ namespace chibios_rt {
/**
* @brief Output queue write with timeout.
* @details This function writes a byte value to an output queue. If the queue
* is full then the calling thread is suspended until there is space
* in the queue or a timeout occurs.
* @details This function writes a byte value to an output queue. If the
* queue is full then the calling thread is suspended until there
* is space in the queue or a timeout occurs.
* @note The callback is invoked after writing the character into the
* buffer.
*
@ -1746,8 +1771,8 @@ namespace chibios_rt {
* operation completes when the specified amount of data has been
* transferred or after the specified timeout or if the queue has
* been reset.
* @note The function is not atomic, if you need atomicity it is suggested
* to use a semaphore or a mutex for mutual exclusion.
* @note The function is not atomic, if you need atomicity it is
* suggested to use a semaphore or a mutex for mutual exclusion.
* @note The callback is invoked after writing each character into the
* buffer.
*
@ -1783,6 +1808,9 @@ namespace chibios_rt {
/**
* @brief OutQueueBuffer constructor.
*
* @param[in] onfy output notify callback function
* @param[in] link parameter to be passed to the callback
*
* @init
*/
OutQueueBuffer(qnotify_t onfy, void *link) : OutQueue(oq_buf, N,
@ -1819,8 +1847,8 @@ namespace chibios_rt {
/**
* @brief Resets a Mailbox object.
* @details All the waiting threads are resumed with status @p RDY_RESET and
* the queued messages are lost.
* @details All the waiting threads are resumed with status @p RDY_RESET
* and the queued messages are lost.
*
* @api
*/
@ -1828,8 +1856,8 @@ namespace chibios_rt {
/**
* @brief Posts a message into a mailbox.
* @details The invoking thread waits until a empty slot in the mailbox becomes
* available or the specified time runs out.
* @details The invoking thread waits until a empty slot in the mailbox
* becomes available or the specified time runs out.
*
* @param[in] msg the message to be posted on the mailbox
* @param[in] time the number of ticks before the operation timeouts,
@ -1848,8 +1876,8 @@ namespace chibios_rt {
/**
* @brief Posts a message into a mailbox.
* @details The invoking thread waits until a empty slot in the mailbox becomes
* available or the specified time runs out.
* @details The invoking thread waits until a empty slot in the mailbox
* becomes available or the specified time runs out.
*
* @param[in] msg the message to be posted on the mailbox
* @param[in] time the number of ticks before the operation timeouts,
@ -1883,8 +1911,8 @@ namespace chibios_rt {
/**
* @brief Posts an high priority message into a mailbox.
* @details The invoking thread waits until a empty slot in the mailbox becomes
* available or the specified time runs out.
* @details The invoking thread waits until a empty slot in the mailbox
* becomes available or the specified time runs out.
*
* @param[in] msg the message to be posted on the mailbox
* @param[in] time the number of ticks before the operation timeouts,
@ -1903,8 +1931,8 @@ namespace chibios_rt {
/**
* @brief Posts an high priority message into a mailbox.
* @details The invoking thread waits until a empty slot in the mailbox becomes
* available or the specified time runs out.
* @details The invoking thread waits until a empty slot in the mailbox
* becomes available or the specified time runs out.
*
* @param[in] msg the message to be posted on the mailbox
* @param[in] time the number of ticks before the operation timeouts,
@ -1938,12 +1966,12 @@ namespace chibios_rt {
/**
* @brief Retrieves a message from a mailbox.
* @details The invoking thread waits until a message is posted in the mailbox
* or the specified time runs out.
* @details The invoking thread waits until a message is posted in the
* mailbox or the specified time runs out.
*
* @param[out] msgp pointer to a message variable for the received message
* @param[in] time the number of ticks before the operation timeouts,
* the following special values are allowed:
* @param[out] msgp pointer to a message variable for the received
* @param[in] time message the number of ticks before the operation
* timeouts, the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
* .
@ -1958,12 +1986,12 @@ namespace chibios_rt {
/**
* @brief Retrieves a message from a mailbox.
* @details The invoking thread waits until a message is posted in the mailbox
* or the specified time runs out.
* @details The invoking thread waits until a message is posted in the
* mailbox or the specified time runs out.
*
* @param[out] msgp pointer to a message variable for the received message
* @param[in] time the number of ticks before the operation timeouts,
* the following special values are allowed:
* @param[out] msgp pointer to a message variable for the received
* @param[in] time message the number of ticks before the operation
* timeouts, the following special values are allowed:
* - @a TIME_IMMEDIATE immediate timeout.
* - @a TIME_INFINITE no timeout.
* .
@ -1981,7 +2009,8 @@ namespace chibios_rt {
* @details This variant is non-blocking, the function returns a timeout
* condition if the queue is empty.
*
* @param[out] msgp pointer to a message variable for the received message
* @param[out] msgp pointer to a message variable for the received
* message
* @return The operation status.
* @retval RDY_OK if a message has been correctly fetched.
* @retval RDY_TIMEOUT if the mailbox is empty and a message cannot be
@ -2034,9 +2063,9 @@ namespace chibios_rt {
/**
* @brief MemoryPool constructor.
*
* @param[in] size the size of the objects contained in this memory pool,
* the minimum accepted size is the size of a pointer to
* void.
* @param[in] size the size of the objects contained in this memory
* pool, the minimum accepted size is the size of
* a pointer to void.
* @param[in] provider memory provider function for the memory pool or
* @p NULL if the pool is not allowed to grow
* automatically
@ -2048,9 +2077,9 @@ namespace chibios_rt {
/**
* @brief MemoryPool constructor.
*
* @param[in] size the size of the objects contained in this memory pool,
* the minimum accepted size is the size of a pointer to
* void.
* @param[in] size the size of the objects contained in this memory
* pool, the minimum accepted size is the size of
* a pointer to void.
* @param[in] provider memory provider function for the memory pool or
* @p NULL if the pool is not allowed to grow
* automatically
@ -2102,7 +2131,8 @@ namespace chibios_rt {
* @pre The memory pool must be already been initialized.
* @pre The freed object must be of the right size for the specified
* memory pool.
* @pre The object must be properly aligned to contain a pointer to void.
* @pre The object must be properly aligned to contain a pointer to
* void.
*
* @param[in] objp the pointer to the object to be released
*
@ -2173,9 +2203,9 @@ namespace chibios_rt {
*
* @param[in] bp pointer to the data buffer
* @param[in] n the maximum amount of data to be transferred
* @return The number of bytes transferred. The return value can
* be less than the specified number of bytes if an
* end-of-file condition has been met.
* @return The number of bytes transferred. The return value
* can be less than the specified number of bytes if
* an end-of-file condition has been met.
*
* @api
*/
@ -2187,9 +2217,9 @@ namespace chibios_rt {
*
* @param[out] bp pointer to the data buffer
* @param[in] n the maximum amount of data to be transferred
* @return The number of bytes transferred. The return value can
* be less than the specified number of bytes if an
* end-of-file condition has been met.
* @return The number of bytes transferred. The return value
* can be less than the specified number of bytes if
* an end-of-file condition has been met.
*
* @api
*/
@ -2198,7 +2228,8 @@ namespace chibios_rt {
/**
* @brief Sequential Stream blocking byte write.
* @details This function writes a byte value to a channel. If the channel
* is not ready to accept data then the calling thread is suspended.
* is not ready to accept data then the calling thread is
* suspended.
*
* @param[in] b the byte value to be written to the channel
*