mirror of
https://bitbucket.org/librepilot/librepilot.git
synced 2024-11-30 08:24:11 +01:00
833e8428d2
find ./flight/Libraries/ \! \( -name '*~' -a -prune \) -type f | xargs -I{} bash -c 'echo {}; dos2unix {}; gnuindent -npro -kr -i8 -ts8 -sob -ss -ncs -cp1 -il0 {};'
git-svn-id: svn://svn.openpilot.org/OpenPilot/trunk@1706 ebee16cc-31ac-478f-84a7-5cbb03baadba
108 lines
4.0 KiB
C
108 lines
4.0 KiB
C
/**
|
||
******************************************************************************
|
||
* @addtogroup OpenPilotModules OpenPilot Modules
|
||
* @{
|
||
* @addtogroup GSPModule GPS Module
|
||
* @brief Process GPS information
|
||
* @{
|
||
*
|
||
* @file buffer.c
|
||
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
|
||
* @brief see below
|
||
* As with all modules only the initialize function is exposed all other
|
||
* interactions with the module take place through the event queue and
|
||
* objects.
|
||
* @see The GNU Public License (GPL) Version 3
|
||
*
|
||
*****************************************************************************/
|
||
|
||
//*****************************************************************************
|
||
//
|
||
// File Name : 'buffer.h'
|
||
// Title : Multipurpose byte buffer structure and methods
|
||
// Author : Pascal Stang - Copyright (C) 2001-2002
|
||
// Created : 9/23/2001
|
||
// Revised : 11/16/2002
|
||
// Version : 1.1
|
||
// Target MCU : any
|
||
// Editor Tabs : 4
|
||
//
|
||
/// \code #include "buffer.h" \endcode
|
||
/// \par Overview
|
||
/// This byte-buffer structure provides an easy and efficient way to store
|
||
/// and process a stream of bytes. You can create as many buffers as you
|
||
/// like (within memory limits), and then use this common set of functions to
|
||
/// access each buffer. The buffers are designed for FIFO operation (first
|
||
/// in, first out). This means that the first byte you put in the buffer
|
||
/// will be the first one you get when you read out the buffer. Supported
|
||
/// functions include buffer initialize, get byte from front of buffer, add
|
||
/// byte to end of buffer, check if buffer is full, and flush buffer. The
|
||
/// buffer uses a circular design so no copying of data is ever necessary.
|
||
/// This buffer is not dynamically allocated, it has a user-defined fixed
|
||
/// maximum size. This buffer is used in many places in the avrlib code.
|
||
//
|
||
// This code is distributed under the GNU Public License
|
||
// which can be found at http://www.gnu.org/licenses/gpl.txt
|
||
//
|
||
//*****************************************************************************
|
||
//@{
|
||
|
||
#ifndef BUFFER_H
|
||
#define BUFFER_H
|
||
|
||
#include "stdint.h"
|
||
|
||
// structure/typdefs
|
||
|
||
//! cBuffer structure
|
||
typedef struct struct_cBuffer {
|
||
unsigned char *dataptr; ///< the physical memory address where the buffer is stored
|
||
unsigned short size; ///< the allocated size of the buffer
|
||
unsigned short datalength; ///< the length of the data currently in the buffer
|
||
unsigned short dataindex; ///< the index into the buffer where the data starts
|
||
} cBuffer;
|
||
|
||
// function prototypes
|
||
|
||
//! initialize a buffer to start at a given address and have given size
|
||
void bufferInit(cBuffer * buffer, uint8_t * start, uint32_t size);
|
||
|
||
//! check free space in buffer
|
||
uint32_t bufferRemainingSpace(cBuffer * buffer);
|
||
|
||
//! get the first byte from the front of the buffer
|
||
uint8_t bufferGetFromFront(cBuffer * buffer);
|
||
|
||
//! get the number of bytes buffered
|
||
uint32_t bufferBufferedData(cBuffer * buffer);
|
||
|
||
//! copy number of elements into another buffer
|
||
uint8_t bufferGetChunkFromFront(cBuffer * buffer, uint8_t * dest,
|
||
uint32_t size);
|
||
|
||
//! dump (discard) the first numbytes from the front of the buffer
|
||
void bufferDumpFromFront(cBuffer * buffer, uint32_t numbytes);
|
||
|
||
//! get a byte at the specified index in the buffer (kind of like array access)
|
||
// ** note: this does not remove the byte that was read from the buffer
|
||
uint8_t bufferGetAtIndex(cBuffer * buffer, uint32_t index);
|
||
|
||
//! add a byte to the end of the buffer
|
||
uint8_t bufferAddToEnd(cBuffer * buffer, uint8_t data);
|
||
|
||
//! queue a block of character to end of buffer
|
||
uint8_t bufferAddChunkToEnd(cBuffer * buffer, const uint8_t * data,
|
||
uint32_t size);
|
||
|
||
//! check if the buffer is full/not full (returns non-zero value if not full)
|
||
uint8_t bufferIsNotFull(cBuffer * buffer);
|
||
|
||
//! flush (clear) the contents of the buffer
|
||
void bufferFlush(cBuffer * buffer);
|
||
|
||
#endif
|
||
|
||
/**
|
||
* @}
|
||
*/
|