Fixed Serial peripheral driver not turning off the USART before reconfiguring it...

[pub/USBasp.git] / Projects / USBtoSerial / Lib / LightweightRingBuff.h

diff --git a/Projects/USBtoSerial/Lib/LightweightRingBuff.h b/Projects/USBtoSerial/Lib/LightweightRingBuff.h
index 89239ac..2faef43 100644 (file)
--- a/Projects/USBtoSerial/Lib/LightweightRingBuff.h
+++ b/Projects/USBtoSerial/Lib/LightweightRingBuff.h
@@ -44,7 +44,7 @@
 
        /* Defines: */
                /** Size of each ring buffer, in data elements - must be between 1 and 255. */
 
        /* Defines: */
                /** Size of each ring buffer, in data elements - must be between 1 and 255. */

-               #define BUFFER_SIZE      128
+               #define BUFFER_SIZE      255

                
                /** Type of data to store into the buffer. */
                #define RingBuff_Data_t  uint8_t
                
                /** Type of data to store into the buffer. */
                #define RingBuff_Data_t  uint8_t


@@ -62,11 +62,11 @@
                } RingBuff_t;
        
        /* Inline Functions: */
                } RingBuff_t;
        
        /* Inline Functions: */

-               /** Initializes a ring buffer ready for use. Buffers must be initialized via this function
+               /** Initialises a ring buffer ready for use. Buffers must be initialized via this function

                 *  before any operations are called upon them. Already initialized buffers may be reset
                 *  by re-initializing them using this function.
                 *
                 *  before any operations are called upon them. Already initialized buffers may be reset
                 *  by re-initializing them using this function.
                 *

-                *  \ref Buffer  Pointer to a ring buffer structure to initialize
+                *  \param[out] Buffer  Pointer to a ring buffer structure to initialize

                 */
                static inline void RingBuffer_InitBuffer(RingBuff_t* const Buffer)
                {
                 */
                static inline void RingBuffer_InitBuffer(RingBuff_t* const Buffer)
                {


@@ -75,12 +75,33 @@
                        Buffer->Count = 0;
                }
                
                        Buffer->Count = 0;
                }
                

-               /** Inserts an element into the ring buffer.
+               /** Atomically determines if the specified ring buffer contains any free space. This should
+                *  be tested before storing data to the buffer, to ensure that no data is lost due to a
+                *  buffer overrun.
+                *
+                *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into
+                *
+                *  \return Boolean true if the buffer contains no free space, false otherwise
+                */              
+               static inline bool RingBuffer_IsFull(RingBuff_t* const Buffer)
+               {
+                       bool IsFull;
+                       
+                       ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
+                       {
+                               IsFull = (Buffer->Count == BUFFER_SIZE);
+                       }
+                       
+                       return IsFull;
+               }
+               
+               /** Atomically inserts an element into the ring buffer.

                 *
                 *

-                *  \ref Buffer  Pointer to a ring buffer structure to insert into
-                *  \ref Data    Data element to insert into the buffer
+                *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into
+                *  \param[in]     Data    Data element to insert into the buffer

                 */
                 */

-               static inline void RingBuffer_Insert(RingBuff_t* const Buffer, RingBuff_Data_t Data)
+               static inline void RingBuffer_AtomicInsert(RingBuff_t* const Buffer,
+                                                          const RingBuff_Data_t Data)

                {
                        ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
                        {
                {
                        ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
                        {


@@ -93,13 +114,13 @@
                        }
                }
 
                        }
                }
 

-               /** Retrieves an element from the ring buffer.
+               /** Atomically retrieves an element from the ring buffer.

                 *
                 *

-                *  \ref Buffer  Pointer to a ring buffer structure to retrieve from
+                *  \param[in,out] Buffer  Pointer to a ring buffer structure to retrieve from

                 *
                 *  \return Next data element stored in the buffer
                 */
                 *
                 *  \return Next data element stored in the buffer
                 */

-               static inline RingBuff_Data_t RingBuffer_Remove(RingBuff_t* const Buffer)
+               static inline RingBuff_Data_t RingBuffer_AtomicRemove(RingBuff_t* const Buffer)

                {
                        RingBuff_Data_t Data;
                        
                {
                        RingBuff_Data_t Data;
                        


@@ -116,5 +137,39 @@
                        return Data;
                }
 
                        return Data;
                }
 

+               /** Inserts an element into the ring buffer.
+                *
+                *  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into
+                *  \param[in]     Data    Data element to insert into the buffer
+                */
+               static inline void RingBuffer_Insert(RingBuff_t* const Buffer,
+                                                    const RingBuff_Data_t Data)
+               {
+                       *Buffer->In = Data;
+                       
+                       if (++Buffer->In == &Buffer->Buffer[BUFFER_SIZE])
+                         Buffer->In = Buffer->Buffer;
+                                 
+                       Buffer->Count++;
+               }
+
+               /** Retrieves an element from the ring buffer.
+                *
+                *  \param[in,out] Buffer  Pointer to a ring buffer structure to retrieve from
+                *
+                *  \return Next data element stored in the buffer
+                */
+               static inline RingBuff_Data_t RingBuffer_Remove(RingBuff_t* const Buffer)
+               {
+                       RingBuff_Data_t Data = *Buffer->Out;
+                       
+                       if (++Buffer->Out == &Buffer->Buffer[BUFFER_SIZE])
+                         Buffer->Out = Buffer->Buffer;
+                                 
+                       Buffer->Count--;
+
+                       return Data;
+               }
+

 #endif
 #endif

- 
\ No newline at end of file
+