ESP8266 support and compiler warnings

Author: wizard97

README.md

@@ -7,14 +7,7 @@ I needed a way to buffer sensor events for a group engineering IOT project that
 
 I decided to give object oriented programming a shot using only C (no C++) with this library, of course, it still compiles with C++ compilers such as in the Arduino IDE. Using C structs and function pointers, the library creates RingBuf objects that are complete with their own methods and attributes. Note that every method (except constructor), takes a `RingBuf *self` pointer. This is the equivalent of the `this` pointer in C++, but the C++ compiler automatically passes it behind the scenes. For this library, you must manually pass a the `RingBuf *self` pointer as the first argument.
 
-## FAQ's
-<dl>
-<dt>Can I buffer C++ objects?</dt>
-  <dd>The library only shallow copies objects into the buffer, it will not call the copy constructor. For many C++ objects this works fine, but if you require a deep copy you will have to look into libraries that supports something like C++ templates. And to be honest, you shouldn't be doing deep copies on a microcontroller or you could get random freezes from memory fragmentation.</dd>
-
-<dt>Does this library support non AVR platforms?</dt>
-  <dd>Currently no, see <a href="https://github.com/wizard97/ArduinoRingBuffer/issues/2">#2</a>. If someone knows of a portable replacement for the  `ATOMIC_BLOCK(ATOMIC_RESTORESTATE){}` macro please let me know.</dd>
-</dl>
+
 ## But I like C++'s object syntax...
 
 Fine. I reluctantly wrapped the C stuff in a C++ class called `RingBufC`. All the methods are the same, except you no longer have to pass the this/self pointer. You can use either.
@@ -29,7 +22,7 @@ buf->add(buf, &mystr);
 
 ```
 // If you want to use the C++ wrapper
-char *mystr = "I like C++";
+char *mystr = "C++ has pretty object.method() syntax";
 
 RingBufC = buf(sizeof(char*), 100);
 buf.add(&mystr);
@@ -93,7 +86,7 @@ Append an element to the buffer, where object is a pointer to object you wish to
 void *peek(RingBuf *self, unsigned int num);
 ```
 
-Peek at the num'th element in the buffer. Returns a void 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. Cast the result of this call into a pointer of whatever type you are storing in the buffer. 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 thread safe (including this one), directly using the pointer returned from this method is not thread 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()`.
+Peek at the num'th element in the buffer. Returns a void 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. Cast the result of this call into a pointer of whatever type you are storing in the buffer. 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 thread safe (including this one), directly using the pointer returned from this method is not thread safe. To use this returned pointer safely, disable interrupts first with `noInterrupts()`, do whatever you need to do with the pointer, then you can reenable interrupts by calling `interrupts()`.
 
 ### pull()
 

RingBuf.c

@@ -6,7 +6,6 @@
 */
 #include "RingBuf.h"
 #include <string.h>
-#include <util/atomic.h>
 
 /////// Constructor //////////
 RingBuf *RingBuf_new(int size, int len)
@@ -86,7 +85,7 @@ int RingBufAdd(RingBuf *self, const void *object)
 {
   int index;
   // Perform all atomic opertaions
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
+  RB_ATOMIC_START
   {
     index = self->next_end_index(self);
     //if not full
@@ -97,30 +96,33 @@ int RingBufAdd(RingBuf *self, const void *object)
       self->elements++;
     }
   }
+  RB_ATOMIC_END
 
   return index;
 }
 
 // Return pointer to num element, return null on empty or num out of bounds
 void *RingBufPeek(RingBuf *self, unsigned int num)
 {
-  void *ret;
+  void *ret = NULL;
   // Perform all atomic opertaions
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
+  RB_ATOMIC_START
   {
     //empty or out of bounds
     if (self->isEmpty(self) || num > self->elements - 1) ret = NULL;
     else ret = &self->buf[((self->start + num)%self->len)*self->size];
   }
+  RB_ATOMIC_END
+
   return ret;
 }
 
 // Returns and removes first buffer element
 void *RingBufPull(RingBuf *self, void *object)
 {
-  void *ret;
+  void *ret = NULL;
   // Perform all atomic opertaions
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
+  RB_ATOMIC_START
   {
     if (self->isEmpty(self)) ret = NULL;
     // Else copy Object
@@ -133,6 +135,7 @@ void *RingBufPull(RingBuf *self, void *object)
       ret = object;
     }
   }
+  RB_ATOMIC_END
 
   return ret;
 }
@@ -143,10 +146,11 @@ unsigned int RingBufNumElements(RingBuf *self)
   unsigned int elements;
 
   // Perform all atomic opertaions
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
+  RB_ATOMIC_START
   {
     elements = self->elements;
   }
+  RB_ATOMIC_END
 
   return elements;
 }
@@ -157,10 +161,11 @@ bool RingBufIsFull(RingBuf *self)
   bool ret;
 
   // Perform all atomic opertaions
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
+  RB_ATOMIC_START
   {
     ret = self->elements == self->len;
   }
+  RB_ATOMIC_END
 
   return ret;
 }
@@ -171,10 +176,11 @@ bool RingBufIsEmpty(RingBuf *self)
   bool ret;
 
   // Perform all atomic opertaions
-  ATOMIC_BLOCK(ATOMIC_RESTORESTATE)
+  RB_ATOMIC_START
   {
     ret = !self->elements;
   }
+  RB_ATOMIC_END
 
   return ret;
 }

RingBuf.h

@@ -15,6 +15,32 @@
 #endif
 #endif
 
+#if defined(ARDUINO_ARCH_AVR)
+    #include <util/atomic.h>
+    #define RB_ATOMIC_START ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
+    #define RB_ATOMIC_END }
+
+
+#elif defined(ARDUINO_ARCH_ESP8266)
+    #ifndef __STRINGIFY
+    #define __STRINGIFY(a) #a
+    #endif
+
+    #ifndef xt_rsil
+        #define xt_rsil(level) (__extension__({uint32_t state; __asm__ __volatile__("rsil %0," __STRINGIFY(level) : "=a" (state)); state;}))
+    #endif
+
+    #ifndef xt_wsr_ps
+        #define xt_wsr_ps(state)  __asm__ __volatile__("wsr %0,ps; isync" :: "a" (state) : "memory")
+    #endif
+
+    #define RB_ATOMIC_START do { uint32_t _savedIS = xt_rsil(1) ;
+    #define RB_ATOMIC_END xt_wsr_ps(_savedIS) ;} while(0);
+#else
+    #error “This library only supports AVR and ESP8266 Boards.”
+#endif
+
+
 typedef struct RingBuf RingBuf;
 
 typedef struct RingBuf

library.properties

@@ -1,9 +1,9 @@
 name=RingBuf
-version=1.3
+version=2.0
 author=D. Aaron Wisner (daw268@cornell.edu)
 maintainer=D. Aaron Wisner (daw268@cornell.edu)
 sentence=A library for buffering items into a ring (circular/FIFO) buffer
 paragraph=This library is perfect for capturing pin states, timestamps, etc.. during an ISR. Then in void loop(), the buffer can be asynchronously processed whenever your program has free time.
 category=Data Storage
 url=https://github.com/wizard97/ArduinoRingBuffer
-architectures=avr
+architectures=avr,esp8266