A C++ template library for embedded applications
Designed and maintained by
Aster Consulting Ltd

queue_spsc_isr

A fixed capacity single-producer, single-consumer queue for interrupt driven systems.
The queue may be used to transfer data to or from an ISR. Calls to the queue from the ISR must use the _from_isr
versions.

A helper class must be supplied that defines static void lock() and void unlock() functions. They must perform the
requisite memory barriers to preserve the order of execution.

etl::queue_spsc_isr<typename T,
                    const size_t SIZE,
                    typename TAccess,
                    const size_t MEMORY_MODEL = etl::memory_model::MEMORY_MODEL_LARGE>

Inherits from etl::iqueue_spsc_isr<T, TAccess>
etl::iqueue_spsc_isr may be used as a size independent pointer or reference type for any etl::queue_spsc_isr
instance of the same implementation.

The memory model determines the type used internally for indexes and size, to allow for the most efficient
implementation for the application.

Maximum queue sizes:
MEMORY_MODEL_SMALL   255
MEMORY_MODEL_MEDIUM  65535
MEMORY_MODEL_LARGE   2147483647
MEMORY_MODEL_HUGE    9223372036854775807

See memory_model.h

Member types

value_type      T
size_type       <based on memory model>
pointer         value_type*
const_pointer   const value_type*
reference       value_type&
const_reference const value_type&

Constructor

queue_spsc_isr();

Capacity

bool empty() const
bool empty_from_isr() const
Returns true if the size of the queue is zero, otherwise false.

bool full() const
bool full_from_isr() const
Returns true if the size of the queue is SIZE, otherwise false.

size_type size() const
size_type size_from_isr() const
Returns the size of the queue.

size_type available() const
size_type available_from_isr() const
Returns the remaining available capacity in the queue.

size_type max_size() const
Returns the maximum possible size of the queue.

size_type capacity() const
Returns the maximum possible size of the queue.

Modifiers

bool push(parameter_t value);
bool push_from_isr(parameter_t value);
Pushes a value to the back of the queue.
Returns true if successful, otherwise false.

bool pop();
bool pop_from_isr();
Pop a value from the front of the list.
Returns true if successful, otherwise false.

void pop(T& value);
void pop_from_isr(T& value);
Pop a value from the front of the list and place it in value.
Returns true if successful, otherwise false.

void clear();
void clear_from_isr();
Clears the queue to a size of zero.

Notes

Remember that interrupts may occur between calls to the access protected functions. For example, a call to empty() may
return true, but a subsequent call to pop() may succeed if an interrupt occurred between the two and pushed a new
value.

Example


class InterruptControl
{
public:

  static void lock()
  {
    // Store current interrupt control register and disable the relevant interrupt.
  }

  static void unlock()
  {
    // Restore the interrupt control register.
  }
};

etl::queue_spsc_isr<char, 10, InterruptControl> queue;

int main()
{
  while (true)
  {
    char c;

    if (queue.pop(c))
    {
      Print(c);
    }
  }
}

void ISR(char c)
{
  queue.push_from_isr(c);
}
queue_spsc_isr.h