ring_buffer.h

Go to the documentation of this file.

/******************************************************************************
 * The MIT License
 *
 * Copyright (c) 2011 LeafLabs, LLC.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *****************************************************************************/

#ifndef _RING_BUFFER_H_
#define _RING_BUFFER_H_

#include "hal_types.h"

typedef struct ring_buffer {
    volatile uint8_t *buf; 
    uint16_t head;         
    uint16_t tail;         
    uint16_t size;         
} ring_buffer;


#ifdef __cplusplus
  extern "C" {
#endif

static inline void rb_init(ring_buffer *rb, uint16_t size, uint8_t *buf) {
    rb->head = 0;
    rb->tail = 0;
    rb->size = size - 1;
    rb->buf = buf;
}

static inline uint16_t rb_full_count(ring_buffer *rb) {
    uint16_t t=rb->tail;
    uint16_t h=rb->head;
    
    int32_t size = t - h;
    if (t < h) {
        size += rb->size + 1;
    }
    return (uint16_t)size;
}

static inline int rb_is_full(ring_buffer *rb) {
    uint16_t t=rb->tail;
    uint16_t h=rb->head;
    return (t + 1 == h || (t == rb->size && h == 0) );
}

static inline int rb_is_empty(ring_buffer *rb) {
    return rb->head == rb->tail;
}

static inline void rb_insert(ring_buffer *rb, uint8_t element) {
    uint16_t t=rb->tail;
    rb->buf[t] = element;
    rb->tail = (t == rb->size) ? 0 : t + 1;
}

static inline uint8_t rb_remove(ring_buffer *rb) {
    uint16_t h=rb->head;
    uint8_t ch = rb->buf[h];
    rb->head = (h == rb->size) ? 0 : h + 1;
    return ch;
}

static inline int16_t rb_safe_remove(ring_buffer *rb) {
    return rb_is_empty(rb) ? -1 : rb_remove(rb);
}

static inline int rb_safe_insert(ring_buffer *rb, uint8_t element) {
    if (rb_is_full(rb)) {
        return 0;
    }
    rb_insert(rb, element);
    return 1;
}

static inline int rb_push_insert(ring_buffer *rb, uint8_t element) {
    int ret = -1;
    if (rb_is_full(rb)) {
        ret = rb_remove(rb);
    }
    rb_insert(rb, element);
    return ret;
}

static inline void rb_reset(ring_buffer *rb) {
    rb->tail = rb->head;
}

#ifdef __cplusplus
  }
#endif

#endif