using circular buffer from penguin buffer until i implement ring buffer
parent
252037532b
commit
310e5a1a32
@ -0,0 +1,36 @@
|
||||
#include "p_serial_mgr.h"
|
||||
#include "PCircularBuffer.h"
|
||||
#define MAX_SERIAL_BUFFER_SIZE (256)
|
||||
static uint8_t buffer[MAX_SERIAL_BUFFER_SIZE];
|
||||
static p_cb_u8 serial_cb;
|
||||
|
||||
static UART_HandleTypeDef *_serial_huart_inst = NULL;
|
||||
static uint8_t serial_cb_rxc = '\0';
|
||||
|
||||
void UART1_RxCpltCallback(UART_HandleTypeDef *huart)
|
||||
{
|
||||
serial_cb.push(&serial_cb, serial_cb_rxc);
|
||||
// HAL_GPIO_WritePin(USART1_DE_GPIO_Port, USART1_DE_Pin, 1);
|
||||
// huart2_rxc = huart1_rxc;
|
||||
|
||||
// HAL_UART_Transmit(&huart2, &huart2_rxc, 1, 500);
|
||||
// HAL_UART_Receive_IT(&huart1, &huart1_rxc, 1);
|
||||
// HAL_GPIO_WritePin(USART1_DE_GPIO_Port, USART1_DE_Pin, 0);
|
||||
}
|
||||
void p_serial_mgr_init(UART_HandleTypeDef *huart)
|
||||
{
|
||||
_serial_huart_inst = huart;
|
||||
_serial_huart_inst->RxCpltCallback = UART1_RxCpltCallback;
|
||||
|
||||
memset(buffer, 0, MAX_SERIAL_BUFFER_SIZE);
|
||||
p_cb_u8_init(&serial_cb, buffer, MAX_SERIAL_BUFFER_SIZE);
|
||||
}
|
||||
|
||||
void p_serial_mgr_service(void)
|
||||
{
|
||||
}
|
||||
|
||||
void p_serial_mgr_start()
|
||||
{
|
||||
HAL_UART_Receive_IT(_serial_huart_inst, &serial_cb_rxc, 1);
|
||||
}
|
||||
@ -0,0 +1,9 @@
|
||||
#ifndef _P_SERIAL_MGR_H_
|
||||
#define _P_SERIAL_MGR_H_
|
||||
|
||||
#include "stm32l4xx_hal.h"
|
||||
void p_serial_mgr_init(UART_HandleTypeDef *huart);
|
||||
|
||||
void p_serial_mgr_service(void);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,448 @@
|
||||
#include <PCircularBuffer.h>
|
||||
|
||||
// Error handler used for debugging only
|
||||
#ifdef PB_CB_DEBUG
|
||||
#include <stdio.h>
|
||||
static void handle_status(const char *func, PB_CB_STATUS status_code)
|
||||
{
|
||||
if (status_code != PB_CB_GOOD)
|
||||
{
|
||||
printf("%s failed: error code: %d\r\n", func, status_code);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- uint8_t
|
||||
#if PB_CB_U8
|
||||
static PB_CB_STATUS p_cb_u8_push(p_cb_u8 *cbuffer, uint8_t value);
|
||||
static PB_CB_STATUS p_cb_u8_empty(p_cb_u8 *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- uint16_t
|
||||
#if PB_CB_U16
|
||||
static PB_CB_STATUS p_cb_u16_push(p_cb_double *cbuffer, uint16_t value);
|
||||
static PB_CB_STATUS p_cb_u16_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- uint32_t
|
||||
#if PB_CB_U32
|
||||
static PB_CB_STATUS p_cb_u32_push(p_cb_double *cbuffer, uint32_t value);
|
||||
static PB_CB_STATUS p_cb_u32_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- uint64_t
|
||||
#if PB_CB_U64
|
||||
static PB_CB_STATUS p_cb_u64_push(p_cb_double *cbuffer, uint64_t value);
|
||||
static PB_CB_STATUS p_cb_u64_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- int8_t
|
||||
#if PB_CB_I8
|
||||
static PB_CB_STATUS p_cb_i8_push(p_cb_double *cbuffer, int8_t value);
|
||||
static PB_CB_STATUS p_cb_i8_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- int16_t
|
||||
#if PB_CB_I16
|
||||
static PB_CB_STATUS p_cb_i16_push(p_cb_double *cbuffer, int16_t value);
|
||||
static PB_CB_STATUS p_cb_i16_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- int32_t
|
||||
#if PB_CB_I32
|
||||
static PB_CB_STATUS p_cb_i32_push(p_cb_double *cbuffer, int32_t value);
|
||||
static PB_CB_STATUS p_cb_i32_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- int64_t
|
||||
#if PB_CB_I64
|
||||
static PB_CB_STATUS p_cb_i64_push(p_cb_double *cbuffer, int64_t value);
|
||||
static PB_CB_STATUS p_cb_i64_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- Float
|
||||
#if PB_CB_FLOAT
|
||||
static PB_CB_STATUS p_cb_float_push(p_cb_double *cbuffer, float value);
|
||||
static PB_CB_STATUS p_cb_float_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Prototypes -- Double
|
||||
#if PB_CB_DOUBLE
|
||||
static PB_CB_STATUS p_cb_double_push(p_cb_double *cbuffer, double value);
|
||||
static PB_CB_STATUS p_cb_double_empty(p_cb_double *cbuffer);
|
||||
#endif
|
||||
|
||||
// Circular Buffer Definitions -- uint8_t
|
||||
#if PB_CB_U8
|
||||
PB_CB_STATUS p_cb_u8_init(p_cb_u8 *circ_buffer, uint8_t *buff, uint32_t max_length)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
do
|
||||
{
|
||||
// Make sure the buffer isn't bad (null)
|
||||
if (!buff)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
// Make sure the max buffer is a useable size
|
||||
if (max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
|
||||
{
|
||||
ret = PB_CB_BAD_BUFFER_SIZE;
|
||||
break;
|
||||
}
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
PB_CB_STATUS p_cb_u8_push(p_cb_u8 *cbuffer, uint8_t value)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
|
||||
if (!cbuffer)
|
||||
{
|
||||
ret = PB_CB_NULL_CBUFFER;
|
||||
}
|
||||
else
|
||||
{
|
||||
cbuffer->buffer[cbuffer->head] = value;
|
||||
cbuffer->head = (cbuffer->head + 1) % cbuffer->max_len;
|
||||
}
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_u8_empty(p_cb_u8 *cbuffer)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
|
||||
do
|
||||
{
|
||||
if (!cbuffer)
|
||||
{
|
||||
ret = PB_CB_NULL_CBUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!cbuffer->buffer)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
memset(cbuffer->buffer, 0, cbuffer->max_len);
|
||||
cbuffer->head = 0;
|
||||
cbuffer->b_empty = true;
|
||||
cbuffer->b_filled = false;
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
// Circular Buffer Definitions -- uint16_t
|
||||
#if PB_CB_U16
|
||||
PB_CB_STATUS p_cb_u16_init(p_cb_u16 *circ_buffer, uint16_t *buff, uint32_t max_length)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
do
|
||||
{
|
||||
// Make sure the buffer isn't bad (null)
|
||||
if (!buff)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
// Make sure the max buffer is a useable size
|
||||
if (max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
|
||||
{
|
||||
ret = PB_CB_BAD_BUFFER_SIZE;
|
||||
break;
|
||||
}
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
PB_CB_STATUS p_cb_u16_push(p_cb_double *cbuffer, uint16_t value)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_u16_empty(p_cb_double *cbuffer)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Circular Buffer Definitions -- uint32_t
|
||||
#if PB_CB_U32
|
||||
PB_CB_STATUS p_cb_u32_init(p_cb_u32 *circ_buffer, uint32_t *buff, uint32_t max_length)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
do
|
||||
{
|
||||
// Make sure the buffer isn't bad (null)
|
||||
if (!buff)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
// Make sure the max buffer is a useable size
|
||||
if (max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
|
||||
{
|
||||
ret = PB_CB_BAD_BUFFER_SIZE;
|
||||
break;
|
||||
}
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_u32_push(p_cb_double *cbuffer, uint32_t value)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_u32_empty(p_cb_double *cbuffer)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Circular Buffer Definitions -- uint64_t
|
||||
#if PB_CB_U64
|
||||
PB_CB_STATUS p_cb_u64_init(p_cb_u64 *circ_buffer, uint64_t *buff, uint32_t max_length)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
do
|
||||
{
|
||||
// Make sure the buffer isn't bad (null)
|
||||
if (!buff)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
// Make sure the max buffer is a useable size
|
||||
if (max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
|
||||
{
|
||||
ret = PB_CB_BAD_BUFFER_SIZE;
|
||||
break;
|
||||
}
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_u64_push(p_cb_double *cbuffer, uint64_t value)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_u64_empty(p_cb_double *cbuffer)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if PB_CB_FLOAT
|
||||
PB_CB_STATUS p_cb_float_init(p_cb_float *circ_buffer, float *buff, uint32_t max_length)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
do
|
||||
{
|
||||
// Make sure the buffer isn't bad (null)
|
||||
if (!buff)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
// Make sure the max buffer is a useable size
|
||||
if (max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
|
||||
{
|
||||
ret = PB_CB_BAD_BUFFER_SIZE;
|
||||
break;
|
||||
}
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_float_push(p_cb_double *cbuffer, float value)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_float_empty(p_cb_double *cbuffer)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
// Circular Buffer Definitions -- double
|
||||
#if PB_CB_DOUBLE
|
||||
PB_CB_STATUS p_cb_double_init(p_cb_double *circ_buffer, double *buff, uint32_t max_length)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
do
|
||||
{
|
||||
// Make sure the buffer isn't bad (null)
|
||||
if (!buff)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
// Make sure the max buffer is a useable size
|
||||
if (max_length > PB_CB_MAX_BUFFER_SIZE || max_length <= 0)
|
||||
{
|
||||
ret = PB_CB_BAD_BUFFER_SIZE;
|
||||
break;
|
||||
}
|
||||
circ_buffer->buffer = buff;
|
||||
circ_buffer->max_len = (uint16_t)max_length;
|
||||
circ_buffer->head = 0;
|
||||
circ_buffer->push = p_cb_double_push;
|
||||
circ_buffer->empty = p_cb_double_empty;
|
||||
circ_buffer->empty(circ_buffer);
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
PB_CB_STATUS p_cb_double_push(p_cb_double *cbuffer, double value)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
|
||||
if (!cbuffer)
|
||||
{
|
||||
ret = PB_CB_NULL_CBUFFER;
|
||||
}
|
||||
else
|
||||
{
|
||||
cbuffer->buffer[cbuffer->head] = value;
|
||||
cbuffer->head = (cbuffer->head + 1) % cbuffer->max_len;
|
||||
}
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
PB_CB_STATUS p_cb_double_empty(p_cb_double *cbuffer)
|
||||
{
|
||||
PB_CB_STATUS ret = PB_CB_GOOD;
|
||||
|
||||
do
|
||||
{
|
||||
if (!cbuffer)
|
||||
{
|
||||
ret = PB_CB_NULL_CBUFFER;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!cbuffer->buffer)
|
||||
{
|
||||
ret = PB_CB_NULL_BUFFER;
|
||||
break;
|
||||
}
|
||||
memset(cbuffer->buffer, 0, sizeof(double) * cbuffer->max_len);
|
||||
cbuffer->head = 0;
|
||||
cbuffer->b_empty = true;
|
||||
cbuffer->b_filled = false;
|
||||
} while (0);
|
||||
|
||||
// Debugging
|
||||
#ifdef PB_CB_DEBUG
|
||||
handle_status(__func__, ret);
|
||||
#endif
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
@ -0,0 +1,200 @@
|
||||
// Resource/Inspiration: https://embedjournal.com/implementing-circular-buffer-embedded-c/
|
||||
|
||||
/*
|
||||
Penguin's Circular Buffer -- a simple floating queue designed for low memory usage (mainly for embedded)
|
||||
|
||||
This is a ring buffer with limited capabilities. It is meant as a container for moving data.
|
||||
Normally included features such as checks to see if the buffer is full or empty have been omitted
|
||||
because this type of buffer is being implemented mainly for sensor data usage. Data is almost never read
|
||||
individually, and even if it is, it isn't meant to be cleared on read. It is a simple moving buffer that
|
||||
automatically writes over old data for the purpose of keeping track of the most up to date data.
|
||||
|
||||
Notes:
|
||||
- Initialization is mandatory using p_cb_<type>_init.
|
||||
- If a circular buffer is not initialized, you will run into a LOT of hard-to-debug problems. Just initialize it.
|
||||
- By default, all cb types should be defined as disabled. This is to save on size. Enable the ones you want to use.
|
||||
|
||||
Behavior:
|
||||
- Oldest data is overwritten
|
||||
- popping of data isn't implemented. If this feature is required, use a ring buffer.
|
||||
|
||||
Acronyms:
|
||||
- p: penguin
|
||||
- pb: penguin buffer
|
||||
- cb: circular buffer
|
||||
- uX, where X is bit size: unsigned X bit integer
|
||||
- iX, where X is bit size: signed X bit integer
|
||||
|
||||
Note: I wrote this like 3 years ago or something. I hope it works.
|
||||
*/
|
||||
|
||||
#ifndef _PCIRCULARBUFFER_H_
|
||||
#define _PCIRCULARBUFFER_H_
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
// comment this out for release builds
|
||||
//#define PB_CB_DEBUG
|
||||
|
||||
// Making these PB_EN/DIS rather than just ENABLE/DISABLE because
|
||||
// some enable/disable definition might already exist that is
|
||||
// inversely active (enabled = 0, disable = 1)
|
||||
// this way our en/dis definitions are explicit
|
||||
#ifndef PB_ENABLE
|
||||
#define PB_ENABLE (1)
|
||||
#endif
|
||||
|
||||
#ifndef PB_DISABLE
|
||||
#define PB_DISABLE (0)
|
||||
#endif
|
||||
|
||||
// Max size is 65535 (2^16 - 1) so variables can be safely set 16 bits (unsigned)
|
||||
// If you want to change this, you'll need to change the sizes of all heads and max lengths
|
||||
#define PB_CB_MAX_BUFFER_SIZE (65535)
|
||||
|
||||
// Config
|
||||
// Disable or Enable types needed here
|
||||
// We can save code size this way
|
||||
// While there are better ways to do this, this is the most accessible for anyone imo
|
||||
#define PB_CB_FLOAT PB_DISABLE
|
||||
#define PB_CB_DOUBLE PB_DISABLE
|
||||
#define PB_CB_U8 PB_ENABLE
|
||||
#define PB_CB_U16 PB_DISABLE
|
||||
#define PB_CB_U32 PB_DISABLE
|
||||
#define PB_CB_U64 PB_DISABLE
|
||||
#define PB_CB_I8 PB_DISABLE
|
||||
#define PB_CB_I16 PB_DISABLE
|
||||
#define PB_CB_I32 PB_DISABLE
|
||||
#define PB_CB_I64 PB_DISABLE
|
||||
|
||||
typedef enum PB_CB_STATUS
|
||||
{
|
||||
PB_CB_GOOD = 0,
|
||||
PB_CB_BAD = 1,
|
||||
PB_CB_BAD_BUFFER_SIZE = 2,
|
||||
PB_CB_NULL_BUFFER = 3,
|
||||
PB_CB_NULL_CBUFFER = 4
|
||||
} PB_CB_STATUS;
|
||||
|
||||
#if PB_CB_U8
|
||||
typedef struct p_cb_u8
|
||||
{
|
||||
uint8_t *buffer;
|
||||
uint16_t head;
|
||||
uint16_t max_len;
|
||||
// Signifies the buffer being filled at least once.
|
||||
// Useful for initializing sensor data
|
||||
bool b_filled;
|
||||
// Signifies the buffer being empty
|
||||
// Useful for knowing if data is being received
|
||||
bool b_empty;
|
||||
|
||||
PB_CB_STATUS (*push)(struct p_cb_u8 *cbuffer, uint8_t value);
|
||||
PB_CB_STATUS (*empty)(struct p_cb_u8 *cbuffer);
|
||||
} p_cb_u8;
|
||||
|
||||
PB_CB_STATUS p_cb_u8_init(p_cb_u8 *circ_buffer, uint8_t *buff, uint32_t max_length);
|
||||
#endif
|
||||
|
||||
#if PB_CB_U16
|
||||
typedef struct p_cb_u16
|
||||
{
|
||||
uint16_t *buffer;
|
||||
uint16_t head;
|
||||
uint16_t max_len;
|
||||
// Signifies the buffer being filled at least once.
|
||||
// Useful for initializing sensor data
|
||||
bool b_filled;
|
||||
// Signifies the buffer being empty
|
||||
// Useful for knowing if data is being received
|
||||
bool b_empty;
|
||||
|
||||
PB_CB_STATUS (*push)(struct p_cb_u16 *cbuffer, uint16_t value);
|
||||
PB_CB_STATUS (*empty)(struct p_cb_u16 *cbuffer);
|
||||
} p_cb_u16;
|
||||
|
||||
PB_CB_STATUS p_cb_u16_init(p_cb_u16 *circ_buffer, uint16_t *buff, uint32_t max_length);
|
||||
#endif
|
||||
|
||||
#if PB_CB_U32
|
||||
typedef struct p_cb_u32
|
||||
{
|
||||
uint32_t *buffer;
|
||||
uint16_t head;
|
||||
uint16_t max_len;
|
||||
// Signifies the buffer being filled at least once.
|
||||
// Useful for initializing sensor data
|
||||
bool b_filled;
|
||||
// Signifies the buffer being empty
|
||||
// Useful for knowing if data is being received
|
||||
bool b_empty;
|
||||
|
||||
PB_CB_STATUS (*push)(struct p_cb_u32 *cbuffer, uint32_t value);
|
||||
PB_CB_STATUS (*empty)(struct p_cb_u32 *cbuffer);
|
||||
} p_cb_u32;
|
||||
|
||||
PB_CB_STATUS p_cb_u32_init(p_cb_u32 *circ_buffer, uint32_t *buff, uint32_t max_length);
|
||||
#endif
|
||||
|
||||
#if PB_CB_U64
|
||||
typedef struct p_cb_u64
|
||||
{
|
||||
uint64_t *buffer;
|
||||
uint16_t head;
|
||||
uint16_t max_len;
|
||||
// Signifies the buffer being filled at least once.
|
||||
// Useful for initializing sensor data
|
||||
bool b_filled;
|
||||
// Signifies the buffer being empty
|
||||
// Useful for knowing if data is being received
|
||||
bool b_empty;
|
||||
|
||||
PB_CB_STATUS (*push)(struct p_cb_u64 *cbuffer, uint64_t value);
|
||||
PB_CB_STATUS (*empty)(struct p_cb_u64 *cbuffer);
|
||||
} p_cb_u64;
|
||||
|
||||
PB_CB_STATUS p_cb_u64_init(p_cb_u64 *circ_buffer, uint64_t *buff, uint32_t max_length);
|
||||
#endif
|
||||
|
||||
#if PB_CB_FLOAT
|
||||
typedef struct p_cb_float
|
||||
{
|
||||
float *buffer;
|
||||
uint16_t head;
|
||||
uint16_t max_len;
|
||||
// Signifies the buffer being filled at least once.
|
||||
// Useful for initializing sensor data
|
||||
bool b_filled;
|
||||
// Signifies the buffer being empty
|
||||
// Useful for knowing if data is being received
|
||||
bool b_empty;
|
||||
|
||||
PB_CB_STATUS (*push)(struct p_cb_float *cbuffer, float value);
|
||||
PB_CB_STATUS (*empty)(struct p_cb_float *cbuffer);
|
||||
} p_cb_float;
|
||||
|
||||
PB_CB_STATUS p_cb_float_init(p_cb_float *circ_buffer, float *buff, uint32_t max_length);
|
||||
#endif
|
||||
|
||||
#if PB_CB_DOUBLE
|
||||
typedef struct p_cb_double
|
||||
{
|
||||
double *buffer;
|
||||
uint16_t head;
|
||||
uint16_t max_len;
|
||||
// Signifies the buffer being filled at least once.
|
||||
// Useful for initializing sensor data
|
||||
bool b_filled;
|
||||
// Signifies the buffer being empty
|
||||
// Useful for knowing if data is being received
|
||||
bool b_empty;
|
||||
|
||||
PB_CB_STATUS (*push)(struct p_cb_double *cbuffer, double value);
|
||||
PB_CB_STATUS (*empty)(struct p_cb_double *cbuffer);
|
||||
} p_cb_double;
|
||||
|
||||
PB_CB_STATUS p_cb_double_init(p_cb_double *circ_buffer, double *buff, uint32_t max_length);
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue