mirror of
https://bitbucket.org/librepilot/librepilot.git
synced 2024-12-10 18:24:11 +01:00
4ca10e92c7
1. Added reenumeration function and call it on USB init (device will appear after reprogramming now) 2. Moved buffer.c to general flight/Libraries location 3. Removed the 62 byte transmission limitation by adding a transmission buffer 4. Sped up USB communication by increasing endpoint polling frequency Note, that the nonblocking and blocking USB send functions are not blocking entirely correcting. The blocking calls the nonblocking, and the nonblocking blocks until the last chunk has started tranmission if it's a big transmission. The buffering I added would generalize to non-blocking nicely, but would require using the EP1(IN) callback to handle most of the tranmission. This creates a lot of issues if one function is pushing data onto the buffer and the interrupt is sending. git-svn-id: svn://svn.openpilot.org/OpenPilot/trunk@1403 ebee16cc-31ac-478f-84a7-5cbb03baadba
107 lines
3.9 KiB
C
107 lines
3.9 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
|
||
|
||
/**
|
||
* @}
|
||
*/
|