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>

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.

Member types

value_type      T
size_type       std::size_t
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_t size() const
size_t size_from_isr() const
Returns the size of the queue.

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

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

size_t 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