radio/src/fifo.h

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #ifndef _FIFO_H_
  22 #define _FIFO_H_
  23
  24 #include <inttypes.h>
  25
  26 template <class T, int N>
  27 class Fifo
  28 {
  29   static_assert((N > 1) & !(N & (N - 1)), "Fifo size must be a power of two!");
  30
  31   public:
  32     Fifo():
  33       widx(0),
  34       ridx(0)
  35     {
  36     }
  37
  38     void clear()
  39     {
  40       widx = ridx = 0;
  41     }
  42
  43     void push(T element)
  44     {
  45       uint32_t next = nextIndex(widx);
  46       if (next != ridx) {
  47         fifo[widx] = element;
  48         widx = next;
  49       }
  50     }
  51
  52     void skip()
  53     {
  54       ridx = nextIndex(ridx);
  55     }
  56
  57     bool pop(T & element)
  58     {
  59       if (isEmpty()) {
  60         return false;
  61       }
  62       else {
  63         element = fifo[ridx];
  64         ridx = nextIndex(ridx);
  65         return true;
  66       }
  67     }
  68
  69     bool isEmpty() const
  70     {
  71       return (ridx == widx);
  72     }
  73
  74     bool isFull()
  75     {
  76       uint32_t next = nextIndex(widx);
  77       return (next == ridx);
  78     }
  79
  80     uint32_t size() const
  81     {
  82       return (N + widx - ridx) & (N - 1);
  83     }
  84
  85     uint32_t hasSpace(uint32_t n) const
  86     {
  87       return (N > (size() + n));
  88     }
  89
  90     bool probe(T & element) const
  91     {
  92       if (isEmpty()) {
  93         return false;
  94       }
  95       else {
  96         element = fifo[ridx];
  97         return true;
  98       }
  99     }
 100
 101   protected:
 102     T fifo[N];
 103     volatile uint32_t widx;
 104     volatile uint32_t ridx;
 105
 106     inline uint32_t nextIndex(uint32_t idx)
 107     {
 108       return (idx + 1) & (N - 1);
 109     }
 110 };
 111
 112 #endif // _FIFO_H_