fixed USB

F1:F103/BISS_C_encoders/ringbuffer.c

@@ -15,9 +15,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <string.h> // memcpy
+#include <string.h>
+
 #include "ringbuffer.h"
 
+#define CHK(b)  do{if(!b) return -1;}while(0)
+
 static int datalen(ringbuffer *b){
     if(b->tail >= b->head) return (b->tail - b->head);
     else return (b->length - b->head + b->tail);
@@ -25,6 +28,8 @@ static int datalen(ringbuffer *b){
 
 // stored data length
 int RB_datalen(ringbuffer *b){
+    CHK(b);
+    if(0 == datalen(b)) return 0; // don't block for empty RO operations
     if(b->busy) return -1;
     b->busy = 1;
     int l = datalen(b);
@@ -52,17 +57,13 @@ static int hasbyte(ringbuffer *b, uint8_t byte){
  * @return index if found, -1 if none or busy
  */
 int RB_hasbyte(ringbuffer *b, uint8_t byte){
+    CHK(b);
     if(b->busy) return -1;
     b->busy = 1;
     int ret = hasbyte(b, byte);
     b->busy = 0;
     return ret;
 }
-/*
-// poor memcpy
-static void mcpy(uint8_t *targ, const uint8_t *src, int l){
-    while(l--) *targ++ = *src++;
-}*/
 
 // increment head or tail
 TRUE_INLINE void incr(ringbuffer *b, volatile int *what, int n){
@@ -77,10 +78,8 @@ static int read(ringbuffer *b, uint8_t *s, int len){
     int _1st = b->length - b->head;
     if(_1st > l) _1st = l;
     if(_1st > len) _1st = len;
-    //mcpy(s, b->data + b->head, _1st);
     memcpy(s, b->data + b->head, _1st);
     if(_1st < len && l > _1st){
-        //mcpy(s+_1st, b->data, l - _1st);
         memcpy(s+_1st, b->data, l - _1st);
         incr(b, &b->head, l);
         return l;
@@ -97,6 +96,9 @@ static int read(ringbuffer *b, uint8_t *s, int len){
  * @return bytes read or -1 if busy
  */
 int RB_read(ringbuffer *b, uint8_t *s, int len){
+    CHK(b);
+    if(!s || len < 1) return -1;
+    if(0 == datalen(b)) return 0;
     if(b->busy) return -1;
     b->busy = 1;
     int r = read(b, s, len);
@@ -104,13 +106,20 @@ int RB_read(ringbuffer *b, uint8_t *s, int len){
     return r;
 }
 
-static int readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
+// length of data from current position to `byte` (including byte)
+static int lento(ringbuffer *b, uint8_t byte){
     int idx = hasbyte(b, byte);
     if(idx < 0) return 0;
     int partlen = idx + 1 - b->head;
     // now calculate length of new data portion
     if(idx < b->head) partlen += b->length;
-    if(partlen > len) return -read(b, s, len);
+    return partlen;
+}
+
+static int readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
+    int partlen = lento(b, byte);
+    if(!partlen) return 0;
+    if(partlen > len) return -1;
     return read(b, s, partlen);
 }
 
@@ -118,27 +127,45 @@ static int readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
  * @brief RB_readto fill array `s` with data until byte `byte` (with it)
  * @param b - ringbuffer
  * @param byte - check byte
- * @param s - buffer to write data
- * @param len - length of `s`
+ * @param s - buffer to write data or NULL to clear data
+ * @param len - length of `s` or 0 to clear data
  * @return amount of bytes written (negative, if len<data in buffer or buffer is busy)
  */
 int RB_readto(ringbuffer *b, uint8_t byte, uint8_t *s, int len){
+    CHK(b);
+    if(!s || len < 1) return -1;
+    if(0 == datalen(b)) return 0;
     if(b->busy) return -1;
     b->busy = 1;
-    int n = readto(b, byte, s, len);
+    int n = 0;
+    if(s && len > 0){
+        n = readto(b, byte, s, len);
+    }else{
+        incr(b, &b->head, lento(b, byte)); // just throw data out
+    }
     b->busy = 0;
     return n;
 }
 
+int RB_datalento(ringbuffer *b, uint8_t byte){
+    CHK(b);
+    if(0 == datalen(b)) return 0;
+    if(b->busy) return -1;
+    b->busy = 1;
+    int n = lento(b, byte);
+    b->busy = 0;
+    return n;
+}
+
+// if l < rest of buffer, truncate and return actually written bytes
 static int write(ringbuffer *b, const uint8_t *str, int l){
     int r = b->length - 1 - datalen(b); // rest length
-    if(l > r || !l) return 0;
+    if(r < 1) return 0;
+    if(l > r) l = r;
     int _1st = b->length - b->tail;
     if(_1st > l) _1st = l;
-    //mcpy(b->data + b->tail, str, _1st);
     memcpy(b->data + b->tail, str, _1st);
     if(_1st < l){ // add another piece from start
-        //mcpy(b->data, str+_1st, l-_1st);
         memcpy(b->data, str+_1st, l-_1st);
     }
     incr(b, &b->tail, l);
@@ -153,6 +180,9 @@ static int write(ringbuffer *b, const uint8_t *str, int l){
  * @return amount of bytes written or -1 if busy
  */
 int RB_write(ringbuffer *b, const uint8_t *str, int l){
+    CHK(b);
+    if(!str || l < 1) return -1;
+    if(b->length - datalen(b) < 2) return 0;
     if(b->busy) return -1;
     b->busy = 1;
     int w = write(b, str, l);
@@ -162,10 +192,12 @@ int RB_write(ringbuffer *b, const uint8_t *str, int l){
 
 // just delete all information in buffer `b`
 int RB_clearbuf(ringbuffer *b){
+    CHK(b);
     if(b->busy) return -1;
     b->busy = 1;
     b->head = 0;
     b->tail = 0;
+    bzero(b->data, b->length);
     b->busy = 0;
     return 1;
 }