From 87ea060afe931087e23444dfa840672aefdd7a46 Mon Sep 17 00:00:00 2001 From: Dean Camera Date: Mon, 11 Jul 2011 05:51:35 +0000 Subject: [PATCH] Added new RingBuffer_GetFreeCount() function to the library miscellaneous RingBuffer driver. --- LUFA/Drivers/Misc/RingBuffer.h | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/LUFA/Drivers/Misc/RingBuffer.h b/LUFA/Drivers/Misc/RingBuffer.h index c953638716..937cb4abfc 100644 --- a/LUFA/Drivers/Misc/RingBuffer.h +++ b/LUFA/Drivers/Misc/RingBuffer.h @@ -29,7 +29,7 @@ */ /** \file - * \brief Lightweight ring buffer, for fast insertion/deletion of bytes. + * \brief Lightweight ring (circular) buffer, for fast insertion/deletion of bytes. * * Lightweight ring buffer, for fast insertion/deletion. Multiple buffers can be created of * different sizes to suit different needs. @@ -126,7 +126,7 @@ * \param[out] DataPtr Pointer to a global array that will hold the data stored into the ring buffer. * \param[out] Size Maximum number of bytes that can be stored in the underlying data array. */ - static inline void RingBuffer_InitBuffer(RingBuffer_t* Buffer, uint8_t* const DataPtr, const uint16_t Size) + static inline void RingBuffer_InitBuffer(RingBuffer_t* const Buffer, uint8_t* const DataPtr, const uint16_t Size) { GCC_FORCE_POINTER_ACCESS(Buffer); @@ -143,18 +143,36 @@ SetGlobalInterruptMask(CurrentGlobalInt); } - /** Retrieves the minimum number of bytes stored in a particular buffer. This value is computed - * by entering an atomic lock on the buffer while the IN and OUT locations are fetched, so that - * the buffer cannot be modified while the computation takes place. This value should be cached - * when reading out the contents of the buffer, so that as small a time as possible is spent - * in an atomic lock. + /** Retrieves the free space in a particular buffer. This value is computed by entering an atomic lock + * on the buffer, so that the buffer cannot be modified while the computation takes place. + * + * \note The value returned by this function is guaranteed to only be the maximum number of bytes + * free in the given buffer; this value may change as other threads write new data, thus + * the returned number should be used only to determine how many successive writes may safely + * be performed on the buffer when there is a single writer thread. + * + * \param[in] Buffer Pointer to a ring buffer structure whose free count is to be computed. + * + * \return Number of free bytes in the buffer. + */ + static inline uint16_t RingBuffer_GetFreeCount(RingBuffer_t* const Buffer) + { + return (Buffer->Size - RingBuffer_GetCount(Buffer)); + } + + /** Retrieves the current number of bytes stored in a particular buffer. This value is computed + * by entering an atomic lock on the buffer, so that the buffer cannot be modified while the + * computation takes place. This value should be cached when reading out the contents of the buffer, + * so that as small a time as possible is spent in an atomic lock. * * \note The value returned by this function is guaranteed to only be the minimum number of bytes - * stored in the given buffer; this value may change as other threads write new data and so + * stored in the given buffer; this value may change as other threads write new data, thus * the returned number should be used only to determine how many successive reads may safely * be performed on the buffer. * * \param[in] Buffer Pointer to a ring buffer structure whose count is to be computed. + * + * \return Number of bytes currently stored in the buffer. */ static inline uint16_t RingBuffer_GetCount(RingBuffer_t* const Buffer) {