This fixes multiple bugs with ring buffers and re-factors the code. The public API has not changed, however the underlying implementation have various private functions have been changed. The following behavioral changes have been made - Size of ring buffers for No-Split/Allow-Split buffers will not be rounded up to the nearest 32-bit aligned size. This was done to simplify the implementation - Item size for No-Split/Allow-Split buffers will also be rounded up to the nearest 32-bit aligned size. The following bugs have been fixed - In copyItemToRingbufAllowSplit(), when copying an item where the aligned size is smaller than the remaining length, the function does not consider the case where the true size of the item is less than 4 bytes. - The copy functions will automatically wrap around the write pointers when the remaining length of the buffer is not large enough to fit a header, but does not consider if wrapping around will cause an overlap with the read pointer. This will make a full buffer be mistaken for an empty buffer closes #1711 - xRingbufferSend() can get stuck in a infinite loop when the size of the free memory is larger than the needed_size, but too small to fit in the ring buffer due to alignment and extra overhead of wrapping around. closes #1846 - Fixed documentation with ring buffer queue set API - Adding and removing from queue set does not consider the case where the read/write semaphores actually hold a value. The following functions have been deprecated - xRingbufferIsNextItemWrapped() due to lack of thread safety - xRingbufferAddToQueueSetWrite() and xRingbufferRemoveFromQueueSetWrite() as adding the queue sets only work under receive operations. The following functions have been added - xRingbufferReceiveSplit() and xRingbufferReceiveSplitFromISR() as a thread safe way to receive from allow-split buffers - vRingbufferGetInfo() Documentation for ring buffers has also been added.
1184 lines
54 KiB
C
1184 lines
54 KiB
C
// Copyright 2015-2018 Espressif Systems (Shanghai) PTE LTD
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include "semphr.h"
|
|
#include "ringbuf.h"
|
|
|
|
//32-bit alignment macros
|
|
#define rbALIGN_SIZE( xSize ) ( ( xSize + portBYTE_ALIGNMENT_MASK ) & ~portBYTE_ALIGNMENT_MASK )
|
|
#define rbCHECK_ALIGNED( pvPtr ) ( ( ( UBaseType_t ) pvPtr & portBYTE_ALIGNMENT_MASK ) == 0 )
|
|
|
|
//Ring buffer flags
|
|
#define rbALLOW_SPLIT_FLAG ( ( UBaseType_t ) 1 ) //The ring buffer allows items to be split
|
|
#define rbBYTE_BUFFER_FLAG ( ( UBaseType_t ) 2 ) //The ring buffer is a byte buffer
|
|
#define rbBUFFER_FULL_FLAG ( ( UBaseType_t ) 4 ) //The ring buffer is currently full (write pointer == free pointer)
|
|
|
|
//Item flags
|
|
#define rbITEM_FREE_FLAG ( ( UBaseType_t ) 1 ) //Item has been retrieved and returned by application, free to overwrite
|
|
#define rbITEM_DUMMY_DATA_FLAG ( ( UBaseType_t ) 2 ) //Data from here to end of the ring buffer is dummy data. Restart reading at start of head of the buffer
|
|
#define rbITEM_SPLIT_FLAG ( ( UBaseType_t ) 4 ) //Valid for RINGBUF_TYPE_ALLOWSPLIT, indicating that rest of the data is wrapped around
|
|
|
|
typedef struct {
|
|
//This size of this structure must be 32-bit aligned
|
|
size_t xItemLen;
|
|
UBaseType_t uxItemFlags;
|
|
} ItemHeader_t;
|
|
|
|
#define rbHEADER_SIZE sizeof(ItemHeader_t)
|
|
typedef struct Ringbuffer_t Ringbuffer_t;
|
|
typedef BaseType_t (*CheckItemFitsFunction_t)(Ringbuffer_t *pxRingbuffer, size_t xItemSize);
|
|
typedef void (*CopyItemFunction_t)(Ringbuffer_t *pxRingbuffer, const uint8_t *pcItem, size_t xItemSize);
|
|
typedef BaseType_t (*CheckItemAvailFunction_t) (Ringbuffer_t *pxRingbuffer);
|
|
typedef void *(*GetItemFunction_t)(Ringbuffer_t *pxRingbuffer, BaseType_t *pxIsSplit, size_t xMaxSize, size_t *pxItemSize);
|
|
typedef void (*ReturnItemFunction_t)(Ringbuffer_t *pxRingbuffer, uint8_t *pvItem);
|
|
typedef size_t (*GetCurMaxSizeFunction_t)(Ringbuffer_t *pxRingbuffer);
|
|
|
|
struct Ringbuffer_t {
|
|
size_t xSize; //Size of the data storage
|
|
UBaseType_t uxRingbufferFlags; //Flags to indicate the type and status of ring buffer
|
|
size_t xMaxItemSize; //Maximum item size
|
|
|
|
CheckItemFitsFunction_t xCheckItemFits; //Function to check if item can currently fit in ring buffer
|
|
CopyItemFunction_t vCopyItem; //Function to copy item to ring buffer
|
|
GetItemFunction_t pvGetItem; //Function to get item from ring buffer
|
|
ReturnItemFunction_t vReturnItem; //Function to return item to ring buffer
|
|
GetCurMaxSizeFunction_t xGetCurMaxSize; //Function to get current free size
|
|
|
|
uint8_t *pucWrite; //Write Pointer. Points to where the next item should be written
|
|
uint8_t *pucRead; //Read Pointer. Points to where the next item should be read from
|
|
uint8_t *pucFree; //Free Pointer. Points to the last item that has yet to be returned to the ring buffer
|
|
uint8_t *pucHead; //Pointer to the start of the ring buffer storage area
|
|
uint8_t *pucTail; //Pointer to the end of the ring buffer storage area
|
|
|
|
BaseType_t xItemsWaiting; //Number of items/bytes(for byte buffers) currently in ring buffer that have not yet been read
|
|
SemaphoreHandle_t xFreeSpaceSemaphore; //Binary semaphore, wakes up writing threads when more free space becomes available or when another thread times out attempting to write
|
|
SemaphoreHandle_t xItemsBufferedSemaphore; //Binary semaphore, indicates there are new packets in the circular buffer. See remark.
|
|
portMUX_TYPE mux; //Spinlock required for SMP
|
|
};
|
|
|
|
/*
|
|
Remark: A counting semaphore for items_buffered_sem would be more logical, but counting semaphores in
|
|
FreeRTOS need a maximum count, and allocate more memory the larger the maximum count is. Here, we
|
|
would need to set the maximum to the maximum amount of times a null-byte unit first in the buffer,
|
|
which is quite high and so would waste a fair amount of memory.
|
|
*/
|
|
|
|
/* ------------------------------------------------ Static Declarations ------------------------------------------ */
|
|
/*
|
|
* WARNING: All of the following static functions (except generic functions)
|
|
* ARE NOT THREAD SAFE. Therefore they should only be called within a critical
|
|
* section (using spin locks)
|
|
*/
|
|
|
|
//Calculate current amount of free space (in bytes) in the ring buffer
|
|
static size_t prvGetFreeSize(Ringbuffer_t *pxRingbuffer);
|
|
|
|
//Checks if an item/data is currently available for retrieval
|
|
static BaseType_t prvCheckItemAvail(Ringbuffer_t *pxRingbuffer);
|
|
|
|
//Checks if an item will currently fit in a no-split/allow-split ring buffer
|
|
static BaseType_t prvCheckItemFitsDefault( Ringbuffer_t *pxRingbuffer, size_t xItemSize);
|
|
|
|
//Checks if an item will currently fit in a byte buffer
|
|
static BaseType_t prvCheckItemFitsByteBuffer( Ringbuffer_t *pxRingbuffer, size_t xItemSize);
|
|
|
|
//Copies an item to a no-split ring buffer. Only call this function after calling prvCheckItemFitsDefault()
|
|
static void prvCopyItemNoSplit(Ringbuffer_t *pxRingbuffer, const uint8_t *pucItem, size_t xItemSize);
|
|
|
|
//Copies an item to a allow-split ring buffer. Only call this function after calling prvCheckItemFitsDefault()
|
|
static void prvCopyItemAllowSplit(Ringbuffer_t *pxRingbuffer, const uint8_t *pucItem, size_t xItemSize);
|
|
|
|
//Copies an item to a byte buffer. Only call this function after calling prvCheckItemFitsByteBuffer()
|
|
static void prvCopyItemByteBuf(Ringbuffer_t *pxRingbuffer, const uint8_t *pucItem, size_t xItemSize);
|
|
|
|
//Retrieve item from no-split/allow-split ring buffer. *pxIsSplit is set to pdTRUE if the retrieved item is split
|
|
static void *prvGetItemDefault(Ringbuffer_t *pxRingbuffer, BaseType_t *pxIsSplit, size_t xUnusedParam, size_t *pxItemSize);
|
|
|
|
//Retrieve data from byte buffer. If xMaxSize is 0, all continuous data is retrieved
|
|
static void *prvGetItemByteBuf(Ringbuffer_t *pxRingbuffer, BaseType_t *pxUnusedParam ,size_t xMaxSize, size_t *pxItemSize);
|
|
|
|
//Return an item to a split/no-split ring buffer
|
|
static void prvReturnItemDefault(Ringbuffer_t *pxRingbuffer, uint8_t *pucItem);
|
|
|
|
//Return data to a byte buffer
|
|
static void prvReturnItemByteBuf(Ringbuffer_t *pxRingbuffer, uint8_t *pucItem);
|
|
|
|
//Get the maximum size an item that can currently have if sent to a no-split ring buffer
|
|
static size_t prvGetCurMaxSizeNoSplit(Ringbuffer_t *pxRingbuffer);
|
|
|
|
//Get the maximum size an item that can currently have if sent to a allow-split ring buffer
|
|
static size_t prvGetCurMaxSizeAllowSplit(Ringbuffer_t *pxRingbuffer);
|
|
|
|
//Get the maximum size an item that can currently have if sent to a byte buffer
|
|
static size_t prvGetCurMaxSizeByteBuf(Ringbuffer_t *pxRingbuffer);
|
|
|
|
/**
|
|
* Generic function used to retrieve an item/data from ring buffers. If called on
|
|
* an allow-split buffer, and pvItem2 and xItemSize2 are not NULL, both parts of
|
|
* a split item will be retrieved. xMaxSize will only take effect if called on
|
|
* byte buffers.
|
|
*/
|
|
static BaseType_t prvReceiveGeneric(Ringbuffer_t *pxRingbuffer, void **pvItem1, void **pvItem2, size_t *xItemSize1, size_t *xItemSize2, size_t xMaxSize, TickType_t xTicksToWait);
|
|
|
|
//Generic function used to retrieve an item/data from ring buffers in an ISR
|
|
static BaseType_t prvReceiveGenericFromISR(Ringbuffer_t *pxRingbuffer, void **pvItem1, void **pvItem2, size_t *xItemSize1, size_t *xItemSize2, size_t xMaxSize);
|
|
|
|
/* ------------------------------------------------ Static Definitions ------------------------------------------- */
|
|
|
|
static size_t prvGetFreeSize(Ringbuffer_t *pxRingbuffer)
|
|
{
|
|
size_t xReturn;
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) {
|
|
xReturn = 0;
|
|
} else {
|
|
BaseType_t xFreeSize = pxRingbuffer->pucFree - pxRingbuffer->pucWrite;
|
|
//Check if xFreeSize has underflowed
|
|
if (xFreeSize <= 0) {
|
|
xFreeSize += pxRingbuffer->xSize;
|
|
}
|
|
xReturn = xFreeSize;
|
|
}
|
|
configASSERT(xReturn <= pxRingbuffer->xSize);
|
|
return xReturn;
|
|
}
|
|
|
|
static BaseType_t prvCheckItemFitsDefault( Ringbuffer_t *pxRingbuffer, size_t xItemSize)
|
|
{
|
|
//Check arguments and buffer state
|
|
configASSERT(rbCHECK_ALIGNED(pxRingbuffer->pucWrite)); //pucWrite is always aligned in no-split ring buffers
|
|
configASSERT(pxRingbuffer->pucWrite >= pxRingbuffer->pucHead && pxRingbuffer->pucWrite < pxRingbuffer->pucTail); //Check write pointer is within bounds
|
|
|
|
size_t xTotalItemSize = rbALIGN_SIZE(xItemSize) + rbHEADER_SIZE; //Rounded up aligned item size with header
|
|
if (pxRingbuffer->pucWrite == pxRingbuffer->pucFree) {
|
|
//Buffer is either complete empty or completely full
|
|
return (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) ? pdFALSE : pdTRUE;
|
|
}
|
|
if (pxRingbuffer->pucFree > pxRingbuffer->pucWrite) {
|
|
//Free space does not wrap around
|
|
return (xTotalItemSize <= pxRingbuffer->pucFree - pxRingbuffer->pucWrite) ? pdTRUE : pdFALSE;
|
|
}
|
|
//Free space wraps around
|
|
if (xTotalItemSize <= pxRingbuffer->pucTail - pxRingbuffer->pucWrite) {
|
|
return pdTRUE; //Item fits without wrapping around
|
|
}
|
|
//Check if item fits by wrapping
|
|
if (pxRingbuffer->uxRingbufferFlags & rbALLOW_SPLIT_FLAG) {
|
|
//Allow split wrapping incurs an extra header
|
|
return (xTotalItemSize + rbHEADER_SIZE <= pxRingbuffer->xSize - (pxRingbuffer->pucWrite - pxRingbuffer->pucFree)) ? pdTRUE : pdFALSE;
|
|
} else {
|
|
return (xTotalItemSize <= pxRingbuffer->pucFree - pxRingbuffer->pucHead) ? pdTRUE : pdFALSE;
|
|
}
|
|
}
|
|
|
|
static BaseType_t prvCheckItemFitsByteBuffer( Ringbuffer_t *pxRingbuffer, size_t xItemSize)
|
|
{
|
|
//Check arguments and buffer state
|
|
configASSERT(pxRingbuffer->pucWrite >= pxRingbuffer->pucHead && pxRingbuffer->pucWrite < pxRingbuffer->pucTail); //Check write pointer is within bounds
|
|
|
|
if (pxRingbuffer->pucWrite == pxRingbuffer->pucFree) {
|
|
//Buffer is either complete empty or completely full
|
|
return (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) ? pdFALSE : pdTRUE;
|
|
}
|
|
if (pxRingbuffer->pucFree > pxRingbuffer->pucWrite) {
|
|
//Free space does not wrap around
|
|
return (xItemSize <= pxRingbuffer->pucFree - pxRingbuffer->pucWrite) ? pdTRUE : pdFALSE;
|
|
}
|
|
//Free space wraps around
|
|
return (xItemSize <= pxRingbuffer->xSize - (pxRingbuffer->pucWrite - pxRingbuffer->pucFree)) ? pdTRUE : pdFALSE;
|
|
}
|
|
|
|
static void prvCopyItemNoSplit(Ringbuffer_t *pxRingbuffer, const uint8_t *pucItem, size_t xItemSize)
|
|
{
|
|
//Check arguments and buffer state
|
|
size_t xAlignedItemSize = rbALIGN_SIZE(xItemSize); //Rounded up aligned item size
|
|
size_t xRemLen = pxRingbuffer->pucTail - pxRingbuffer->pucWrite; //Length from pucWrite until end of buffer
|
|
configASSERT(rbCHECK_ALIGNED(pxRingbuffer->pucWrite)); //pucWrite is always aligned in no-split ring buffers
|
|
configASSERT(pxRingbuffer->pucWrite >= pxRingbuffer->pucHead && pxRingbuffer->pucWrite < pxRingbuffer->pucTail); //Check write pointer is within bounds
|
|
configASSERT(xRemLen >= rbHEADER_SIZE); //Remaining length must be able to at least fit an item header
|
|
|
|
//If remaining length can't fit item, set as dummy data and wrap around
|
|
if (xRemLen < xAlignedItemSize + rbHEADER_SIZE) {
|
|
ItemHeader_t *pxDummy = (ItemHeader_t *)pxRingbuffer->pucWrite;
|
|
pxDummy->uxItemFlags = rbITEM_DUMMY_DATA_FLAG; //Set remaining length as dummy data
|
|
pxDummy->xItemLen = 0; //Dummy data should have no length
|
|
pxRingbuffer->pucWrite = pxRingbuffer->pucHead; //Reset write pointer to wrap around
|
|
}
|
|
|
|
//Item should be guaranteed to fit at this point. Set item header and copy data
|
|
ItemHeader_t *pxHeader = (ItemHeader_t *)pxRingbuffer->pucWrite;
|
|
pxHeader->xItemLen = xItemSize;
|
|
pxHeader->uxItemFlags = 0;
|
|
pxRingbuffer->pucWrite += rbHEADER_SIZE; //Advance pucWrite past header
|
|
memcpy(pxRingbuffer->pucWrite, pucItem, xItemSize);
|
|
pxRingbuffer->xItemsWaiting++;
|
|
pxRingbuffer->pucWrite += xAlignedItemSize; //Advance pucWrite past item to next aligned address
|
|
|
|
//If current remaining length can't fit a header, wrap around write pointer
|
|
if (pxRingbuffer->pucTail - pxRingbuffer->pucWrite < rbHEADER_SIZE) {
|
|
pxRingbuffer->pucWrite = pxRingbuffer->pucHead; //Wrap around pucWrite
|
|
}
|
|
//Check if buffer is full
|
|
if (pxRingbuffer->pucWrite == pxRingbuffer->pucFree) {
|
|
//Mark the buffer as full to distinguish with an empty buffer
|
|
pxRingbuffer->uxRingbufferFlags |= rbBUFFER_FULL_FLAG;
|
|
}
|
|
}
|
|
|
|
static void prvCopyItemAllowSplit(Ringbuffer_t *pxRingbuffer, const uint8_t *pucItem, size_t xItemSize)
|
|
{
|
|
//Check arguments and buffer state
|
|
size_t xAlignedItemSize = rbALIGN_SIZE(xItemSize); //Rounded up aligned item size
|
|
size_t xRemLen = pxRingbuffer->pucTail - pxRingbuffer->pucWrite; //Length from pucWrite until end of buffer
|
|
configASSERT(rbCHECK_ALIGNED(pxRingbuffer->pucWrite)); //pucWrite is always aligned in split ring buffers
|
|
configASSERT(pxRingbuffer->pucWrite >= pxRingbuffer->pucHead && pxRingbuffer->pucWrite < pxRingbuffer->pucTail); //Check write pointer is within bounds
|
|
configASSERT(xRemLen >= rbHEADER_SIZE); //Remaining length must be able to at least fit an item header
|
|
|
|
//Split item if necessary
|
|
if (xRemLen < xAlignedItemSize + rbHEADER_SIZE) {
|
|
//Write first part of the item
|
|
ItemHeader_t *pxFirstHeader = (ItemHeader_t *)pxRingbuffer->pucWrite;
|
|
pxFirstHeader->uxItemFlags = 0;
|
|
pxFirstHeader->xItemLen = xRemLen - rbHEADER_SIZE; //Fill remaining length with first part
|
|
pxRingbuffer->pucWrite += rbHEADER_SIZE; //Advance pucWrite past header
|
|
xRemLen -= rbHEADER_SIZE;
|
|
if (xRemLen > 0) {
|
|
memcpy(pxRingbuffer->pucWrite, pucItem, xRemLen);
|
|
pxRingbuffer->xItemsWaiting++;
|
|
//Update item arguments to account for data already copied
|
|
pucItem += xRemLen;
|
|
xItemSize -= xRemLen;
|
|
xAlignedItemSize -= xRemLen;
|
|
pxFirstHeader->uxItemFlags |= rbITEM_SPLIT_FLAG; //There must be more data
|
|
} else {
|
|
//Remaining length was only large enough to fit header
|
|
pxFirstHeader->uxItemFlags |= rbITEM_DUMMY_DATA_FLAG; //Item will completely be stored in 2nd part
|
|
}
|
|
pxRingbuffer->pucWrite = pxRingbuffer->pucHead; //Reset write pointer to start of buffer
|
|
}
|
|
|
|
//Item (whole or second part) should be guaranteed to fit at this point
|
|
ItemHeader_t *pxSecondHeader = (ItemHeader_t *)pxRingbuffer->pucWrite;
|
|
pxSecondHeader->xItemLen = xItemSize;
|
|
pxSecondHeader->uxItemFlags = 0;
|
|
pxRingbuffer->pucWrite += rbHEADER_SIZE; //Advance write pointer past header
|
|
memcpy(pxRingbuffer->pucWrite, pucItem, xItemSize);
|
|
pxRingbuffer->xItemsWaiting++;
|
|
pxRingbuffer->pucWrite += xAlignedItemSize; //Advance pucWrite past item to next aligned address
|
|
|
|
//If current remaining length can't fit a header, wrap around write pointer
|
|
if (pxRingbuffer->pucTail - pxRingbuffer->pucWrite < rbHEADER_SIZE) {
|
|
pxRingbuffer->pucWrite = pxRingbuffer->pucHead; //Wrap around pucWrite
|
|
}
|
|
//Check if buffer is full
|
|
if (pxRingbuffer->pucWrite == pxRingbuffer->pucFree) {
|
|
//Mark the buffer as full to distinguish with an empty buffer
|
|
pxRingbuffer->uxRingbufferFlags |= rbBUFFER_FULL_FLAG;
|
|
}
|
|
}
|
|
|
|
static void prvCopyItemByteBuf(Ringbuffer_t *pxRingbuffer, const uint8_t *pucItem, size_t xItemSize)
|
|
{
|
|
//Check arguments and buffer state
|
|
configASSERT(pxRingbuffer->pucWrite >= pxRingbuffer->pucHead && pxRingbuffer->pucWrite < pxRingbuffer->pucTail); //Check write pointer is within bounds
|
|
|
|
size_t xRemLen = pxRingbuffer->pucTail - pxRingbuffer->pucWrite; //Length from pucWrite until end of buffer
|
|
if (xRemLen < xItemSize) {
|
|
//Copy as much as possible into remaining length
|
|
memcpy(pxRingbuffer->pucWrite, pucItem, xRemLen);
|
|
pxRingbuffer->xItemsWaiting += xRemLen;
|
|
//Update item arguments to account for data already written
|
|
pucItem += xRemLen;
|
|
xItemSize -= xRemLen;
|
|
pxRingbuffer->pucWrite = pxRingbuffer->pucHead; //Reset write pointer to start of buffer
|
|
}
|
|
//Copy all or remaining portion of the item
|
|
memcpy(pxRingbuffer->pucWrite, pucItem, xItemSize);
|
|
pxRingbuffer->xItemsWaiting += xItemSize;
|
|
pxRingbuffer->pucWrite += xItemSize;
|
|
|
|
//Wrap around pucWrite if it reaches the end
|
|
if (pxRingbuffer->pucWrite == pxRingbuffer->pucTail) {
|
|
pxRingbuffer->pucWrite = pxRingbuffer->pucHead;
|
|
}
|
|
//Check if buffer is full
|
|
if (pxRingbuffer->pucWrite == pxRingbuffer->pucFree) {
|
|
pxRingbuffer->uxRingbufferFlags |= rbBUFFER_FULL_FLAG; //Mark the buffer as full to avoid confusion with an empty buffer
|
|
}
|
|
}
|
|
|
|
static BaseType_t prvCheckItemAvail(Ringbuffer_t *pxRingbuffer)
|
|
{
|
|
if ((pxRingbuffer->uxRingbufferFlags & rbBYTE_BUFFER_FLAG) && pxRingbuffer->pucRead != pxRingbuffer->pucFree) {
|
|
return pdFALSE; //Byte buffers do not allow multiple retrievals before return
|
|
}
|
|
if ((pxRingbuffer->xItemsWaiting > 0) && ((pxRingbuffer->pucRead != pxRingbuffer->pucWrite) || (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG))) {
|
|
return pdTRUE; //Items/data available for retrieval
|
|
} else {
|
|
return pdFALSE; //No items/data available for retrieval
|
|
}
|
|
}
|
|
|
|
static void *prvGetItemDefault(Ringbuffer_t *pxRingbuffer, BaseType_t *pxIsSplit, size_t xUnusedParam, size_t *pxItemSize)
|
|
{
|
|
//Check arguments and buffer state
|
|
ItemHeader_t *pxHeader = (ItemHeader_t *)pxRingbuffer->pucRead;
|
|
configASSERT(pxIsSplit != NULL);
|
|
configASSERT((pxRingbuffer->xItemsWaiting > 0) && ((pxRingbuffer->pucRead != pxRingbuffer->pucWrite) || (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG))); //Check there are items to be read
|
|
configASSERT(rbCHECK_ALIGNED(pxRingbuffer->pucRead)); //pucRead is always aligned in split ring buffers
|
|
configASSERT(pxRingbuffer->pucRead >= pxRingbuffer->pucHead && pxRingbuffer->pucRead < pxRingbuffer->pucTail); //Check read pointer is within bounds
|
|
configASSERT((pxHeader->xItemLen <= pxRingbuffer->xMaxItemSize) || (pxHeader->uxItemFlags & rbITEM_DUMMY_DATA_FLAG));
|
|
|
|
uint8_t *pcReturn;
|
|
//Wrap around if dummy data (dummy data indicates wrap around in no-split buffers)
|
|
if (pxHeader->uxItemFlags & rbITEM_DUMMY_DATA_FLAG) {
|
|
pxRingbuffer->pucRead = pxRingbuffer->pucHead;
|
|
//Check for errors with the next item
|
|
pxHeader = (ItemHeader_t *)pxRingbuffer->pucRead;
|
|
configASSERT(pxHeader->xItemLen <= pxRingbuffer->xMaxItemSize);
|
|
}
|
|
pcReturn = pxRingbuffer->pucRead + rbHEADER_SIZE; //Get pointer to part of item containing data (point past the header)
|
|
if (pxHeader->xItemLen == 0) {
|
|
//Inclusive of pucTail for special case where item of zero length just fits at the end of the buffer
|
|
configASSERT(pcReturn >= pxRingbuffer->pucHead && pcReturn <= pxRingbuffer->pucTail);
|
|
} else {
|
|
//Exclusive of pucTali if length is larger than zero, pcReturn should never point to pucTail
|
|
configASSERT(pcReturn >= pxRingbuffer->pucHead && pcReturn < pxRingbuffer->pucTail);
|
|
}
|
|
*pxItemSize = pxHeader->xItemLen; //Get length of item
|
|
pxRingbuffer->xItemsWaiting --; //Update item count
|
|
*pxIsSplit = (pxHeader->uxItemFlags & rbITEM_SPLIT_FLAG) ? pdTRUE : pdFALSE;
|
|
|
|
pxRingbuffer->pucRead += rbHEADER_SIZE + rbALIGN_SIZE(pxHeader->xItemLen); //Update pucRead
|
|
//Check if pucRead requires wrap around
|
|
if ((pxRingbuffer->pucTail - pxRingbuffer->pucRead) < rbHEADER_SIZE) {
|
|
pxRingbuffer->pucRead = pxRingbuffer->pucHead;
|
|
}
|
|
return (void *)pcReturn;
|
|
}
|
|
|
|
static void *prvGetItemByteBuf(Ringbuffer_t *pxRingbuffer, BaseType_t *pxUnusedParam ,size_t xMaxSize, size_t *pxItemSize)
|
|
{
|
|
//Check arguments and buffer state
|
|
configASSERT((pxRingbuffer->xItemsWaiting > 0) && ((pxRingbuffer->pucRead != pxRingbuffer->pucWrite) || (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG))); //Check there are items to be read
|
|
configASSERT(pxRingbuffer->pucRead >= pxRingbuffer->pucHead && pxRingbuffer->pucRead < pxRingbuffer->pucTail); //Check read pointer is within bounds
|
|
configASSERT(pxRingbuffer->pucRead == pxRingbuffer->pucFree);
|
|
|
|
uint8_t *ret = pxRingbuffer->pucRead;
|
|
if ((pxRingbuffer->pucRead > pxRingbuffer->pucWrite) || (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG)) { //Available data wraps around
|
|
//Return contiguous piece from read pointer until buffer tail, or xMaxSize
|
|
if (xMaxSize == 0 || pxRingbuffer->pucTail - pxRingbuffer->pucRead <= xMaxSize) {
|
|
//All contiguous data from read pointer to tail
|
|
*pxItemSize = pxRingbuffer->pucTail - pxRingbuffer->pucRead;
|
|
pxRingbuffer->xItemsWaiting -= pxRingbuffer->pucTail - pxRingbuffer->pucRead;
|
|
pxRingbuffer->pucRead = pxRingbuffer->pucHead; //Wrap around read pointer
|
|
} else {
|
|
//Return xMaxSize amount of data
|
|
*pxItemSize = xMaxSize;
|
|
pxRingbuffer->xItemsWaiting -= xMaxSize;
|
|
pxRingbuffer->pucRead += xMaxSize; //Advance read pointer past retrieved data
|
|
}
|
|
} else { //Available data is contiguous between read and write pointer
|
|
if (xMaxSize == 0 || pxRingbuffer->pucWrite - pxRingbuffer->pucRead <= xMaxSize) {
|
|
//Return all contiguous data from read to write pointer
|
|
*pxItemSize = pxRingbuffer->pucWrite - pxRingbuffer->pucRead;
|
|
pxRingbuffer->xItemsWaiting -= pxRingbuffer->pucWrite - pxRingbuffer->pucRead;
|
|
pxRingbuffer->pucRead = pxRingbuffer->pucWrite;
|
|
} else {
|
|
//Return xMaxSize data from read pointer
|
|
*pxItemSize = xMaxSize;
|
|
pxRingbuffer->xItemsWaiting -= xMaxSize;
|
|
pxRingbuffer->pucRead += xMaxSize; //Advance read pointer past retrieved data
|
|
|
|
}
|
|
}
|
|
return (void *)ret;
|
|
}
|
|
|
|
static void prvReturnItemDefault(Ringbuffer_t *pxRingbuffer, uint8_t *pucItem)
|
|
{
|
|
//Check arguments and buffer state
|
|
configASSERT(rbCHECK_ALIGNED(pucItem));
|
|
configASSERT(pucItem >= pxRingbuffer->pucHead);
|
|
configASSERT(pucItem <= pxRingbuffer->pucTail); //Inclusive of pucTail in the case of zero length item at the very end
|
|
|
|
//Get and check header of the item
|
|
ItemHeader_t *pxCurHeader = (ItemHeader_t *)(pucItem - rbHEADER_SIZE);
|
|
configASSERT(pxCurHeader->xItemLen <= pxRingbuffer->xMaxItemSize);
|
|
configASSERT((pxCurHeader->uxItemFlags & rbITEM_DUMMY_DATA_FLAG) == 0); //Dummy items should never have been read
|
|
configASSERT((pxCurHeader->uxItemFlags & rbITEM_FREE_FLAG) == 0); //Indicates item has already been returned before
|
|
pxCurHeader->uxItemFlags &= ~rbITEM_SPLIT_FLAG; //Clear wrap flag if set (not strictly necessary)
|
|
pxCurHeader->uxItemFlags |= rbITEM_FREE_FLAG; //Mark as free
|
|
|
|
/*
|
|
* Items might not be returned in the order they were retrieved. Move the free pointer
|
|
* up to the next item that has not been marked as free (by free flag) or up
|
|
* till the read pointer. When advancing the free pointer, items that have already been
|
|
* freed or items with dummy data should be skipped over
|
|
*/
|
|
pxCurHeader = (ItemHeader_t *)pxRingbuffer->pucFree;
|
|
//Skip over Items that have already been freed or are dummy items
|
|
while (((pxCurHeader->uxItemFlags & rbITEM_FREE_FLAG) || (pxCurHeader->uxItemFlags & rbITEM_DUMMY_DATA_FLAG)) && pxRingbuffer->pucFree != pxRingbuffer->pucRead) {
|
|
if (pxCurHeader->uxItemFlags & rbITEM_DUMMY_DATA_FLAG) {
|
|
pxCurHeader->uxItemFlags |= rbITEM_FREE_FLAG; //Mark as freed (not strictly necessary but adds redundancy)
|
|
pxRingbuffer->pucFree = pxRingbuffer->pucHead; //Wrap around due to dummy data
|
|
} else {
|
|
//Item with data that has already been freed, advance free pointer past this item
|
|
size_t xAlignedItemSize = rbALIGN_SIZE(pxCurHeader->xItemLen);
|
|
pxRingbuffer->pucFree += xAlignedItemSize + rbHEADER_SIZE;
|
|
//Redundancy check to ensure free pointer has not overshot buffer bounds
|
|
configASSERT(pxRingbuffer->pucFree <= pxRingbuffer->pucHead + pxRingbuffer->xSize);
|
|
}
|
|
//Check if pucRead requires wrap around
|
|
if ((pxRingbuffer->pucTail - pxRingbuffer->pucFree) < rbHEADER_SIZE) {
|
|
pxRingbuffer->pucFree = pxRingbuffer->pucHead;
|
|
}
|
|
pxCurHeader = (ItemHeader_t *)pxRingbuffer->pucFree; //Update header to point to item
|
|
}
|
|
|
|
//Check if the buffer full flag should be reset
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) {
|
|
if (pxRingbuffer->pucFree != pxRingbuffer->pucWrite) {
|
|
pxRingbuffer->uxRingbufferFlags &= ~rbBUFFER_FULL_FLAG;
|
|
} else if (pxRingbuffer->pucFree == pxRingbuffer->pucWrite && pxRingbuffer->pucFree == pxRingbuffer->pucRead) {
|
|
//Special case where a full buffer is completely freed in one go
|
|
pxRingbuffer->uxRingbufferFlags &= ~rbBUFFER_FULL_FLAG;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void prvReturnItemByteBuf(Ringbuffer_t *pxRingbuffer, uint8_t *pucItem)
|
|
{
|
|
//Check pointer points to address inside buffer
|
|
configASSERT((uint8_t *)pucItem >= pxRingbuffer->pucHead);
|
|
configASSERT((uint8_t *)pucItem < pxRingbuffer->pucTail);
|
|
//Free the read memory. Simply moves free pointer to read pointer as byte buffers do not allow multiple outstanding reads
|
|
pxRingbuffer->pucFree = pxRingbuffer->pucRead;
|
|
//If buffer was full before, reset full flag as free pointer has moved
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) {
|
|
pxRingbuffer->uxRingbufferFlags &= ~rbBUFFER_FULL_FLAG;
|
|
}
|
|
}
|
|
|
|
static size_t prvGetCurMaxSizeNoSplit(Ringbuffer_t *pxRingbuffer)
|
|
{
|
|
BaseType_t xFreeSize;
|
|
//Check if buffer is full
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) {
|
|
return 0;
|
|
}
|
|
if (pxRingbuffer->pucWrite < pxRingbuffer->pucFree) {
|
|
//Free space is contiguous between pucWrite and pucFree
|
|
xFreeSize = pxRingbuffer->pucFree - pxRingbuffer->pucWrite;
|
|
} else {
|
|
//Free space wraps around (or overlapped at pucHead), select largest
|
|
//contiguous free space as no-split items require contiguous space
|
|
size_t xSize1 = pxRingbuffer->pucTail - pxRingbuffer->pucWrite;
|
|
size_t xSize2 = pxRingbuffer->pucFree - pxRingbuffer->pucHead;
|
|
xFreeSize = (xSize1 > xSize2) ? xSize1 : xSize2;
|
|
}
|
|
|
|
//No-split ring buffer items need space for a header
|
|
xFreeSize -= rbHEADER_SIZE;
|
|
//Limit free size to be within bounds
|
|
if (xFreeSize > pxRingbuffer->xMaxItemSize) {
|
|
xFreeSize = pxRingbuffer->xMaxItemSize;
|
|
} else if (xFreeSize < 0) {
|
|
//Occurs when free space is less than header size
|
|
xFreeSize = 0;
|
|
}
|
|
return xFreeSize;
|
|
}
|
|
|
|
static size_t prvGetCurMaxSizeAllowSplit(Ringbuffer_t *pxRingbuffer)
|
|
{
|
|
BaseType_t xFreeSize;
|
|
//Check if buffer is full
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) {
|
|
return 0;
|
|
}
|
|
if (pxRingbuffer->pucWrite == pxRingbuffer->pucHead && pxRingbuffer->pucFree == pxRingbuffer->pucHead) {
|
|
//Check for special case where pucWrite and pucFree are both at pucHead
|
|
xFreeSize = pxRingbuffer->xSize - rbHEADER_SIZE;
|
|
} else if (pxRingbuffer->pucWrite < pxRingbuffer->pucFree) {
|
|
//Free space is contiguous between pucWrite and pucFree, requires single header
|
|
xFreeSize = (pxRingbuffer->pucFree - pxRingbuffer->pucWrite) - rbHEADER_SIZE;
|
|
} else {
|
|
//Free space wraps around, requires two headers
|
|
xFreeSize = (pxRingbuffer->pucFree - pxRingbuffer->pucHead) +
|
|
(pxRingbuffer->pucTail - pxRingbuffer->pucWrite) -
|
|
(rbHEADER_SIZE * 2);
|
|
}
|
|
|
|
//Limit free size to be within bounds
|
|
if (xFreeSize > pxRingbuffer->xMaxItemSize) {
|
|
xFreeSize = pxRingbuffer->xMaxItemSize;
|
|
} else if (xFreeSize < 0) {
|
|
xFreeSize = 0;
|
|
}
|
|
return xFreeSize;
|
|
}
|
|
|
|
static size_t prvGetCurMaxSizeByteBuf(Ringbuffer_t *pxRingbuffer)
|
|
{
|
|
BaseType_t xFreeSize;
|
|
//Check if buffer is full
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBUFFER_FULL_FLAG) {
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Return whatever space is available depending on relative positions of the free
|
|
* pointer and write pointer. There is no overhead of headers in this mode
|
|
*/
|
|
xFreeSize = pxRingbuffer->pucFree - pxRingbuffer->pucWrite;
|
|
if (xFreeSize <= 0) {
|
|
xFreeSize += pxRingbuffer->xSize;
|
|
}
|
|
return xFreeSize;
|
|
}
|
|
|
|
static BaseType_t prvReceiveGeneric(Ringbuffer_t *pxRingbuffer, void **pvItem1, void **pvItem2, size_t *xItemSize1, size_t *xItemSize2, size_t xMaxSize, TickType_t xTicksToWait)
|
|
{
|
|
BaseType_t xReturn = pdFALSE;
|
|
BaseType_t xReturnSemaphore = pdFALSE;
|
|
TickType_t xTicksEnd = xTaskGetTickCount() + xTicksToWait;
|
|
TickType_t xTicksRemaining = xTicksToWait;
|
|
while (xTicksRemaining <= xTicksToWait) { //xTicksToWait will underflow once xTaskGetTickCount() > ticks_end
|
|
//Block until more free space becomes available or timeout
|
|
if (xSemaphoreTake(pxRingbuffer->xItemsBufferedSemaphore, xTicksRemaining) != pdTRUE) {
|
|
xReturn = pdFALSE; //Timed out attempting to get semaphore
|
|
break;
|
|
}
|
|
|
|
//Semaphore obtained, check if item can be retrieved
|
|
taskENTER_CRITICAL(&pxRingbuffer->mux);
|
|
if (prvCheckItemAvail(pxRingbuffer) == pdTRUE) {
|
|
//Item is available for retrieval
|
|
BaseType_t xIsSplit;
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBYTE_BUFFER_FLAG) {
|
|
//Second argument (pxIsSplit) is unused for byte buffers
|
|
*pvItem1 = pxRingbuffer->pvGetItem(pxRingbuffer, NULL, xMaxSize, xItemSize1);
|
|
} else {
|
|
//Third argument (xMaxSize) is unused for no-split/allow-split buffers
|
|
*pvItem1 = pxRingbuffer->pvGetItem(pxRingbuffer, &xIsSplit, 0, xItemSize1);
|
|
}
|
|
//Check for item split if configured to do so
|
|
if ((pxRingbuffer->uxRingbufferFlags & rbALLOW_SPLIT_FLAG) && (pvItem2 != NULL) && (xItemSize2 != NULL)) {
|
|
if (xIsSplit == pdTRUE) {
|
|
*pvItem2 = pxRingbuffer->pvGetItem(pxRingbuffer, &xIsSplit, 0, xItemSize2);
|
|
configASSERT(*pvItem2 < *pvItem1); //Check wrap around has occurred
|
|
configASSERT(xIsSplit == pdFALSE); //Second part should not have wrapped flag
|
|
} else {
|
|
*pvItem2 = NULL;
|
|
}
|
|
}
|
|
xReturn = pdTRUE;
|
|
if (pxRingbuffer->xItemsWaiting > 0) {
|
|
xReturnSemaphore = pdTRUE;
|
|
}
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
break;
|
|
}
|
|
//No item available for retrieval, adjust ticks and take the semaphore again
|
|
if (xTicksToWait != portMAX_DELAY) {
|
|
xTicksRemaining = xTicksEnd - xTaskGetTickCount();
|
|
}
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
/*
|
|
* Gap between critical section and re-acquiring of the semaphore. If
|
|
* semaphore is given now, priority inversion might occur (see docs)
|
|
*/
|
|
}
|
|
|
|
if (xReturnSemaphore == pdTRUE) {
|
|
xSemaphoreGive(pxRingbuffer->xItemsBufferedSemaphore); //Give semaphore back so other tasks can retrieve
|
|
}
|
|
return xReturn;
|
|
}
|
|
|
|
static BaseType_t prvReceiveGenericFromISR(Ringbuffer_t *pxRingbuffer, void **pvItem1, void **pvItem2, size_t *xItemSize1, size_t *xItemSize2, size_t xMaxSize)
|
|
{
|
|
BaseType_t xReturn = pdFALSE;
|
|
BaseType_t xReturnSemaphore = pdFALSE;
|
|
|
|
taskENTER_CRITICAL_ISR(&pxRingbuffer->mux);
|
|
if(prvCheckItemAvail(pxRingbuffer) == pdTRUE) {
|
|
BaseType_t xIsSplit;
|
|
if (pxRingbuffer->uxRingbufferFlags & rbBYTE_BUFFER_FLAG) {
|
|
//Second argument (pxIsSplit) is unused for byte buffers
|
|
*pvItem1 = pxRingbuffer->pvGetItem(pxRingbuffer, NULL, xMaxSize, xItemSize1);
|
|
} else {
|
|
//Third argument (xMaxSize) is unused for no-split/allow-split buffers
|
|
*pvItem1 = pxRingbuffer->pvGetItem(pxRingbuffer, &xIsSplit, 0, xItemSize1);
|
|
}
|
|
//Check for item split if configured to do so
|
|
if ((pxRingbuffer->uxRingbufferFlags & rbALLOW_SPLIT_FLAG) && pvItem2 != NULL && xItemSize2 != NULL) {
|
|
if (xIsSplit == pdTRUE) {
|
|
*pvItem2 = pxRingbuffer->pvGetItem(pxRingbuffer, &xIsSplit, 0, xItemSize2);
|
|
configASSERT(*pvItem2 < *pvItem1); //Check wrap around has occurred
|
|
configASSERT(xIsSplit == pdFALSE); //Second part should not have wrapped flag
|
|
} else {
|
|
*pvItem2 = NULL;
|
|
}
|
|
}
|
|
xReturn = pdTRUE;
|
|
if (pxRingbuffer->xItemsWaiting > 0) {
|
|
xReturnSemaphore = pdTRUE;
|
|
}
|
|
}
|
|
taskEXIT_CRITICAL_ISR(&pxRingbuffer->mux);
|
|
|
|
if (xReturnSemaphore == pdTRUE) {
|
|
xSemaphoreGiveFromISR(pxRingbuffer->xItemsBufferedSemaphore, NULL); //Give semaphore back so other tasks can retrieve
|
|
}
|
|
return xReturn;
|
|
}
|
|
|
|
/* ------------------------------------------------- Public Definitions -------------------------------------------- */
|
|
|
|
RingbufHandle_t xRingbufferCreate(size_t xBufferSize, ringbuf_type_t xBufferType)
|
|
{
|
|
//Allocate memory
|
|
Ringbuffer_t *pxRingbuffer = calloc(1, sizeof(Ringbuffer_t));
|
|
if (pxRingbuffer == NULL) {
|
|
goto err;
|
|
}
|
|
if (xBufferType != RINGBUF_TYPE_BYTEBUF) {
|
|
xBufferSize = rbALIGN_SIZE(xBufferSize); //xBufferSize is rounded up for no-split/allow-split buffers
|
|
}
|
|
pxRingbuffer->pucHead = malloc(xBufferSize);
|
|
if (pxRingbuffer->pucHead == NULL) {
|
|
goto err;
|
|
}
|
|
|
|
//Initialize values
|
|
pxRingbuffer->xSize = xBufferSize;
|
|
pxRingbuffer->pucTail = pxRingbuffer->pucHead + xBufferSize;
|
|
pxRingbuffer->pucFree = pxRingbuffer->pucHead;
|
|
pxRingbuffer->pucRead = pxRingbuffer->pucHead;
|
|
pxRingbuffer->pucWrite = pxRingbuffer->pucHead;
|
|
pxRingbuffer->xItemsWaiting = 0;
|
|
pxRingbuffer->xFreeSpaceSemaphore = xSemaphoreCreateBinary();
|
|
pxRingbuffer->xItemsBufferedSemaphore = xSemaphoreCreateBinary();
|
|
pxRingbuffer->uxRingbufferFlags = 0;
|
|
|
|
//Initialize type dependent values and function pointers
|
|
if (xBufferType == RINGBUF_TYPE_NOSPLIT) {
|
|
pxRingbuffer->xCheckItemFits = prvCheckItemFitsDefault;
|
|
pxRingbuffer->vCopyItem = prvCopyItemNoSplit;
|
|
pxRingbuffer->pvGetItem = prvGetItemDefault;
|
|
pxRingbuffer->vReturnItem = prvReturnItemDefault;
|
|
/*
|
|
* Buffer lengths are always aligned. No-split buffer (read/write/free)
|
|
* pointers are also always aligned. Therefore worse case scenario is
|
|
* the write pointer is at the most aligned halfway point.
|
|
*/
|
|
pxRingbuffer->xMaxItemSize = rbALIGN_SIZE(pxRingbuffer->xSize / 2) - rbHEADER_SIZE;
|
|
pxRingbuffer->xGetCurMaxSize = prvGetCurMaxSizeNoSplit;
|
|
} else if (xBufferType == RINGBUF_TYPE_ALLOWSPLIT) {
|
|
pxRingbuffer->uxRingbufferFlags |= rbALLOW_SPLIT_FLAG;
|
|
pxRingbuffer->xCheckItemFits = prvCheckItemFitsDefault;
|
|
pxRingbuffer->vCopyItem = prvCopyItemAllowSplit;
|
|
pxRingbuffer->pvGetItem = prvGetItemDefault;
|
|
pxRingbuffer->vReturnItem = prvReturnItemDefault;
|
|
//Worst case an item is split into two, incurring two headers of overhead
|
|
pxRingbuffer->xMaxItemSize = pxRingbuffer->xSize - (sizeof(ItemHeader_t) * 2);
|
|
pxRingbuffer->xGetCurMaxSize = prvGetCurMaxSizeAllowSplit;
|
|
} else if (xBufferType == RINGBUF_TYPE_BYTEBUF) {
|
|
pxRingbuffer->uxRingbufferFlags |= rbBYTE_BUFFER_FLAG;
|
|
pxRingbuffer->xCheckItemFits = prvCheckItemFitsByteBuffer;
|
|
pxRingbuffer->vCopyItem = prvCopyItemByteBuf;
|
|
pxRingbuffer->pvGetItem = prvGetItemByteBuf;
|
|
pxRingbuffer->vReturnItem = prvReturnItemByteBuf;
|
|
//Byte buffers do not incur any overhead
|
|
pxRingbuffer->xMaxItemSize = pxRingbuffer->xSize;
|
|
pxRingbuffer->xGetCurMaxSize = prvGetCurMaxSizeByteBuf;
|
|
} else {
|
|
//Unsupported type
|
|
configASSERT(0);
|
|
}
|
|
|
|
if (pxRingbuffer->xFreeSpaceSemaphore == NULL || pxRingbuffer->xItemsBufferedSemaphore == NULL) {
|
|
goto err;
|
|
}
|
|
xSemaphoreGive(pxRingbuffer->xFreeSpaceSemaphore);
|
|
vPortCPUInitializeMutex(&pxRingbuffer->mux);
|
|
|
|
return (RingbufHandle_t)pxRingbuffer;
|
|
|
|
err:
|
|
//Some error has happened. Free/destroy all allocated things and return NULL.
|
|
if (pxRingbuffer) {
|
|
free(pxRingbuffer->pucHead);
|
|
if (pxRingbuffer->xFreeSpaceSemaphore) {
|
|
vSemaphoreDelete(pxRingbuffer->xFreeSpaceSemaphore);
|
|
}
|
|
if (pxRingbuffer->xItemsBufferedSemaphore) {
|
|
vSemaphoreDelete(pxRingbuffer->xItemsBufferedSemaphore);
|
|
}
|
|
}
|
|
free(pxRingbuffer);
|
|
return NULL;
|
|
}
|
|
|
|
RingbufHandle_t xRingbufferCreateNoSplit(size_t xItemSize, size_t xItemNum)
|
|
{
|
|
return xRingbufferCreate((rbALIGN_SIZE(xItemSize) + rbHEADER_SIZE) * xItemNum, RINGBUF_TYPE_NOSPLIT);
|
|
}
|
|
|
|
BaseType_t xRingbufferSend(RingbufHandle_t xRingbuffer, const void *pvItem, size_t xItemSize, TickType_t xTicksToWait)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pvItem != NULL || xItemSize == 0);
|
|
if (xItemSize > pxRingbuffer->xMaxItemSize) {
|
|
return pdFALSE; //Data will never ever fit in the queue.
|
|
}
|
|
if ((pxRingbuffer->uxRingbufferFlags & rbBYTE_BUFFER_FLAG) && xItemSize == 0) {
|
|
return pdTRUE; //Sending 0 bytes to byte buffer has no effect
|
|
}
|
|
|
|
//Attempt to send an item
|
|
BaseType_t xReturn = pdFALSE;
|
|
BaseType_t xReturnSemaphore = pdFALSE;
|
|
TickType_t xTicksEnd = xTaskGetTickCount() + xTicksToWait;
|
|
TickType_t xTicksRemaining = xTicksToWait;
|
|
while (xTicksRemaining <= xTicksToWait) { //xTicksToWait will underflow once xTaskGetTickCount() > ticks_end
|
|
//Block until more free space becomes available or timeout
|
|
if (xSemaphoreTake(pxRingbuffer->xFreeSpaceSemaphore, xTicksRemaining) != pdTRUE) {
|
|
xReturn = pdFALSE;
|
|
break;
|
|
}
|
|
//Semaphore obtained, check if item can fit
|
|
taskENTER_CRITICAL(&pxRingbuffer->mux);
|
|
if(pxRingbuffer->xCheckItemFits(pxRingbuffer, xItemSize) == pdTRUE) {
|
|
//Item will fit, copy item
|
|
pxRingbuffer->vCopyItem(pxRingbuffer, pvItem, xItemSize);
|
|
xReturn = pdTRUE;
|
|
//Check if the free semaphore should be returned to allow other tasks to send
|
|
if (prvGetFreeSize(pxRingbuffer) > 0) {
|
|
xReturnSemaphore = pdTRUE;
|
|
}
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
break;
|
|
}
|
|
//Item doesn't fit, adjust ticks and take the semaphore again
|
|
if (xTicksToWait != portMAX_DELAY) {
|
|
xTicksRemaining = xTicksEnd - xTaskGetTickCount();
|
|
}
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
/*
|
|
* Gap between critical section and re-acquiring of the semaphore. If
|
|
* semaphore is given now, priority inversion might occur (see docs)
|
|
*/
|
|
}
|
|
|
|
if (xReturn == pdTRUE) {
|
|
//Indicate item was successfully sent
|
|
xSemaphoreGive(pxRingbuffer->xItemsBufferedSemaphore);
|
|
}
|
|
if (xReturnSemaphore == pdTRUE) {
|
|
xSemaphoreGive(pxRingbuffer->xFreeSpaceSemaphore); //Give back semaphore so other tasks can send
|
|
}
|
|
return xReturn;
|
|
}
|
|
|
|
BaseType_t xRingbufferSendFromISR(RingbufHandle_t xRingbuffer, const void *pvItem, size_t xItemSize, BaseType_t *pxHigherPriorityTaskWoken)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pvItem != NULL || xItemSize == 0);
|
|
if (xItemSize > pxRingbuffer->xMaxItemSize) {
|
|
return pdFALSE; //Data will never ever fit in the queue.
|
|
}
|
|
if ((pxRingbuffer->uxRingbufferFlags & rbBYTE_BUFFER_FLAG) && xItemSize == 0) {
|
|
return pdTRUE; //Sending 0 bytes to byte buffer has no effect
|
|
}
|
|
|
|
//Attempt to send an item
|
|
BaseType_t xReturn;
|
|
BaseType_t xReturnSemaphore = pdFALSE;
|
|
taskENTER_CRITICAL_ISR(&pxRingbuffer->mux);
|
|
if (pxRingbuffer->xCheckItemFits(xRingbuffer, xItemSize) == pdTRUE) {
|
|
pxRingbuffer->vCopyItem(xRingbuffer, pvItem, xItemSize);
|
|
xReturn = pdTRUE;
|
|
//Check if the free semaphore should be returned to allow other tasks to send
|
|
if (prvGetFreeSize(pxRingbuffer) > 0) {
|
|
xReturnSemaphore = pdTRUE;
|
|
}
|
|
} else {
|
|
xReturn = pdFALSE;
|
|
}
|
|
taskEXIT_CRITICAL_ISR(&pxRingbuffer->mux);
|
|
|
|
if (xReturn == pdTRUE) {
|
|
//Indicate item was successfully sent
|
|
xSemaphoreGiveFromISR(pxRingbuffer->xItemsBufferedSemaphore, pxHigherPriorityTaskWoken);
|
|
}
|
|
if (xReturnSemaphore == pdTRUE) {
|
|
xSemaphoreGiveFromISR(pxRingbuffer->xFreeSpaceSemaphore, pxHigherPriorityTaskWoken); //Give back semaphore so other tasks can send
|
|
}
|
|
return xReturn;
|
|
}
|
|
|
|
void *xRingbufferReceive(RingbufHandle_t xRingbuffer, size_t *pxItemSize, TickType_t xTicksToWait)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
//Attempt to retrieve an item
|
|
void *pvTempItem;
|
|
size_t xTempSize;
|
|
if (prvReceiveGeneric(pxRingbuffer, &pvTempItem, NULL, &xTempSize, NULL, 0, xTicksToWait) == pdTRUE) {
|
|
if (pxItemSize != NULL) {
|
|
*pxItemSize = xTempSize;
|
|
}
|
|
return pvTempItem;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void *xRingbufferReceiveFromISR(RingbufHandle_t xRingbuffer, size_t *pxItemSize)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
//Attempt to retrieve an item
|
|
void *pvTempItem;
|
|
size_t xTempSize;
|
|
if (prvReceiveGenericFromISR(pxRingbuffer, &pvTempItem, NULL, &xTempSize, NULL, 0) == pdTRUE) {
|
|
if (pxItemSize != NULL) {
|
|
*pxItemSize = xTempSize;
|
|
}
|
|
return pvTempItem;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
BaseType_t xRingbufferReceiveSplit(RingbufHandle_t xRingbuffer, void **ppvHeadItem, void **ppvTailItem, size_t *pxHeadItemSize, size_t *pxTailItemSize, TickType_t xTicksToWait)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pxRingbuffer->uxRingbufferFlags & rbALLOW_SPLIT_FLAG);
|
|
configASSERT(ppvHeadItem != NULL && ppvTailItem != NULL);
|
|
|
|
//Attempt to retrieve multiple items
|
|
void *pvTempHeadItem, *pvTempTailItem;
|
|
size_t xTempHeadSize, xTempTailSize;
|
|
if (prvReceiveGeneric(pxRingbuffer, &pvTempHeadItem, &pvTempTailItem, &xTempHeadSize, &xTempTailSize, 0, xTicksToWait) == pdTRUE) {
|
|
//At least one item was retrieved
|
|
*ppvHeadItem = pvTempHeadItem;
|
|
if(pxHeadItemSize != NULL){
|
|
*pxHeadItemSize = xTempHeadSize;
|
|
}
|
|
//Check to see if a second item was also retrieved
|
|
if (pvTempTailItem != NULL) {
|
|
*ppvTailItem = pvTempTailItem;
|
|
if (pxTailItemSize != NULL) {
|
|
*pxTailItemSize = xTempTailSize;
|
|
}
|
|
} else {
|
|
*ppvTailItem = NULL;
|
|
}
|
|
return pdTRUE;
|
|
} else {
|
|
//No items retrieved
|
|
*ppvHeadItem = NULL;
|
|
*ppvTailItem = NULL;
|
|
return pdFALSE;
|
|
}
|
|
}
|
|
|
|
BaseType_t xRingbufferReceiveSplitFromISR(RingbufHandle_t xRingbuffer, void **ppvHeadItem, void **ppvTailItem, size_t *pxHeadItemSize, size_t *pxTailItemSize)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pxRingbuffer->uxRingbufferFlags & rbALLOW_SPLIT_FLAG);
|
|
configASSERT(ppvHeadItem != NULL && ppvTailItem != NULL);
|
|
|
|
//Attempt to retrieve multiple items
|
|
void *pvTempHeadItem, *pvTempTailItem;
|
|
size_t xTempHeadSize, xTempTailSize;
|
|
if (prvReceiveGenericFromISR(pxRingbuffer, &pvTempHeadItem, &pvTempTailItem, &xTempHeadSize, &xTempTailSize, 0) == pdTRUE) {
|
|
//At least one item was received
|
|
*ppvHeadItem = pvTempHeadItem;
|
|
if (pxHeadItemSize != NULL) {
|
|
*pxHeadItemSize = xTempHeadSize;
|
|
}
|
|
//Check to see if a second item was also retrieved
|
|
if (pvTempTailItem != NULL) {
|
|
*ppvTailItem = pvTempTailItem;
|
|
if (pxTailItemSize != NULL) {
|
|
*pxTailItemSize = xTempTailSize;
|
|
}
|
|
} else {
|
|
*ppvTailItem = NULL;
|
|
}
|
|
return pdTRUE;
|
|
} else {
|
|
*ppvHeadItem = NULL;
|
|
*ppvTailItem = NULL;
|
|
return pdFALSE;
|
|
}
|
|
}
|
|
|
|
void *xRingbufferReceiveUpTo(RingbufHandle_t xRingbuffer, size_t *pxItemSize, TickType_t xTicksToWait, size_t xMaxSize)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pxRingbuffer->uxRingbufferFlags & rbBYTE_BUFFER_FLAG); //This function should only be called for byte buffers
|
|
if (xMaxSize == 0) {
|
|
return NULL;
|
|
}
|
|
|
|
//Attempt to retrieve up to xMaxSize bytes
|
|
void *pvTempItem;
|
|
size_t xTempSize;
|
|
if (prvReceiveGeneric(pxRingbuffer, &pvTempItem, NULL, &xTempSize, NULL, xMaxSize, xTicksToWait) == pdTRUE) {
|
|
if (pxItemSize != NULL) {
|
|
*pxItemSize = xTempSize;
|
|
}
|
|
return pvTempItem;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void *xRingbufferReceiveUpToFromISR(RingbufHandle_t xRingbuffer, size_t *pxItemSize, size_t xMaxSize)
|
|
{
|
|
//Check arguments
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pxRingbuffer->uxRingbufferFlags & rbBYTE_BUFFER_FLAG); //This function should only be called for byte buffers
|
|
if (xMaxSize == 0) {
|
|
return NULL;
|
|
}
|
|
|
|
//Attempt to retrieve up to xMaxSize bytes
|
|
void *pvTempItem;
|
|
size_t xTempSize;
|
|
if (prvReceiveGenericFromISR(pxRingbuffer, &pvTempItem, NULL, &xTempSize, NULL, xMaxSize) == pdTRUE) {
|
|
if (pxItemSize != NULL) {
|
|
*pxItemSize = xTempSize;
|
|
}
|
|
return pvTempItem;
|
|
} else {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void vRingbufferReturnItem(RingbufHandle_t xRingbuffer, void *pvItem)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pvItem != NULL);
|
|
|
|
taskENTER_CRITICAL(&pxRingbuffer->mux);
|
|
pxRingbuffer->vReturnItem(pxRingbuffer, (uint8_t *)pvItem);
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
xSemaphoreGive(pxRingbuffer->xFreeSpaceSemaphore);
|
|
}
|
|
|
|
void vRingbufferReturnItemFromISR(RingbufHandle_t xRingbuffer, void *pvItem, BaseType_t *pxHigherPriorityTaskWoken)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
configASSERT(pvItem != NULL);
|
|
|
|
taskENTER_CRITICAL_ISR(&pxRingbuffer->mux);
|
|
pxRingbuffer->vReturnItem(pxRingbuffer, (uint8_t *)pvItem);
|
|
taskEXIT_CRITICAL_ISR(&pxRingbuffer->mux);
|
|
xSemaphoreGiveFromISR(pxRingbuffer->xFreeSpaceSemaphore, pxHigherPriorityTaskWoken);
|
|
}
|
|
|
|
void vRingbufferDelete(RingbufHandle_t xRingbuffer)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
if (pxRingbuffer) {
|
|
free(pxRingbuffer->pucHead);
|
|
if (pxRingbuffer->xFreeSpaceSemaphore) {
|
|
vSemaphoreDelete(pxRingbuffer->xFreeSpaceSemaphore);
|
|
}
|
|
if (pxRingbuffer->xItemsBufferedSemaphore) {
|
|
vSemaphoreDelete(pxRingbuffer->xItemsBufferedSemaphore);
|
|
}
|
|
}
|
|
free(pxRingbuffer);
|
|
}
|
|
|
|
size_t xRingbufferGetMaxItemSize(RingbufHandle_t xRingbuffer)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
return pxRingbuffer->xMaxItemSize;
|
|
}
|
|
|
|
size_t xRingbufferGetCurFreeSize(RingbufHandle_t xRingbuffer)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
size_t xFreeSize;
|
|
taskENTER_CRITICAL(&pxRingbuffer->mux);
|
|
xFreeSize = pxRingbuffer->xGetCurMaxSize(pxRingbuffer);
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
return xFreeSize;
|
|
}
|
|
|
|
BaseType_t xRingbufferAddToQueueSetRead(RingbufHandle_t xRingbuffer, QueueSetHandle_t xQueueSet)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
BaseType_t xReturn;
|
|
taskENTER_CRITICAL(&pxRingbuffer->mux);
|
|
//Cannot add semaphore to queue set if semaphore is not empty. Temporarily hold semaphore
|
|
BaseType_t xHoldSemaphore = xSemaphoreTake(pxRingbuffer->xItemsBufferedSemaphore, 0);
|
|
xReturn = xQueueAddToSet(pxRingbuffer->xItemsBufferedSemaphore, xQueueSet);
|
|
if (xHoldSemaphore == pdTRUE) {
|
|
//Return semaphore if temporarily held
|
|
configASSERT(xSemaphoreGive(pxRingbuffer->xItemsBufferedSemaphore) == pdTRUE);
|
|
}
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
return xReturn;
|
|
}
|
|
|
|
BaseType_t xRingbufferCanRead(RingbufHandle_t xRingbuffer, QueueSetMemberHandle_t xMember)
|
|
{
|
|
//Check if the selected queue set member is the ring buffer's read semaphore
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
return (pxRingbuffer->xItemsBufferedSemaphore == xMember) ? pdTRUE : pdFALSE;
|
|
}
|
|
|
|
BaseType_t xRingbufferRemoveFromQueueSetRead(RingbufHandle_t xRingbuffer, QueueSetHandle_t xQueueSet)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
BaseType_t xReturn;
|
|
taskENTER_CRITICAL(&pxRingbuffer->mux);
|
|
//Cannot remove semaphore from queue set if semaphore is not empty. Temporarily hold semaphore
|
|
BaseType_t xHoldSemaphore = xSemaphoreTake(pxRingbuffer->xItemsBufferedSemaphore, 0);
|
|
xReturn = xQueueRemoveFromSet(pxRingbuffer->xItemsBufferedSemaphore, xQueueSet);
|
|
if (xHoldSemaphore == pdTRUE) {
|
|
//Return semaphore if temporarily held
|
|
configASSERT(xSemaphoreGive(pxRingbuffer->xItemsBufferedSemaphore) == pdTRUE);
|
|
}
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
return xReturn;
|
|
}
|
|
|
|
void vRingbufferGetInfo(RingbufHandle_t xRingbuffer, UBaseType_t *uxFree, UBaseType_t *uxRead, UBaseType_t *uxWrite, UBaseType_t *uxItemsWaiting)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
taskENTER_CRITICAL(&pxRingbuffer->mux);
|
|
if (uxFree != NULL) {
|
|
*uxFree = (UBaseType_t)(pxRingbuffer->pucFree - pxRingbuffer->pucHead);
|
|
}
|
|
if (uxRead != NULL) {
|
|
*uxRead = (UBaseType_t)(pxRingbuffer->pucRead - pxRingbuffer->pucHead);
|
|
}
|
|
if (uxWrite != NULL) {
|
|
*uxWrite = (UBaseType_t)(pxRingbuffer->pucWrite - pxRingbuffer->pucHead);
|
|
}
|
|
if (uxItemsWaiting != NULL) {
|
|
*uxItemsWaiting = (UBaseType_t)(pxRingbuffer->xItemsWaiting);
|
|
}
|
|
taskEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
}
|
|
|
|
void xRingbufferPrintInfo(RingbufHandle_t xRingbuffer)
|
|
{
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
printf("Rb size:%d\tfree: %d\trptr: %d\tfreeptr: %d\twptr: %d\n",
|
|
pxRingbuffer->xSize, prvGetFreeSize(pxRingbuffer),
|
|
pxRingbuffer->pucRead - pxRingbuffer->pucHead,
|
|
pxRingbuffer->pucFree - pxRingbuffer->pucHead,
|
|
pxRingbuffer->pucWrite - pxRingbuffer->pucHead);
|
|
}
|
|
|
|
/* --------------------------------- Deprecated Functions ------------------------------ */
|
|
//Todo: Remove the following deprecated functions in next release
|
|
|
|
bool xRingbufferIsNextItemWrapped(RingbufHandle_t xRingbuffer)
|
|
{
|
|
//This function is deprecated, use xRingbufferReceiveSplit() instead
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
bool is_wrapped;
|
|
|
|
portENTER_CRITICAL(&pxRingbuffer->mux);
|
|
ItemHeader_t *xHeader = (ItemHeader_t *)pxRingbuffer->pucRead;
|
|
is_wrapped = xHeader->uxItemFlags & rbITEM_SPLIT_FLAG;
|
|
portEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
return is_wrapped;
|
|
}
|
|
|
|
BaseType_t xRingbufferAddToQueueSetWrite(RingbufHandle_t xRingbuffer, QueueSetHandle_t xQueueSet)
|
|
{
|
|
//This function is deprecated. QueueSetWrite no longer supported
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
BaseType_t xReturn;
|
|
portENTER_CRITICAL(&pxRingbuffer->mux);
|
|
//Cannot add semaphore to queue set if semaphore is not empty. Temporary hold semaphore
|
|
BaseType_t xHoldSemaphore = xSemaphoreTake(pxRingbuffer->xFreeSpaceSemaphore, 0);
|
|
xReturn = xQueueAddToSet(pxRingbuffer->xFreeSpaceSemaphore, xQueueSet);
|
|
if (xHoldSemaphore == pdTRUE) {
|
|
//Return semaphore is temporarily held
|
|
configASSERT(xSemaphoreGive(pxRingbuffer->xFreeSpaceSemaphore) == pdTRUE);
|
|
}
|
|
portEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
return xReturn;
|
|
}
|
|
|
|
BaseType_t xRingbufferRemoveFromQueueSetWrite(RingbufHandle_t xRingbuffer, QueueSetHandle_t xQueueSet)
|
|
{
|
|
//This function is deprecated. QueueSetWrite no longer supported
|
|
Ringbuffer_t *pxRingbuffer = (Ringbuffer_t *)xRingbuffer;
|
|
configASSERT(pxRingbuffer);
|
|
|
|
BaseType_t xReturn;
|
|
portENTER_CRITICAL(&pxRingbuffer->mux);
|
|
//Cannot remove semaphore from queue set if semaphore is not empty. Temporary hold semaphore
|
|
BaseType_t xHoldSemaphore = xSemaphoreTake(pxRingbuffer->xFreeSpaceSemaphore, 0);
|
|
xReturn = xQueueRemoveFromSet(pxRingbuffer->xFreeSpaceSemaphore, xQueueSet);
|
|
if (xHoldSemaphore == pdTRUE) {
|
|
//Return semaphore is temporarily held
|
|
configASSERT(xSemaphoreGive(pxRingbuffer->xFreeSpaceSemaphore) == pdTRUE);
|
|
}
|
|
portEXIT_CRITICAL(&pxRingbuffer->mux);
|
|
return xReturn;
|
|
}
|
|
|