src/lib/FIFO/FIFO.cpp

   1 /*
   2  * FIFO Buffer
   3  * Implementation uses arrays to conserve memory
   4  *
   5  * The MIT License (MIT)
   6  *
   7  * Copyright (c) 2015 Daniel Eisterhold
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in all
  17  * copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  *
  27  *
  28  * Modified/Ammended by Alessandro Carcione 2020
  29  */
  30 #include "FIFO.h"
  31 #include "logging.h"
  32
  33 FIFO::FIFO()
  34 {
  35     head = 0;
  36     tail = 0;
  37     numElements = 0;
  38 }
  39
  40 FIFO::~FIFO()
  41 {
  42 }
  43
  44 void ICACHE_RAM_ATTR FIFO::push(const uint8_t data)
  45 {
  46     if (numElements == FIFO_SIZE)
  47     {
  48         ERRLN("Buffer full, will flush");
  49         flush();
  50         return;
  51     }
  52     else
  53     {
  54         numElements++;
  55         buffer[tail] = data;
  56         tail = (tail + 1) % FIFO_SIZE;
  57     }
  58 }
  59
  60 void ICACHE_RAM_ATTR FIFO::pushBytes(const uint8_t *data, uint8_t len)
  61 {
  62     if (numElements + len > FIFO_SIZE)
  63     {
  64         ERRLN("Buffer full, will flush");
  65         flush();
  66         return;
  67     }
  68     for (int i = 0; i < len; i++)
  69     {
  70         buffer[tail] = data[i];
  71         tail = (tail + 1) % FIFO_SIZE;
  72     }
  73     numElements += len;
  74 }
  75
  76 uint8_t ICACHE_RAM_ATTR FIFO::pop()
  77 {
  78     if (numElements == 0)
  79     {
  80         // DBGLN(F("Buffer empty"));
  81         return 0;
  82     }
  83     else
  84     {
  85         numElements--;
  86         uint8_t data = buffer[head];
  87         head = (head + 1) % FIFO_SIZE;
  88         return data;
  89     }
  90 }
  91
  92 void ICACHE_RAM_ATTR FIFO::popBytes(uint8_t *data, uint8_t len)
  93 {
  94     if (numElements < len)
  95     {
  96         // DBGLN(F("Buffer underrun"));
  97         flush();
  98     }
  99     else
 100     {
 101         numElements -= len;
 102         for (int i = 0; i < len; i++)
 103         {
 104             data[i] = buffer[head];
 105             head = (head + 1) % FIFO_SIZE;
 106         }
 107     }
 108 }
 109
 110 uint8_t ICACHE_RAM_ATTR FIFO::peek()
 111 {
 112     if (numElements == 0)
 113     {
 114         // DBGLN(F("Buffer empty"));
 115         return 0;
 116     }
 117     else
 118     {
 119         uint8_t data = buffer[head];
 120         return data;
 121     }
 122 }
 123
 124 uint16_t ICACHE_RAM_ATTR FIFO::size()
 125 {
 126     return numElements;
 127 }
 128
 129 void ICACHE_RAM_ATTR FIFO::flush()
 130 {
 131     head = 0;
 132     tail = 0;
 133     numElements = 0;
 134 }
 135
 136 bool ICACHE_RAM_ATTR FIFO::ensure(uint8_t requiredSize)
 137 {
 138     if(requiredSize > FIFO_SIZE)
 139         return false;
 140     while(!available(requiredSize)) {
 141         uint8_t len = pop();
 142         head = (head + len) % FIFO_SIZE;
 143         numElements -= len;
 144     }
 145     return true;
 146 }