Buffer Functions

Functions
enum sd_buff_err	sd_char_buff_init (struct sd_cbuf *buff, uint32_t size, uint8_t *pbuff)
	Initialize Character Buffer. More...
enum sd_buff_err	sd_doub_buff_init (struct sd_doub_buff *buff, uint32_t size, uint8_t **pbuff)
	Initialize Double Buffer. More...
enum sd_buff_err	sd_char_buff_putc (struct sd_cbuf *buffer, uint8_t data)
	Put Character in Buffer Write a character to the buffer. More...
enum sd_buff_err	sd_char_buff_putc_to (struct sd_cbuf *buffer, uint8_t data, uint32_t timeout)
	Put Character in Buffer with Timeout Write a character to the buffer with a timeout. More...
enum sd_buff_err	sd_char_buff_write (struct sd_cbuf *buffer, uint8_t *data, uint32_t len)
	Write Data to Buffer Write a specified length of characters from a data pointer to the buffer. More...
enum sd_buff_err	sd_char_buff_read (struct sd_cbuf *buff, uint8_t *data, uint32_t *len)
	Read Length of Characters from Buffer Copy a specified length of the buffer to a pointer. More...
enum sd_buff_err	sd_char_buff_getc (struct sd_cbuf *buff, uint8_t *data)
	Get Character from Buffer Get a single character from the buffer. More...
enum sd_buff_err	sd_char_buff_getc_to (struct sd_cbuf *buff, uint8_t *data, uint32_t timeout)
	Get Character from Buffer with Timeout Get a single character from the buffer with a timeout if the buffer is locked. More...
enum sd_buff_err	sd_buff_reset (struct sd_cbuf *buff)
	Reset buffer Resets the in and out indexes of the buffer (without removing contents of the buffer) to the start of the buffer. More...
__weak void	sd_char_write_end_cb (struct sd_cbuf *buff)
	Write Command End Callback User defined function executed when a write operation is completed. More...
__weak void	sd_char_read_end_cb (struct sd_cbuf *buff)
	Read Command End Callback User defined function executed when a read operation is completed. More...
enum sd_buff_err	sd_doub_buff_init (struct sd_doub_buff *buff, uint32_t size, uint8_t *pbuff[])

Detailed Description

Function Documentation

sd_buff_reset()

enum sd_buff_err sd_buff_reset

(

struct sd_cbuf *

buff

)

#include <Src/sd_buffer.c>

Reset buffer Resets the in and out indexes of the buffer (without removing contents of the buffer) to the start of the buffer.

Parameters

buff	The buffer to reset

Return values

SD_BUFF_SUCCESS

on success, error state otherwise

{
    
    return SD_BUFF_SUCCESS;
}

sd_char_buff_getc()

enum sd_buff_err sd_char_buff_getc	(	struct sd_cbuf *	buff,
		uint8_t *	data
	)

#include <Src/sd_buffer.c>

Get Character from Buffer Get a single character from the buffer.

Parameters

buff	The buffer to read from
data	Pointer to character to write to

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

Warning

This does not destroy the contents of the buffer. The circular nature of the buffer will allow any characters to be written over, including characters that have not been read yet (buffer overflow condition).

{
                       
    if (buff == NULL)
        return SD_BUFF_NULL_ERROR;
  
    /* Check if the buffer was newly initialized */
    if (buff->state == SD_BUFF_INITIALIZED)
        buff->state = SD_BUFF_READY;
  
    /* Wait until the buffer is available */
    if (buff->state != SD_BUFF_READY) 
        return SD_BUFF_LOCKED;
  
    /* Set the state to busy */
    buff->state = SD_BUFF_BUSY;
  
    /* If the buffer is at the end, wrap around */
    if (buff->out >= buff->size) 
        buff->out = 0;
  
    if (buff->len) {
 *data = buff->buff[buff->out++];
    
        /* Check for end of buffer and wrap around */
        if (buff->out >= buff->size) 
            buff->out = 0;
        
        /* Decrement length */
        if (buff->len-- <= 0)
            buff->len = 0;
    } else {
        return SD_BUFF_EMPTY;
    }
  
    /* Release the buffer */
    buff->state = SD_BUFF_READY;
  
    /* Execute user-defined callback */
    sd_char_read_end_cb(buff);
  
    return SD_BUFF_SUCCESS;
}

sd_char_buff_getc_to()

enum sd_buff_err sd_char_buff_getc_to	(	struct sd_cbuf *	buff,
		uint8_t *	data,
		uint32_t	timeout
	)

#include <Src/sd_buffer.c>

Get Character from Buffer with Timeout Get a single character from the buffer with a timeout if the buffer is locked.

Parameters

buff	The buffer to read from
data	Pointer to character to write to
timeout	Timeout value to use for read

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

Warning

This does not destroy the contents of the buffer. The circular nature of the buffer will allow any characters to be written over, including characters that have not been read yet (buffer overflow condition).

{
    uint32_t time = HAL_GetTick();
    
    if (buff == NULL)
        return SD_BUFF_NULL_ERROR;
  
    /* Check if the buffer is ready to be used */
    while (buff->state != SD_BUFF_READY) {
        /* Check for timeout */
        if ((timeout == 0) || (HAL_GetTick() - time) > timeout)
            return SD_BUFF_TIMEOUT;
    }
  
    /* Set the state to busy */
    buff->state = SD_BUFF_BUSY;
  
    /* If the buffer is at the end, wrap around */
    if (buff->out >= buff->size) 
        buff->out = 0;
  
    if (buff->len) {
 *data = buff->buff[buff->out++];
    
        /* Check for end of buffer and wrap around */
        if (buff->out >= buff->size) 
            buff->out = 0;
        
        /* Decrement length */
        if (buff->len-- <= 0)
            buff->len = 0;
    } else {
        return SD_BUFF_EMPTY;
    }
  
    /* Release the buffer */
    buff->state = SD_BUFF_READY;
  
    /* Execute user-defined callback */
    sd_char_read_end_cb(buff);
  
    return SD_BUFF_SUCCESS;
}

sd_char_buff_init()

enum sd_buff_err sd_char_buff_init	(	struct sd_cbuf *	buff,
		uint32_t	size,
		uint8_t *	pbuff
	)

#include <Src/sd_buffer.c>

Initialize Character Buffer.

Parameters

buffer	The buffer to initialize
size	The length of the buffer
pbuff	Pointer to location of character array to hold buffer data

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

{
    /* Initialize the buffer to all zeros */
    memset(buff, 0, sizeof(struct sd_cbuf));
  
    /* Set the default values of the buffer */
    buff->size = size;
    buff->buff = pbuff;
    
    /* Buffer has been initialized */
    buff->state = SD_BUFF_READY;
   
    return SD_BUFF_SUCCESS;
}

sd_char_buff_putc()

enum sd_buff_err sd_char_buff_putc	(	struct sd_cbuf *	buffer,
		uint8_t	data
	)

#include <Src/sd_buffer.c>

Put Character in Buffer Write a character to the buffer.

Parameters

buffer	The buffer to write to
data	The character to write

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

{
    if (buffer == NULL)
        return SD_BUFF_NULL_ERROR;
    
    /* Check if the buffer is ready to be used */
    if (buffer->state != SD_BUFF_READY)
        return SD_BUFF_LOCKED;
  
    /* Set the state to busy */
    buffer->state = SD_BUFF_BUSY;
  
    buffer->buff[buffer->in++] = data;
  
    /* Check for end of buffer and wrap around */
    if (++buffer->in >= buffer->size) 
        buffer->in = 0;
  
    /* Increase the length of the buffer */
    buffer->len++;
  
    /* Release the buffer */
    buffer->state = SD_BUFF_READY;
  
    return SD_BUFF_SUCCESS;
}

sd_char_buff_putc_to()

enum sd_buff_err sd_char_buff_putc_to	(	struct sd_cbuf *	buffer,
		uint8_t	data,
		uint32_t	timeout
	)

#include <Src/sd_buffer.c>

Put Character in Buffer with Timeout Write a character to the buffer with a timeout.

Parameters

buffer	The buffer to write to
data	The character to write
timeout	The timeout used to write the character

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

{
    uint32_t time = HAL_GetTick();
    
    if (buffer == NULL)
        return SD_BUFF_NULL_ERROR;
    
    /* Check if the buffer is ready to be used */
    while (buffer->state != SD_BUFF_READY) {
        /* Check for timeout */
        if ((timeout == 0) || (HAL_GetTick() - time) > timeout)
            return SD_BUFF_TIMEOUT;
    }
  
    /* Set the state to busy */
    buffer->state = SD_BUFF_BUSY;
  
    buffer->buff[buffer->in++] = data;
  
    /* Check for end of buffer and wrap around */
    if (++buffer->in >= buffer->size) 
        buffer->in = 0;
  
    /* Increase the length of the buffer */
    buffer->len++;
  
    /* Release the buffer */
    buffer->state = SD_BUFF_READY;
  
    return SD_BUFF_SUCCESS;
}

sd_char_buff_read()

enum sd_buff_err sd_char_buff_read	(	struct sd_cbuf *	buff,
		uint8_t *	data,
		uint32_t *	len
	)

#include <Src/sd_buffer.c>

Read Length of Characters from Buffer Copy a specified length of the buffer to a pointer.

Parameters

buff	The buffer to read from
data	The data pointer to write the buffer to
len	The length of the buffer to read

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

Warning

This does not destroy the contents of the buffer. The circular nature of the buffer will allow any characters to be written over, including characters that have not been read yet (buffer overflow condition).

{              
    uint32_t tmp_len;
                       
    if (buff == NULL)
        return SD_BUFF_NULL_ERROR;
    if (len == NULL)
        return SD_BUFF_ERROR;  
    
    /* Check if the buffer was newly initialized */
    if (buff->state == SD_BUFF_INITIALIZED) 
        buff->state = SD_BUFF_READY;
  
    /* Wait until the buffer is available */
    if (buff->state != SD_BUFF_READY)
        return SD_BUFF_LOCKED;
  
    /* Set the state to busy */
    buff->state = SD_BUFF_BUSY;
  
    /* If the buffer is at the end, wrap around */
    if (buff->out >= buff->len)
        buff->out = 0;
  
    while (buff->len) {
 *data++ = buff->buff[buff->out++];
    
        /* Increase the length of the buffer read */
        tmp_len++;
    
        /* Check for end of buffer and wrap around */
        if (buff->out >= buff->size )
            buff->out = 0;
    
        if (buff->len-- <= 0 )
            buff->len = 0;
    }
  
    /* Set the length of the buffer that was read */
    *len = tmp_len;
  
    /* Release the buffer */
    buff->state = SD_BUFF_READY;
  
    /* Execute user-defined callback */
    sd_char_read_end_cb(buff);
  
    return SD_BUFF_SUCCESS;
}

sd_char_buff_write()

enum sd_buff_err sd_char_buff_write	(	struct sd_cbuf *	buffer,
		uint8_t *	data,
		uint32_t	len
	)

#include <Src/sd_buffer.c>

Write Data to Buffer Write a specified length of characters from a data pointer to the buffer.

Parameters

buffer	The buffer to write to
data	The data pointer to data to write to buffer
len	The length of the buffer to write

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

{
    if (buffer == NULL)
        return SD_BUFF_NULL_ERROR;
    if (len == 0)
        return SD_BUFF_ERROR;
  
    /* Check if the buffer was newly initialized */
    if (buffer->state == SD_BUFF_INITIALIZED ) 
        buffer->state = SD_BUFF_READY;
  
    if (buffer->state != SD_BUFF_READY)
        return SD_BUFF_LOCKED;

    /* Set the state to busy */
    buffer->state = SD_BUFF_BUSY;
  
    /* If the buffer is at the end, wrap around */
    if (buffer->in >= buffer->size)
        buffer->in = 0; 
  
    while (len--) {
        /* Add the data to the buffer */
        buffer->buff[buffer->in] = *data++;
    
        /* Check for end of buffer and wrap around */
        if (++buffer->in >= buffer->size ) buffer->in = 0;
    
        /* Increase count (length) of buffer */
        buffer->len++;
    }
  
    /* Release the buffer */
    buffer->state = SD_BUFF_READY;
  
    /* Execute user-defined callback */
    sd_char_write_end_cb(buffer);
  
    return SD_BUFF_SUCCESS;
}

sd_char_read_end_cb()

void sd_char_read_end_cb

(

struct sd_cbuf *

buff

)

#include <Src/sd_buffer.c>

Read Command End Callback User defined function executed when a read operation is completed.

Note

This function should not be modified, when the callback is needed, the sd_char_read_end_cb can be implemented in the user file.

Parameters

buff	The buffer that was read

Return values

none

{

}

sd_char_write_end_cb()

void sd_char_write_end_cb

(

struct sd_cbuf *

buff

)

#include <Src/sd_buffer.c>

Write Command End Callback User defined function executed when a write operation is completed.

Note

This function should not be modified, when the callback is needed, the sd_char_write_end_cb can be implemented in the user file.

Parameters

buff	The buffer that was written

Return values

None

{
    
}

sd_doub_buff_init()

enum sd_buff_err sd_doub_buff_init	(	struct sd_doub_buff *	buff,
		uint32_t	size,
		uint8_t **	pbuff
	)

#include <Src/sd_buffer.c>

Initialize Double Buffer.

Parameters

buff	The buffer to initialize
size	Length of the buffer
pbuff	Pointer to buffer array

Return values

SD_BUFF_SUCCESS

on success, error status otherwise

{
    memset(buff, 0, sizeof(struct sd_doub_buff));
    
    buff->size = size;
    buff->buff = pbuff;

    return SD_BUFF_SUCCESS;
}