Classe CircularBuffer

###### Home << Bibliotecas para Arduino <

Esta é uma classe com pouco código que implementa um *buffer* circular. É possível adicionar items e depois recuperá-los na sequência em que foram armazenados (fila) ou na sequência inversa (pilha). Estes items podem ser estruturas, strings, arrays ou qualquer tipo de dados. Abaixo sua declaração pública:

* Arquivo: pCircBuff.h
* Dependencias: pGlobals.h
* SourceForge wiki (in english):  CircularBuffer Class

**Declarações públicas:**

```
 class CircularBuffer{
 public:
     CircularBuffer();
     ~CircularBuffer();

     boolean begin(byte items, byte itemSize);
     boolean addItem(void* item);
     void clear();
     byte itemsCount();

     void* getFirst(void* item);
     void* getLast(void* item);
     byte* checkFirst();
     byte* checkLast();
 };

```

O uso é bem simples, depois de criar uma instância, inicialize a classe chamando o método ***begin()*** para informar a quantidade máxima de itens que serão armazenados e o tamanho de cada item. Se for usar o buffer como fila, use o método ***getFirst()*** para recuperar o primeiro item do *buffer*. Se for usar como pilha, chame o método ***getLast()*** para obter o último item adicionado. Estes métodos fazem com que "a fila ande". Da próxima ver que forem chamados é o próximo item que será retornado. O método ***clear()*** limpa o *buffer*. Use o método ***itemsCount()*** para saber quantos itens restam na fila. Os métodos ***checkFirst()*** e ***getLast()*** retornam uma referencia para o primeiro e último item respectivamente, mas não fazem nenhuma alteração no buffer.

Veja um exemplo de uso no final da página.

### **boolean begin(byte items, byte itemSize)**

Alloc memory to buffer. Call before any other method.

* **items**: Maximum amount of items to be stored.
* **itemSize**: Size in bytes of each item.
* **return**:
	+ **true**: No errors;
	+ **false**: Insufficient memory.

### **boolean addItem(void\* item)**

Add item at the end of buffer.

* **item**: reference to item. Item will be copied to buffer.
* **return**:
	+ **true** if item was added;
	+ **false** if buffer is full.

### **byte \* getFirst (byte \* item)**

Remove and return the first item.

* **item**: reference to destination memory block to contain an item. The item will be copied to it.
* **return**: reference to destination block

### **byte \* getLast (byte \* item)**

Remove and return the last item.

* **item**: reference to destination memory block to contain an item. The item will be copied to it.
* **return**: reference to destination block

### **byte itemsCount()**

Return current amount of items in buffer. The counter is increased by ***addItem()*** and decreased by ***getFirst()*** and ***getLast()***.

* **return**: current amount of items in buffer.

### **byte\* checkFirst()**

Return a reference to first item added. This method dont modify the buffer.

* **return**: reference to first item added.

### **byte\* checkLast()**

Return a reference to last item added. This method dont modify the buffer.

* **return**: reference to last item added.

### **Exemplo de uso**

```
#include <circBuff.h>

CircularBuffer cbuf;

// Estrutura que será usada no buffer.
typedef struct{
  int number;
  char str[8];
} MyStruct;

// Enche o buffer
void addItems()
{
  MyStruct ms;

  for(int i=0; i<10; i++)
  {
    switch (i){
      case 0: strcpy(ms.str, "Uno");     break;
      case 1: strcpy(ms.str, "Bi");      break;
      case 2: strcpy(ms.str, "Tri");     break;
      case 3: strcpy(ms.str, "Tetra");   break;
      case 4: strcpy(ms.str, "Penta");   break;
      case 5: strcpy(ms.str, "Hexa");    break;
      case 6: strcpy(ms.str, "Hepta");   break;
      case 7: strcpy(ms.str, "Octopus"); break;
      case 8: strcpy(ms.str, "Nueve");   break;
      case 9: strcpy(ms.str, "Decup");   break;
    }
    ms.number= i+1;
    cbuf.addItem((byte*)&ms);
  }
}

// Imprime o item recuperado
void printStruct(MyStruct* ms)
{
  Serial.print(ms->number);
  Serial.print(": ");
  Serial.println(ms->str);
}

void setup()
{
  Serial.begin(57600);
  cbuf.begin(10, sizeof(MyStruct));
}

#define lapse 333
ulong next= 0;

void loop()
{
  // Se o buffer está vazio, enche o buffer
  if(cbuf.itemsCount()==0)
  {
    addItems();
    Serial.println();
  }

  if(next <= millis())
  {
    MyStruct ms;

    // Recupera o próximo item e já manda pra impressão
    printStruct((MyStruct*)cbuf.getFirst((byte*)&ms));

    next= millis()+lapse;
  }
}

```