Problem with ring buffer

10 posts / 0 new
Author
Message

Two problems actually, but lets start with the first one. Using RingBuffer.h from the LUFA framework. I got rid of the need to include Common.h by putting the needed functions right into RingBuffer.h. I am getting compile errors for some reason. I have came across these errors in other instances before, but never quite understood what they mean. *REMEDIED THIS PART OF THE PROBLEM*


../RingBuffer.h:182: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'RingBuffer_IsFull'

../RingBuffer.h:199: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'RingBuffer_IsEmpty'



As far as I can see, there is no missing ';' or the like. If I comment out those two functions, it compiles perfectly.

RingBugger.h (ha ha)


/*
LUFA Library

dean [at] fourwalledcubicle [dot] com
www.lufa-lib.org
*/

/*
Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)

Permission to use, copy, modify, distribute, and sell this
software and its documentation for any purpose is hereby granted
without fee, provided that the above copyright notice appear in
all copies and that both that the copyright notice and this
permission notice and warranty disclaimer appear in supporting
documentation, and that the name of the author not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.

The author disclaim all warranties with regard to this
software, including all implied warranties of merchantability
and fitness.  In no event shall the author be liable for any
special, indirect or consequential damages or any damages
whatsoever resulting from loss of use, data or profits, whether
in an action of contract, negligence or other tortious action,
arising out of or in connection with the use or performance of
this software.
*/

/** \file
*  \brief Lightweight ring 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.
*
*  Note that for each buffer, insertion and removal operations may occur at the same time (via
*  a multi-threaded ISR based system) however the same kind of operation (two or more insertions
*  or deletions) must not overlap. If there is possibility of two or more of the same kind of
*  operating occurring at the same point in time, atomic (mutex) locking should be used.
*/

/** \ingroup Group_MiscDrivers
*  \defgroup Group_RingBuff Generic Byte Ring Buffer - LUFA/Drivers/Misc/RingBuffer.h
*  \brief Lightweight ring buffer, for fast insertion/deletion of bytes.
*
*  \section Sec_Dependencies Module Source Dependencies
*  The following files must be built with any user project that uses this module:
*    - None
*
*  \section Sec_ModDescription Module Description
*  Lightweight ring buffer, for fast insertion/deletion. Multiple buffers can be created of
*  different sizes to suit different needs.
*
*  Note that for each buffer, insertion and removal operations may occur at the same time (via
*  a multi-threaded ISR based system) however the same kind of operation (two or more insertions
*  or deletions) must not overlap. If there is possibility of two or more of the same kind of
*  operating occurring at the same point in time, atomic (mutex) locking should be used.
*
*  \section Sec_ExampleUsage Example Usage
*  The following snippet is an example of how this module may be used within a typical
*  application.
*
*  \code
*      // Create the buffer structure and its underlying storage array
*      RingBuffer_t Buffer;
*      uint8_t      BufferData[128];
*
*      // Initialise the buffer with the created storage array
*      RingBuffer_InitBuffer(&Buffer, BufferData, sizeof(BufferData));
*
*      // Insert some data into the buffer
*      RingBuffer_Insert(Buffer, 'H');
*      RingBuffer_Insert(Buffer, 'E');
*      RingBuffer_Insert(Buffer, 'L');
*      RingBuffer_Insert(Buffer, 'L');
*      RingBuffer_Insert(Buffer, 'O');
*
*      // Cache the number of stored bytes in the buffer
*      uint16_t BufferCount = RingBuffer_GetCount(&Buffer);
*
*      // Printer stored data length
*      printf("Buffer Length: #d, Buffer Data: \r\n", BufferCount);
*
*      // Print contents of the buffer one character at a time
*      while (BufferCount--)
*        putc(RingBuffer_Remove(&Buffer));
*  \endcode
*
*  @{
*/

#ifndef __RING_BUFFER_H__
#define __RING_BUFFER_H__

/* Type Defines: */

/** Forces GCC to use pointer indirection (via the device's pointer register pairs) when accessing the given
*  struct pointer. In some cases GCC will emit non-optimal assembly code when accessing a structure through
*  a pointer, resulting in a larger binary. When this macro is used on a (non \c const) structure pointer before
*  use, it will force GCC to use pointer indirection on the elements rather than direct store and load
*  instructions.
*
*  \param[in, out] StructPtr  Pointer to a structure which is to be forced into indirect access mode.
*/

#define GCC_FORCE_POINTER_ACCESS(StructPtr) __asm__ __volatile__("" : "=b" (StructPtr) : "0" (StructPtr))
/** \brief Ring Buffer Management Structure.
*
*  Type define for a new ring buffer object. Buffers should be initialized via a call to
*  \ref RingBuffer_InitBuffer() before use.
*/
typedef struct
{
uint8_t* In; /**< Current storage location in the circular buffer. */
uint8_t* Out; /**< Current retrieval location in the circular buffer. */
uint8_t* Start; /**< Pointer to the start of the buffer's underlying storage array. */
uint8_t* End; /**< Pointer to the end of the buffer's underlying storage array. */
uint8_t  Size; /**< Size of the buffer's underlying storage array. */
uint16_t Count; /**< Number of bytes currently stored in the buffer. */
} RingBuffer_t;

/* Inline Functions: */
/** Initializes 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.
*
*  \param[out] Buffer   Pointer to a ring buffer structure to initialize.
*  \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)
{
GCC_FORCE_POINTER_ACCESS(Buffer);

cli();

Buffer->In     = DataPtr;
Buffer->Out    = DataPtr;
Buffer->Start  = &DataPtr[0];
Buffer->End    = &DataPtr[Size];
Buffer->Size   = Size;
Buffer->Count  = 0;

sei();
}

/** 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.
*
*  \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
*        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.
*/
static inline uint16_t RingBuffer_GetCount(RingBuffer_t* const Buffer)
{
uint16_t Count;

cli();

Count = Buffer->Count;

sei();
return Count;
}

/** 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 \c true if the buffer contains no free space, false otherwise.
*/
static inline bool RingBuffer_IsFull(RingBuffer_t* const Buffer)
{
return (RingBuffer_GetCount(Buffer) == Buffer->Size);
}

/** Atomically determines if the specified ring buffer contains any data. This should
*  be tested before removing data from the buffer, to ensure that the buffer does not
*  underflow.
*
*  If the data is to be removed in a loop, store the total number of bytes stored in the
*  buffer (via a call to the \ref RingBuffer_GetCount() function) in a temporary variable
*  to reduce the time spent in atomicity locks.
*
*  \param[in,out] Buffer  Pointer to a ring buffer structure to insert into.
*
*  \return Boolean \c true if the buffer contains no free space, false otherwise.
*/
static inline bool RingBuffer_IsEmpty(RingBuffer_t* const Buffer)
{
return (RingBuffer_GetCount(Buffer) == 0);
}

/** Inserts an element into the ring buffer.
*
*  \note Only one execution thread (main program thread or an ISR) may insert into a single buffer
*        otherwise data corruption may occur. Insertion and removal may occur from different execution
*
*  \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(RingBuffer_t* Buffer, const uint8_t Data)
{
GCC_FORCE_POINTER_ACCESS(Buffer);

*Buffer->In = Data;

if (++Buffer->In == Buffer->End)
Buffer->In = Buffer->Start;

cli();

Buffer->Count++;

sei();
}

/** Removes an element from the ring buffer.
*
*  \note Only one execution thread (main program thread or an ISR) may remove from a single buffer
*        otherwise data corruption may occur. Insertion and removal may occur from different execution
*
*  \param[in,out] Buffer  Pointer to a ring buffer structure to retrieve from.
*
*  \return Next data element stored in the buffer.
*/
static inline uint8_t RingBuffer_Remove(RingBuffer_t* Buffer)
{
GCC_FORCE_POINTER_ACCESS(Buffer);

uint8_t Data = *Buffer->Out;

if (++Buffer->Out == Buffer->End)
Buffer->Out = Buffer->Start;

cli();

Buffer->Count--;

sei();

return Data;
}

/** Returns the next element stored in the ring buffer, without removing it.
*
*  \param[in,out] Buffer  Pointer to a ring buffer structure to retrieve from.
*
*  \return Next data element stored in the buffer.
*/
static inline uint8_t RingBuffer_Peek(RingBuffer_t* const Buffer)
{
return *Buffer->Out;
}

#endif

/** @} */


The second issue is using it.

// Declare ring buffer for incomming serial data
RingBuffer_t	Buffer;
uint8_t		BufferData[128];

