Fixed compiler errors and added readme

Author: wizard97

README.md

@@ -0,0 +1,104 @@
+# ArduinoRingBuffer
+
+This is a simple ring (FIFO) buffer queuing library for embedded platforms, such as Arduino's. This library is based on a previous one I wrote, only now in C++ instead of C. It uses C++'s templating, so weird no more weird pointer casting, and deep copies of objects are supported. It has concurrency protection built in, so feel free to do operations
+on the buffer inside of ISR's. All memory is statically allocated at compile time, so no heap memory is used. It can buffer any fixed size object (ints, floats, structs, objects, etc...).
+
+## FAQ's
+ <dl>
+ <dt>I only have a C compiler for my platform</dt>
+   <dd>No worries, try the vanilla C version of the library.</dd>
+ </dl>
+
+
+## Use Cases
+
+A ring buffer is used when passing asynchronous io between two threads. In the case of the Arduino, it is very useful for buffering data in an interrupt routine that is later processed in your `void loop()`.
+
+## Supported Platforms
+The library currently supports:
+- AVR
+- ESP8266
+- Any other platform (just implement the `RB_ATOMIC_START` and `RB_ATOMIC_END` macros)
+
+## Install
+
+This library is now available in the Arduino Library Manager, directly in the IDE. Go to `Sketch > Include Library > Manage Libraries` and search for `RingBuf`.
+
+To manually install this library, download this file as a zip, and extract the resulting folder into your Arduino Libraries folder. [Installing an Arduino Library] (https://www.arduino.cc/en/Guide/Libraries).
+
+## Examples
+
+Look at the examples folder for several examples.
+
+## Contributing
+
+If you find this Arduino library helpful, click the Star button, and you will make my day.
+
+Feel free to improve this library. Fork it, make your changes, then submit a pull request!
+
+## API
+
+
+### Constructor
+
+```c++
+RingBuf<typename Type, uint16_t MaxElements>();
+```
+
+Creates a new RingBuf object that can buffer up to MaxElements of type Type.
+
+
+## Methods
+
+
+### add()
+
+```c++
+bool add(Type &obj);
+```
+
+Append an element to the buffer. Return true on success, false on a full buffer.
+
+### peek()
+
+```c++
+Type *peek(uint16_t num);
+```
+
+Peek at the num'th element in the buffer. Returns a pointer to the location of the num'th element. If num is out of bounds or the num'th element is empty, a NULL pointer is returned. Note that this gives you direct memory access to the location of the num'th element in the buffer, allowing you to directly edit elements in the buffer. Note that while all of RingBuf's public methods are atomic (including this one), directly using the pointer returned from this method is not safe. If there is a possibility an interrupt could fire and remove/modify the item pointed to by the returned pointer, disable interrupts first with `noInterrupts()`, do whatever you need to do with the pointer, then you can reenable interrupts by calling `interrupts()`.
+
+### pull()
+
+```c++
+bool pull(Type *dest);
+```
+
+Pull the first element out of the buffer. The first element is copied into the location pointed to by dest. Returns false if the buffer is empty, otherwise returns true on success.
+
+
+### numElements()
+```c++
+uint16_t numElements();
+```
+
+Returns number of elements in the buffer.
+
+### isFull()
+```c++
+bool isFull();
+```
+
+Returns true if buffer is full, otherwise false.
+
+
+### isEmpty()
+
+```c++
+bool isEmpty();
+```
+
+Returns true if buffer is empty, false otherwise.
+
+## License
+
+This library is open-source, and licensed under the [MIT license](http://opensource.org/licenses/MIT). Do whatever you like with it, but contributions are appreciated.

RingBuf.cpp

@@ -1,70 +1,107 @@
-#include "RingBuf.h"
+//#include "RingBuf.h"
 
 template <typename Type, uint16_t MaxElements>
 RingBuf<Type, MaxElements>::RingBuf()
-: _buf{ 0 }
+//: _buf{ 0 }
 {
-    _numElements = 0;
+     RB_ATOMIC_START
+     {
+         _numElements = 0;
 
-    _head = 0;
+         _head = 0;
+     }
+     RB_ATOMIC_END
 }
 
 template <typename Type, uint16_t MaxElements>
 bool RingBuf<Type, MaxElements>::add(Type &obj)
 {
-    if (isFull())
-        return false;
+    RB_ATOMIC_START
+    {
+        if (isFull())
+            return false;
 
-    _buf[_head] = obj;
-    _head = (_head + 1)%MaxElements;
-    numElements++;
-    return true;
+        _buf[_head] = obj;
+        _head = (_head + 1)%MaxElements;
+        _numElements++;
+        return true;
+    }
+    RB_ATOMIC_END
 }
 
 template <typename Type, uint16_t MaxElements>
 bool RingBuf<Type, MaxElements>::pull(Type *dest)
 {
-    uint16_t tail;
+    RB_ATOMIC_START
+    {
+        uint16_t tail;
 
-    if (isEmpty())
-        return false;
+        if (isEmpty())
+            return false;
 
-    tail = getTail();
+        tail = getTail();
 
-    *dest = _buf[tail];
-    numElements--;
-    return true;
+        *dest = _buf[tail];
+        _numElements--;
+        return true;
+    }
+    RB_ATOMIC_END
 }
 
 template <typename Type, uint16_t MaxElements>
 bool RingBuf<Type, MaxElements>::isFull()
 {
-    return numElements >= MaxElements;
+    RB_ATOMIC_START
+    {
+        return _numElements >= MaxElements;
+    }
+    RB_ATOMIC_END
 }
 
 template <typename Type, uint16_t MaxElements>
 uint16_t RingBuf<Type, MaxElements>::numElements()
 {
-    return numElements;
+    RB_ATOMIC_START
+    {
+        return _numElements;
+    }
+    RB_ATOMIC_END
 }
 
 template <typename Type, uint16_t MaxElements>
 bool RingBuf<Type, MaxElements>::isEmpty()
 {
-    return !numElements;
+    RB_ATOMIC_START
+    {
+        return !_numElements;
+    }
+    RB_ATOMIC_END
 }
 
 template <typename Type, uint16_t MaxElements>
 Type *RingBuf<Type, MaxElements>::peek(uint16_t num)
 {
-    if (num >= numElements)
-        return NULL;
+    RB_ATOMIC_START
+    {
+        if (num >= _numElements)
+            return NULL;
 
-    return &_buf[(getTail() + num)%MaxElements];
+        return &_buf[(getTail() + num)%MaxElements];
+    }
+    RB_ATOMIC_END 
 }
 
+// ONLY CALL WHEN SAFE
 template <typename Type, uint16_t MaxElements>
 uint16_t RingBuf<Type, MaxElements>::getTail()
 {
     return (_head + (MaxElements - _numElements))%MaxElements;
 }
+/*
+void TemporaryFunction()
+{
+    RingBuf<bool, 1> TempObj;
+    bool b = true;
+    TempObj.add(b);
+}
+*/

RingBuf.h

@@ -1,5 +1,8 @@
-#ifndef RINGBUG_FIFO_H
-#define RINGBUF_FIFO_H
+#ifndef EM_RINGBUF_FIFO_CPP_H
+#define EM_RINGBUF_FIFO_CPP_H
+
+// TODO fix this
+#define NULL (void *)(0)
 
 #ifdef ARDUINO
     #include <Arduino.h>
@@ -46,7 +49,6 @@
 #endif
 
 template <typename Type, uint16_t MaxElements>
-
 class RingBuf
 {
 public:
@@ -101,4 +103,6 @@ uint16_t _numElements;
 private:
 
 };
+
+#include "RingBuf.cpp"
 #endif

a.out

@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include "RingBuf.h"
+#include <stdint.h>
+#include <stdlib.h>
+
+int main()
+{
+    RingBuf<int, 5> q;
+    int tmp = 12;
+    //q.add(tmp);
+
+    for (uint16_t i=0; i< 100; i++) {
+        int tmp = random();
+
+        if (q.add(tmp)) {
+            printf("Added %d\n", tmp);
+        }
+        else {
+            q.pull(&tmp);
+            break;
+        }
+    }
+
+    while(!q.isEmpty()) {
+        int pulled;
+        q.pull(&pulled);
+        printf("Got %d\n", pulled);
+    }
+}