mirror of
https://github.com/espressif/arduino-esp32
synced 2024-09-21 18:38:17 +00:00
d59efdcecd
* Rework cbuf to use FreeRTOS Ringbuffer * Update cbuf.cpp * Fix typo * Initialize with NULL * Implement peek method * Add initializer --------- Co-authored-by: Lucas Saavedra Vaz <lucas.vaz@espressif.com> Co-authored-by: Lucas Saavedra Vaz <32426024+lucasssvaz@users.noreply.github.com>
291 lines
7.4 KiB
C++
291 lines
7.4 KiB
C++
/*
|
|
cbuf.cpp - Circular buffer implementation
|
|
Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
|
|
This file is part of the esp8266 core for Arduino environment.
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "cbuf.h"
|
|
#include "esp32-hal-log.h"
|
|
|
|
#if CONFIG_DISABLE_HAL_LOCKS
|
|
#define CBUF_MUTEX_CREATE()
|
|
#define CBUF_MUTEX_LOCK()
|
|
#define CBUF_MUTEX_UNLOCK()
|
|
#define CBUF_MUTEX_DELETE()
|
|
#else
|
|
#define CBUF_MUTEX_CREATE() if(_lock == NULL){_lock = xSemaphoreCreateMutex(); if(_lock == NULL){log_e("failed to create mutex");}}
|
|
#define CBUF_MUTEX_LOCK() if(_lock != NULL){xSemaphoreTakeRecursive(_lock, portMAX_DELAY);}
|
|
#define CBUF_MUTEX_UNLOCK() if(_lock != NULL){xSemaphoreGiveRecursive(_lock);}
|
|
#define CBUF_MUTEX_DELETE() if(_lock != NULL){SemaphoreHandle_t l = _lock; _lock = NULL; vSemaphoreDelete(l);}
|
|
#endif
|
|
|
|
cbuf::cbuf(size_t size) :
|
|
next(NULL),
|
|
has_peek(false),
|
|
peek_byte(0),
|
|
_buf(xRingbufferCreate(size, RINGBUF_TYPE_BYTEBUF))
|
|
{
|
|
if(_buf == NULL) {
|
|
log_e("failed to allocate ring buffer");
|
|
}
|
|
CBUF_MUTEX_CREATE();
|
|
}
|
|
|
|
cbuf::~cbuf()
|
|
{
|
|
CBUF_MUTEX_LOCK();
|
|
if(_buf != NULL){
|
|
RingbufHandle_t b = _buf;
|
|
_buf = NULL;
|
|
vRingbufferDelete(b);
|
|
}
|
|
CBUF_MUTEX_UNLOCK();
|
|
CBUF_MUTEX_DELETE();
|
|
}
|
|
|
|
size_t cbuf::resizeAdd(size_t addSize)
|
|
{
|
|
return resize(size() + addSize);
|
|
}
|
|
|
|
size_t cbuf::resize(size_t newSize)
|
|
{
|
|
CBUF_MUTEX_LOCK();
|
|
size_t _size = size();
|
|
if(newSize == _size) {
|
|
return _size;
|
|
}
|
|
|
|
// not lose any data
|
|
// if data can be lost use remove or flush before resize
|
|
size_t bytes_available = available();
|
|
if(newSize < bytes_available) {
|
|
CBUF_MUTEX_UNLOCK();
|
|
log_e("new size is less than the currently available data size");
|
|
return _size;
|
|
}
|
|
|
|
RingbufHandle_t newbuf = xRingbufferCreate(newSize, RINGBUF_TYPE_BYTEBUF);
|
|
if(newbuf == NULL) {
|
|
CBUF_MUTEX_UNLOCK();
|
|
log_e("failed to allocate new ring buffer");
|
|
return _size;
|
|
}
|
|
|
|
if(_buf != NULL) {
|
|
if(bytes_available){
|
|
char * old_data = (char *)malloc(bytes_available);
|
|
if(old_data == NULL){
|
|
vRingbufferDelete(newbuf);
|
|
CBUF_MUTEX_UNLOCK();
|
|
log_e("failed to allocate temporary buffer");
|
|
return _size;
|
|
}
|
|
bytes_available = read(old_data, bytes_available);
|
|
if(!bytes_available){
|
|
free(old_data);
|
|
vRingbufferDelete(newbuf);
|
|
CBUF_MUTEX_UNLOCK();
|
|
log_e("failed to read previous data");
|
|
return _size;
|
|
}
|
|
if(xRingbufferSend(newbuf, (void*)old_data, bytes_available, 0) != pdTRUE){
|
|
write(old_data, bytes_available);
|
|
free(old_data);
|
|
vRingbufferDelete(newbuf);
|
|
CBUF_MUTEX_UNLOCK();
|
|
log_e("failed to restore previous data");
|
|
return _size;
|
|
}
|
|
free(old_data);
|
|
}
|
|
|
|
RingbufHandle_t b = _buf;
|
|
_buf = newbuf;
|
|
vRingbufferDelete(b);
|
|
} else {
|
|
_buf = newbuf;
|
|
}
|
|
CBUF_MUTEX_UNLOCK();
|
|
return newSize;
|
|
}
|
|
|
|
size_t cbuf::available() const
|
|
{
|
|
size_t available = 0;
|
|
if(_buf != NULL){
|
|
vRingbufferGetInfo(_buf, NULL, NULL, NULL, NULL, (UBaseType_t *)&available);
|
|
}
|
|
if (has_peek) available++;
|
|
return available;
|
|
}
|
|
|
|
size_t cbuf::size()
|
|
{
|
|
size_t _size = 0;
|
|
if(_buf != NULL){
|
|
_size = xRingbufferGetMaxItemSize(_buf);
|
|
}
|
|
return _size;
|
|
}
|
|
|
|
size_t cbuf::room() const
|
|
{
|
|
size_t _room = 0;
|
|
if(_buf != NULL){
|
|
_room = xRingbufferGetCurFreeSize(_buf);
|
|
}
|
|
return _room;
|
|
}
|
|
|
|
bool cbuf::empty() const
|
|
{
|
|
return available() == 0;
|
|
}
|
|
|
|
bool cbuf::full() const
|
|
{
|
|
return room() == 0;
|
|
}
|
|
|
|
int cbuf::peek()
|
|
{
|
|
if (!available()) {
|
|
return -1;
|
|
}
|
|
|
|
int c;
|
|
|
|
CBUF_MUTEX_LOCK();
|
|
if (has_peek) {
|
|
c = peek_byte;
|
|
} else {
|
|
c = read();
|
|
if (c >= 0) {
|
|
has_peek = true;
|
|
peek_byte = c;
|
|
}
|
|
}
|
|
CBUF_MUTEX_UNLOCK();
|
|
return c;
|
|
}
|
|
|
|
int cbuf::read()
|
|
{
|
|
char result = 0;
|
|
if(!read(&result, 1)){
|
|
return -1;
|
|
}
|
|
return static_cast<int>(result);
|
|
}
|
|
|
|
size_t cbuf::read(char* dst, size_t size)
|
|
{
|
|
CBUF_MUTEX_LOCK();
|
|
size_t bytes_available = available();
|
|
if(!bytes_available || !size){
|
|
CBUF_MUTEX_UNLOCK();
|
|
return 0;
|
|
}
|
|
|
|
if (has_peek) {
|
|
if (dst != NULL) {
|
|
*dst++ = peek_byte;
|
|
}
|
|
size--;
|
|
}
|
|
|
|
size_t size_read = 0;
|
|
if (size) {
|
|
size_t received_size = 0;
|
|
size_t size_to_read = (size < bytes_available) ? size : bytes_available;
|
|
uint8_t *received_buff = (uint8_t *)xRingbufferReceiveUpTo(_buf, &received_size, 0, size_to_read);
|
|
if (received_buff != NULL) {
|
|
if(dst != NULL){
|
|
memcpy(dst, received_buff, received_size);
|
|
}
|
|
vRingbufferReturnItem(_buf, received_buff);
|
|
size_read = received_size;
|
|
size_to_read -= received_size;
|
|
// wrap around data
|
|
if(size_to_read){
|
|
received_size = 0;
|
|
received_buff = (uint8_t *)xRingbufferReceiveUpTo(_buf, &received_size, 0, size_to_read);
|
|
if (received_buff != NULL) {
|
|
if(dst != NULL){
|
|
memcpy(dst+size_read, received_buff, received_size);
|
|
}
|
|
vRingbufferReturnItem(_buf, received_buff);
|
|
size_read += received_size;
|
|
} else {
|
|
log_e("failed to read wrap around data from ring buffer");
|
|
}
|
|
}
|
|
} else {
|
|
log_e("failed to read from ring buffer");
|
|
}
|
|
}
|
|
|
|
if (has_peek) {
|
|
has_peek = false;
|
|
size_read++;
|
|
}
|
|
|
|
CBUF_MUTEX_UNLOCK();
|
|
return size_read;
|
|
}
|
|
|
|
size_t cbuf::write(char c)
|
|
{
|
|
return write(&c, 1);
|
|
}
|
|
|
|
size_t cbuf::write(const char* src, size_t size)
|
|
{
|
|
CBUF_MUTEX_LOCK();
|
|
size_t bytes_available = room();
|
|
if(!bytes_available || !size){
|
|
CBUF_MUTEX_UNLOCK();
|
|
return 0;
|
|
}
|
|
size_t size_to_write = (size < bytes_available) ? size : bytes_available;
|
|
if(xRingbufferSend(_buf, (void*)src, size_to_write, 0) != pdTRUE){
|
|
CBUF_MUTEX_UNLOCK();
|
|
log_e("failed to write to ring buffer");
|
|
return 0;
|
|
}
|
|
CBUF_MUTEX_UNLOCK();
|
|
return size_to_write;
|
|
}
|
|
|
|
void cbuf::flush()
|
|
{
|
|
read(NULL, available());
|
|
}
|
|
|
|
size_t cbuf::remove(size_t size)
|
|
{
|
|
CBUF_MUTEX_LOCK();
|
|
size_t bytes_available = available();
|
|
if(bytes_available && size){
|
|
size_t size_to_remove = (size < bytes_available) ? size : bytes_available;
|
|
bytes_available -= read(NULL, size_to_remove);
|
|
}
|
|
CBUF_MUTEX_UNLOCK();
|
|
return bytes_available;
|
|
}
|