// Initialise the buffer with the created storage array
RingBuffer_InitBuffer(&Buffer, BufferData, sizeof(BufferData));
RingBuffer_Insert(Buffer, 'H');
error: incompatible type for argument 1 of 'RingBuffer_Insert'

../RingBuffer.h:213: note: expected 'struct RingBuffer_t *' but argument is of type 'RingBuffer_t'



Chief Tinkerer

Last Edited: Mon. Feb 27, 2012 - 02:18 AM

My guess is that it does not know what "bool" is. Try including stdbool.h.

Regards,
Steve A.

The Board helps those that help themselves.

Koshchi wrote:
My guess is that it does not know what "bool" is. Try including stdbool.h.

oh snap that was it. I would have NEVER figured that out from that error message. I expected bool to be a default type, but I guess that was introduced in c++ IIRC.

Any ideas with the other error?

Chief Tinkerer

Quote:
Any ideas with the other error?

The error message is quite descriptive. Change

   RingBuffer_Insert(Buffer, 'H');


to

   RingBuffer_Insert(&Buffer, 'H');


- S

mnehpets wrote:
Quote:
Any ideas with the other error?

The error message is quite descriptive. Change

   RingBuffer_Insert(Buffer, 'H');


to

   RingBuffer_Insert(&Buffer, 'H');


- S

Ah ok, forgive me as I am trying to slowly learn pointers. It's been a while since I've worked with them last, but I know how important they are. As I understand, the '&' sends the pointer address to the function instead. That makes sense now. Thanks

Chris

Chief Tinkerer

Quote:

I would have NEVER figured that out from that error message.

Note for the future. Whenever you see the:

expected '=', ',', ';', 'asm' or '__attribute__' before

message 99.9% of the time it is saying "I don't know this type".

Quote:
As I understand, the '&' sends the pointer address to the function instead.

It could just be semantics but I read your description as the "address of the address" (you said "pointer address" where pointer is already a holder of an address). If that's what you think you are wrong. The & simply arranges to pass the address of the 'Buffer' struct rather than the struct itself. (not the address of the address of the struct),

clawson wrote:
Quote:

I would have NEVER figured that out from that error message.

Note for the future. Whenever you see the:

expected '=', ',', ';', 'asm' or '__attribute__' before

message 99.9% of the time it is saying "I don't know this type".

Quote:
As I understand, the '&' sends the pointer address to the function instead.

It could just be semantics but I read your description as the "address of the address" (you said "pointer address" where pointer is already a holder of an address). If that's what you think you are wrong. The & simply arranges to pass the address of the 'Buffer' struct rather than the struct itself. (not the address of the address of the struct),

Duly noted. I'm all for being corrected when what I say isn't quite right. Thanks for the clarification.

Chief Tinkerer

Let me give you a brief warning to keep you from getting a third problem...

A few years ago I wrote a very similar ringbuffer.
Same synchronisation using cli() / sei().
But every 100.000th or so entry was faulty.
I REALLY went out of my way to find the error but could not solve it.
Some day while lurking through AVRFreaks I read a post that warned from using this method, instead use the
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) macro from .

Tried it and I tell you ... the problems disappeared!!

I really don't know exactly what the reason was, seems that the compiler rearranges the cli()/sei() sometimes..
If someone is in the know, please share some insight!

regards
Luigi

P.S. I dont't know who gave me this hint (can't find the post anymore), but I owe him a beer or two!

luigirossi wrote:
I really don't know exactly what the reason was, seems that the compiler rearranges the cli()/sei() sometimes...
Older versions of the sei/cli macros from AVR-Libc did not implement a memory barrier.

According to NEWS, the change was for AVR-Libc 1.7.0 and went upstream 2010-06-08:

http://svn.savannah.nongnu.org/v...

WinAVR-20100110 contains AVR-Libc 1.6.7 stamped 2009-07-02.

The "volatile" in "asm volatile" avoids that the asm is not optimized away if it has no side effects that have an effect on the program.

The "volatile" does not prohibit reordering. In order to avoid reordering of a inline asm, the dependencies with the surrounding code must be correct. If there are no dependencies, reordering is all right, of course. The memory clobber establishes a dependency between the asm and memory accesses.

avrfreaks does not support Opera. Profile inactive.