Compare text

Find the difference between two text files
Real-time diff
Unified diff
Collapse lines
Highlight change
Syntax highlighting
Tools

Untitled diff

Created Diff never expires
114 removals
493 lines
115 additions
494 lines
/*
/*
MIT License
MIT License


Copyright (c) 2018 Antonio Alexander Brewer (tonton81) - https://github.com/tonton81
Copyright (c) 2018 Antonio Alexander Brewer (tonton81) - https://github.com/tonton81


Contributors:
Contributors:
Tim - https://github.com/Defragster
Tim - https://github.com/Defragster
Mike - https://github.com/mjs513
Mike - https://github.com/mjs513


Designed and tested for PJRC Teensy 3.2, 3.5, and 3.6 boards.
Designed and tested for PJRC Teensy 3.2, 3.5, and 3.6 boards.
May or may not work on other microcontrollers, support for them will not be provided.
May or may not work on other microcontrollers, support for them will not be provided.
Use at your own risk.
Use at your own risk.


Forum link : https://forum.pjrc.com/threads/50395-Circular_Buffer
Forum link : https://forum.pjrc.com/threads/50395-Circular_Buffer


Permission is hereby granted, free of charge, to any person obtaining a copy
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
furnished to do so, subject to the following conditions:


The above copyright notice and this permission notice shall be included in all
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
copies or substantial portions of the Software.


THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
SOFTWARE.
*/
*/




#ifndef CIRCULAR_BUFFER_H
#ifndef CIRCULAR_BUFFER_H
#define CIRCULAR_BUFFER_H
#define CIRCULAR_BUFFER_H
#include <algorithm>
#include <algorithm>


template<typename T, uint16_t _size, uint16_t multi = 0>
template<typename T, uint16_t _size, uint16_t multi = 0>
class Circular_Buffer {
class Circular_Buffer {
public:
public:


void push_back(T value) { return write(value); }
void push_back(T value) { return write(value); }
void push_front(T value);
void push_front(T value);
T pop_front() { return read(); }
T pop_front() { return read(); }
T pop_back();
T pop_back();
void write(T value);
void write(T value);
void push_back(const T *buffer, uint16_t length) { write(buffer, length); }
void push_back(const T *buffer, uint16_t length) { write(buffer, length); }
void write(const T *buffer, uint16_t length);
void write(const T *buffer, uint16_t length);
void push_front(const T *buffer, uint16_t length);
void push_front(const T *buffer, uint16_t length);
T peek(uint16_t pos = 0);
T peek(uint16_t pos = 0);
T peekBytes(T *buffer, uint16_t length);
T peekBytes(T *buffer, uint16_t length);
T read();
T read();
T pop_front(T *buffer, uint16_t length) { return readBytes(buffer,length); }
T pop_front(T *buffer, uint16_t length) { return readBytes(buffer,length); }
T read(T *buffer, uint16_t length) { return readBytes(buffer,length); }
T read(T *buffer, uint16_t length) { return readBytes(buffer,length); }
T readBytes(T *buffer, uint16_t length);
T readBytes(T *buffer, uint16_t length);
void flush() { clear(); }
void flush() { clear(); }
void clear() { head = tail = _available = 0; }
void clear() { head = tail = _available = 0; }
void print(const char *p);
void print(const char *p);
void println(const char *p);
void println(const char *p);
uint16_t size() { return _available; }
uint16_t size() { return _available; }
uint16_t available() { return _available; }
uint16_t available() { return _available; }
T capacity() { return _size; }
T capacity() { return _size; }
uint16_t length_back() { return ((uint16_t)(_cabuf[_cbuf[(head+size()-1)&(_size-1)]][0] << 8*sizeof(T)) | _cabuf[_cbuf[(head+size()-1)&(_size-1)]][1]); }
uint16_t length_back() { return ((uint16_t)(_cabuf[((head+size()-1)&(_size-1))][0] << 8*sizeof(T)) | _cabuf[((head+size()-1)&(_size-1))][1]); }
uint16_t length_front() { return ((uint16_t)_cabuf[_cbuf[(head)&(_size-1)]][0] << 8*sizeof(T) | _cabuf[_cbuf[(head)&(_size-1)]][1]); }
uint16_t length_front() { return ((uint16_t)_cabuf[((head)&(_size-1))][0] << 8*sizeof(T) | _cabuf[((head)&(_size-1))][1]); }
T list();
T list();
T variance();
T variance();
T deviation();
T deviation();
T average();
T average();
bool remove(uint16_t pos);
bool remove(uint16_t pos);
T median(bool override = 0);
T median(bool override = 0);
void sort_ascending();
void sort_ascending();
void sort_descending();
void sort_descending();
T sum();
T sum();
T min();
T min();
T max();
T max();
T mean() { return average(); }
T mean() { return average(); }
T max_size() { return multi; }
T max_size() { return multi; }
T pop_back(T *buffer, uint16_t length);
T pop_back(T *buffer, uint16_t length);
T* peek_front() { return front(); }
T* peek_front() { return front(); }
T* peek_back() { return back(); }
T* peek_back() { return back(); }
T* front() { return _cabuf[_cbuf[(head)&(_size-1)]]+2; }
T* front() { return _cabuf[((head)&(_size-1))]+2; }
T* back() { return _cabuf[(tail-1)&(_size-1)]+2; }
T* back() { return _cabuf[((tail-1)&(_size-1))]+2; }
bool replace(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4 = -1, int pos5 = -1);
bool replace(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4 = -1, int pos5 = -1);
T* find(int pos1, int pos2, int pos3, int pos4 = -1, int pos5 = -1);
T* find(int pos1, int pos2, int pos3, int pos4 = -1, int pos5 = -1);


protected:
protected:
private:
private:
volatile uint16_t head = 0;
volatile uint16_t head = 0;
volatile uint16_t tail = 0;
volatile uint16_t tail = 0;
volatile uint16_t _available = 0;
volatile uint16_t _available = 0;


bool init_ca = 1;
bool init_ca = 1;
T _cbuf[_size];
T _cbuf[_size];
T _cabuf[_size][multi+2];
T _cabuf[_size][multi+2];
void _init();
void _init();
};
};


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
bool Circular_Buffer<T,_size,multi>::remove(uint16_t pos) {
bool Circular_Buffer<T,_size,multi>::remove(uint16_t pos) {
if ( multi ) {
if ( multi ) {
if ( pos >= _size ) return 0;
if ( pos >= _size ) return 0;


int32_t find_area = -1;
int32_t find_area = -1;


for ( uint16_t i = 0; i < _size; i++ ) {
for ( uint16_t i = 0; i < _size; i++ ) {
if ( ((head+i)&(_size-1)) == pos ) {
if ( ((head+i)&(_size-1)) == pos ) {
find_area = i;
find_area = i;
break;
break;
}
}
}
}
if ( find_area == -1 ) return 0;
if ( find_area == -1 ) return 0;


while ( ((head+find_area)&(_size-1)) != ((head)&(_size-1)) ) {
while ( ((head+find_area)&(_size-1)) != ((head)&(_size-1)) ) {
memmove(_cabuf[_cbuf[((head+find_area)&(_size-1))]],_cabuf[_cbuf[((head+find_area-1)&(_size-1))]],((int)((int)_cabuf[(int)_cbuf[(head+find_area-1)&(_size-1)]][0] << 8*sizeof(T)) | (int)_cabuf[(int)_cbuf[(head+find_area-1)&(_size-1)]][1])+3);
memmove(_cabuf[((head+find_area)&(_size-1))],_cabuf[((head+find_area-1)&(_size-1))],((uint16_t)(_cabuf[((head+find_area-1)&(_size-1))][0] << 8*sizeof(T)) | _cabuf[((head+find_area-1)&(_size-1))][1])+3);
find_area--;
find_area--;
}
}


head = ((head + 1)&(2*_size-1));
head = ((head + 1)&(2*_size-1));
_available--;
_available--;
return 1;
return 1;
}
}
return 0;
return 0;
}
}




































template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T* Circular_Buffer<T, _size, multi>::find(int pos1, int pos2, int pos3, int pos4, int pos5) {
T* Circular_Buffer<T, _size, multi>::find(int pos1, int pos2, int pos3, int pos4, int pos5) {
}
}




template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
bool Circular_Buffer<T, _size, multi>::replace(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4, int pos5) {
bool Circular_Buffer<T, _size, multi>::replace(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4, int pos5) {
uint8_t input_count = 3;
uint8_t input_count = 3;
bool found = 0;
bool found = 0;
if ( pos4 != -1 ) input_count = 4;
if ( pos4 != -1 ) input_count = 4;
if ( pos5 != -1 ) input_count = 5;
if ( pos5 != -1 ) input_count = 5;
for ( uint16_t j = 0; j < _available; j++ ) {
for ( uint16_t j = 0; j < _available; j++ ) {
switch ( input_count ) {
switch ( input_count ) {
case 3: {
case 3: {
if ( _cabuf[ (head+j)&(_size-1) ][pos1+2] == buffer[pos1] && _cabuf[ (head+j)&(_size-1) ][pos2+2] == buffer[pos2] &&
if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&
_cabuf[ (head+j)&(_size-1) ][pos3+2] == buffer[pos3] ) {
_cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] ) {
found = 1;
found = 1;
break;
break;
}
}
}
}
case 4: {
case 4: {
if ( _cabuf[ (head+j)&(_size-1) ][pos1+2] == buffer[pos1] && _cabuf[ (head+j)&(_size-1) ][pos2+2] == buffer[pos2] &&
if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&
_cabuf[ (head+j)&(_size-1) ][pos3+2] == buffer[pos3] && _cabuf[ (head+j)&(_size-1) ][pos4+2] == buffer[pos4] ) {
_cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] ) {
found = 1;
found = 1;
break;
break;
}
}
}
}
case 5: {
case 5: {
if ( _cabuf[ (head+j)&(_size-1) ][pos1+2] == buffer[pos1] && _cabuf[ (head+j)&(_size-1) ][pos2+2] == buffer[pos2] &&
if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&
_cabuf[ (head+j)&(_size-1) ][pos3+2] == buffer[pos3] && _cabuf[ (head+j)&(_size-1) ][pos4+2] == buffer[pos4] &&
_cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] &&
_cabuf[ (head+j)&(_size-1) ][pos5+2] == buffer[pos5] ) {
_cabuf[ ((head+j)&(_size-1)) ][pos5+2] == buffer[pos5] ) {
found = 1;
found = 1;
break;
break;
}
}
}
}
}
}
if ( found ) {
if ( found ) {
_cabuf[j][0] = ((uint8_t)(length >> 8*sizeof(T)));
_cabuf[ ((head+j)&(_size-1)) ][0] = ((uint8_t)(length >> 8*sizeof(T)));
_cabuf[j][1] = length;
_cabuf[ ((head+j)&(_size-1)) ][1] = length;
memmove(_cabuf[j]+2,buffer,length*sizeof(T));
memmove(_cabuf[ ((head+j)&(_size-1)) ]+2,buffer,length*sizeof(T));
break;
break;
}
}
}
}
return found;
return found;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::print(const char *p) {
void Circular_Buffer<T,_size,multi>::print(const char *p) {
if ( multi ) return;
if ( multi ) return;
write((T*)p,strlen(p));
write((T*)p,strlen(p));
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::println(const char *p) {
void Circular_Buffer<T,_size,multi>::println(const char *p) {
if ( multi ) return;
if ( multi ) return;
write((T*)p,strlen(p));
write((T*)p,strlen(p));
write('\n');
write('\n');
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::_init() {
void Circular_Buffer<T,_size,multi>::_init() {
for ( uint16_t i = 0; i < _size; i++ ) _cbuf[i] = i;
for ( uint16_t i = 0; i < _size; i++ ) _cbuf[i] = i;
init_ca = 0;
init_ca = 0;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::push_front(const T *buffer, uint16_t length) {
void Circular_Buffer<T,_size,multi>::push_front(const T *buffer, uint16_t length) {
if ( multi ) {
if ( multi ) {
if ( init_ca ) _init();
if ( init_ca ) _init();
if ( tail == (head ^ _size) ) tail = (tail - 1)&(2*_size-1);
if ( tail == (head ^ _size) ) tail = ((tail - 1)&(2*_size-1));
head = (head - 1)&(2*_size-1);
head = ((head - 1)&(2*_size-1));
_cabuf[_cbuf[head&(_size-1)]][0] = length >> 8*sizeof(T);
_cabuf[(head&(_size-1))][0] = length >> 8*sizeof(T);
_cabuf[_cbuf[head&(_size-1)]][1] = length;
_cabuf[(head&(_size-1))][1] = length;
memmove(_cabuf[_cbuf[(head)&(_size-1)]]+2,buffer,length*sizeof(T));
memmove(_cabuf[((head)&(_size-1))]+2,buffer,length*sizeof(T));
if ( _available < _size ) _available++;
if ( _available < _size ) _available++;
return;
return;
}
}
for ( uint16_t i = length-1; i > 0; i-- ) push_front(buffer[i]);
for ( uint16_t i = length-1; i > 0; i-- ) push_front(buffer[i]);
push_front(buffer[0]);
push_front(buffer[0]);
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::pop_back() {
T Circular_Buffer<T,_size,multi>::pop_back() {
if ( _available ) {
if ( _available ) {
if ( _available ) _available--;
if ( _available ) _available--;
tail = (tail - 1)&(2*_size-1);
tail = ((tail - 1)&(2*_size-1));
return _cbuf[tail&(_size-1)];
return _cbuf[((tail)&(_size-1))];
}
}
return -1;
return -1;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::push_front(T value) {
void Circular_Buffer<T,_size,multi>::push_front(T value) {
if ( multi ) return;
if ( multi ) return;
head = (head - 1)&(2*_size-1);
head = ((head - 1)&(2*_size-1));
_cbuf[head&(_size-1)] = value;
_cbuf[((head)&(_size-1))] = value;
if ( _available < _size ) _available++;
if ( _available < _size ) _available++;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::write(const T *buffer, uint16_t length) {
void Circular_Buffer<T,_size,multi>::write(const T *buffer, uint16_t length) {
if ( multi ) {
if ( multi ) {
if ( init_ca ) _init();
if ( init_ca ) _init();
_cabuf[(int)_cbuf[tail&(_size-1)]][0] = length >> 8*sizeof(T);
_cabuf[((tail)&(_size-1))][0] = length >> 8*sizeof(T);
_cabuf[(int)_cbuf[tail&(_size-1)]][1] = length;
_cabuf[((tail)&(_size-1))][1] = length;
memmove(_cabuf[(int)_cbuf[tail&(_size-1)]]+2,buffer,length*sizeof(T));
memmove(_cabuf[((tail)&(_size-1))]+2,buffer,length*sizeof(T));
if ( tail == (head ^ _size) ) head = (head + 1)&(2*_size-1);
if ( tail == ((head ^ _size)) ) head = ((head + 1)&(2*_size-1));
tail = (tail + 1)&(2*_size-1);
tail = ((tail + 1)&(2*_size-1));
if ( _available < _size ) _available++;
if ( _available < _size ) _available++;
return;
return;
}
}
if ( ( _available += length ) >= _size ) _available = _size;
if ( ( _available += length ) >= _size ) _available = _size;
if ( length < ( _size - tail ) ) {
if ( length < ( _size - tail ) ) {
memmove(_cbuf+tail,buffer,length*sizeof(T));
memmove(_cbuf+tail,buffer,length*sizeof(T));
tail = (tail + length)&(2*_size-1);
tail = ((tail + length)&(2*_size-1));
}
}
else for ( uint16_t i = 0; i < length; i++ ) write(buffer[i]);
else for ( uint16_t i = 0; i < length; i++ ) write(buffer[i]);
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::write(T value) {
void Circular_Buffer<T,_size,multi>::write(T value) {
if ( multi ) return;
if ( multi ) return;
if ( _available < _size ) _available++;
if ( _available < _size ) _available++;
_cbuf[tail&(_size-1)] = value;
_cbuf[((tail)&(_size-1))] = value;
if ( tail == (head ^ _size) ) head = (head + 1)&(2*_size-1);
if ( tail == ((head ^ _size)) ) head = ((head + 1)&(2*_size-1));
tail = (tail + 1)&(2*_size-1);
tail = ((tail + 1)&(2*_size-1));
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::list() {
T Circular_Buffer<T,_size,multi>::list() {
if ( multi ) {
if ( multi ) {
if ( init_ca ) _init();
if ( init_ca ) _init();
if ( !size() ) {
if ( !size() ) {
Serial.println("There are no queues available..."); return 0;
Serial.println("There are no queues available..."); return 0;
}
}


Serial.print("\nCircular Array Buffer Queue Size: "); Serial.print(size()); Serial.print(" / "); Serial.println(_size);
Serial.print("\nCircular Array Buffer Queue Size: "); Serial.print(size()); Serial.print(" / "); Serial.println(_size);


Serial.print("\nFirst Entry: ");
Serial.print("\nFirst Entry: ");
for ( uint16_t i = 2; i <= (((int)_cabuf[(int)_cbuf[(head)&(_size-1)]][0] << 8*sizeof(T)) | (int)_cabuf[(int)_cbuf[(head)&(_size-1)]][1])+1; i++ ) {
for ( uint16_t i = 2; i <= (((int)_cabuf[((head)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head)&(_size-1))][1])+1; i++ ) {
if ( (int)(_cabuf[(int)_cbuf[(head+i)&(_size-1)]][i]) != (T)(_cabuf[(int)_cbuf[(head+i)&(_size-1)]][i]) ) { // possible float?
if ( (int)(_cabuf[((head+i)&(_size-1))][i]) != (T)(_cabuf[((head+i)&(_size-1))][i]) ) { // possible float?
Serial.print(_cabuf[(int)_cbuf[(head)&(_size-1)]][i],7);
Serial.print(_cabuf[((head)&(_size-1))][i],7);
}
}
else Serial.print(_cabuf[(int)_cbuf[(head)&(_size-1)]][i]);
else Serial.print(_cabuf[((head)&(_size-1))][i]);
Serial.print(" ");
Serial.print(" ");
} Serial.print("("); Serial.print(((int)((int)_cabuf[(int)_cbuf[(head)&(_size-1)]][0] << 8*sizeof(T)) | (int)_cabuf[(int)_cbuf[(head)&(_size-1)]][1])); Serial.println(" entries.)");
} Serial.print("("); Serial.print((((int)_cabuf[((head)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head)&(_size-1))][1])); Serial.println(" entries.)");


Serial.print("Last Entry: ");
Serial.print("Last Entry: ");
for ( uint16_t i = 2; i <= ((int)((int)_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][0] << 8*sizeof(T)) | (int)_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][1])+1; i++ ) {
for ( uint16_t i = 2; i <= (((int)_cabuf[((head+size()-1)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head+size()-1)&(_size-1))][1])+1; i++ ) {
if ( (int)(_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][i]) != (T)(_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][i]) ) { // possible float?
if ( (int)(_cabuf[((head+size()-1)&(_size-1))][i]) != (T)(_cabuf[((head+size()-1)&(_size-1))][i]) ) { // possible float?
Serial.print(_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][i],7);
Serial.print(_cabuf[((head+size()-1)&(_size-1))][i],7);
}
}
else Serial.print(_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][i]);
else Serial.print(_cabuf[((head+size()-1)&(_size-1))][i]);
Serial.print(" ");
Serial.print(" ");
} Serial.print("("); Serial.print(((int)((int)_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][0] << 8*sizeof(T)) | (int)_cabuf[(int)_cbuf[(head+size()-1)&(_size-1)]][1])); Serial.println(" entries.)");
} Serial.print("("); Serial.print((((int)_cabuf[((head+size()-1)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head+size()-1)&(_size-1))][1])); Serial.println(" entries.)");


Serial.print("\n[Indice] [Entries]\n\n");
Serial.print("\n[Indice] [Entries]\n\n");
for ( uint16_t i = 0; i < size(); i++ ) {
for ( uint16_t i = 0; i < size(); i++ ) {
Serial.print(" ");
Serial.print(" ");
Serial.print((head+i)&(_size-1));
Serial.print(((head+i)&(_size-1)));
Serial.print("\t\t");
Serial.print("\t\t");
for ( uint16_t j = 2; j <= ((int)((int)_cabuf[(int)_cbuf[(head+i)&(_size-1)]][0] << 8*sizeof(T)) | (int)_cabuf[(int)_cbuf[(head+i)&(_size-1)]][1])+1; j++ ) {
for ( uint16_t j = 2; j <= (((int)_cabuf[((head+i)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head+i)&(_size-1))][1])+1; j++ ) {
if ( (int)(_cabuf[(int)_cbuf[(head+i)&(_size-1)]][j]) != (T)(_cabuf[(int)_cbuf[(head+i)&(_size-1)]][j]) ) { // possible float?
if ( (int)(_cabuf[((head+i)&(_size-1))][j]) != (T)(_cabuf[((head+i)&(_size-1))][j]) ) { // possible float?
Serial.print(_cabuf[(int)_cbuf[(head+i)&(_size-1)]][j],7); Serial.print("\t");
Serial.print(_cabuf[((head+i)&(_size-1))][j],7); Serial.print("\t");
}
}
else {
else {
Serial.print(_cabuf[(int)_cbuf[(head+i)&(_size-1)]][j]); Serial.print("\t");
Serial.print(_cabuf[((head+i)&(_size-1))][j]); Serial.print("\t");
}
}
} Serial.print("("); Serial.print(((int)((int)_cabuf[(int)_cbuf[(head+i)&(_size-1)]][0] << 8*sizeof(T)) | (int)_cabuf[(int)_cbuf[(head+i)&(_size-1)]][1])); Serial.println(" entries.)");
} Serial.print("("); Serial.print((((int)_cabuf[((head+i)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head+i)&(_size-1))][1])); Serial.println(" entries.)");
}
}
return _available;
return _available;
}
}




if ( !size() ) {
if ( !size() ) {
Serial.println("There are no queues available..."); return 0;
Serial.println("There are no queues available..."); return 0;
}
}
Serial.print("\nCircular Ring Buffer Queue Size: "); Serial.print(size()); Serial.print(" / "); Serial.println(_size);
Serial.print("\nCircular Ring Buffer Queue Size: "); Serial.print(size()); Serial.print(" / "); Serial.println(_size);


Serial.print("\nIndice: \t");
Serial.print("\nIndice: \t");


for ( uint16_t i = 0; i < _available; i++ ) {
for ( uint16_t i = 0; i < _available; i++ ) {
Serial.print("[");
Serial.print("[");
Serial.print((head+i)&(_size-1)); Serial.print("] \t");
Serial.print((head+i)&(_size-1)); Serial.print("] \t");
}
}


Serial.print("\nEntries:\t");
Serial.print("\nEntries:\t");


for ( uint16_t i = 0; i < _available; i++ ) {
for ( uint16_t i = 0; i < _available; i++ ) {
if ( (int)_cbuf[(head+i)&(_size-1)] != (T)_cbuf[(head+i)&(_size-1)] ) { // possible float?
if ( (int)_cbuf[((head+i)&(_size-1))] != (T)_cbuf[((head+i)&(_size-1))] ) { // possible float?
Serial.print(_cbuf[(head+i)&(_size-1)],7); Serial.print("\t");
Serial.print(_cbuf[((head+i)&(_size-1))],7); Serial.print("\t");
}
}
else {
else {
Serial.print(_cbuf[(head+i)&(_size-1)]); Serial.print("\t\t");
Serial.print(_cbuf[((head+i)&(_size-1))]); Serial.print("\t\t");
}
}
} Serial.println('\n');
} Serial.println('\n');








return _available;
return _available;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::read() {
T Circular_Buffer<T,_size,multi>::read() {
if ( multi ) {
if ( multi ) {
if ( init_ca ) _init();
if ( init_ca ) _init();
head = (head + 1)&(2*_size-1);
head = ((head + 1)&(2*_size-1));
if ( _available ) _available--;
if ( _available ) _available--;
return 0;
return 0;
}
}
if ( _available ) _available--;
if ( _available ) _available--;
T value = _cbuf[head&(_size-1)];
T value = _cbuf[((head)&(_size-1))];
head = (head + 1)&(2*_size-1);
head = ((head + 1)&(2*_size-1));
return value;
return value;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::sum() {
T Circular_Buffer<T,_size,multi>::sum() {
if ( multi || !_available ) return 0;
if ( multi || !_available ) return 0;
T value = 0;
T value = 0;
for ( uint16_t i = 0; i < _available; i++ ) value += _cbuf[(head+i)&(_size-1)];
for ( uint16_t i = 0; i < _available; i++ ) value += _cbuf[((head+i)&(_size-1))];
return value;
return value;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::average() {
T Circular_Buffer<T,_size,multi>::average() {
if ( multi || !_available ) return 0;
if ( multi || !_available ) return 0;
return sum()/_available;
return sum()/_available;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::variance() {
T Circular_Buffer<T,_size,multi>::variance() {
if ( multi || !_available ) return 0;
if ( multi || !_available ) return 0;
T _mean = average();
T _mean = average();
T value = 0;
T value = 0;
for ( uint16_t i = 0; i < _available; i++ ) {
for ( uint16_t i = 0; i < _available; i++ ) {
value += ((_cbuf[(head+i)&(_size-1)] - _mean) * (_cbuf[(head+i)&(_size-1)] - _mean));
value += ((_cbuf[((head+i)&(_size-1))] - _mean) * (_cbuf[((head+i)&(_size-1))] - _mean));
}
}
value /= _available;
value /= _available;
return value;
return value;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::deviation() {
T Circular_Buffer<T,_size,multi>::deviation() {
if ( multi || !_available ) return 0;
if ( multi || !_available ) return 0;
return sqrt(variance());
return sqrt(variance());
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::peek(uint16_t pos) {
T Circular_Buffer<T,_size,multi>::peek(uint16_t pos) {
if ( multi ) return 0;
if ( multi ) return 0;
if ( pos > _size ) return 0;
if ( pos > _size ) return 0;
return _cbuf[(head+pos)&(_size-1)];
return _cbuf[((head+pos)&(_size-1))];
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::sort_ascending() {
void Circular_Buffer<T,_size,multi>::sort_ascending() {
if ( multi || !_available ) return;
if ( multi || !_available ) return;
T buffer[_available];
T buffer[_available];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[(head+i)&(_size-1)];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];
std::sort(&buffer[0], &buffer[_available]); // sort ascending
std::sort(&buffer[0], &buffer[_available]); // sort ascending
for ( uint16_t i = 0; i < _available; i++ ) _cbuf[(head+i)&(_size-1)] = buffer[i];
for ( uint16_t i = 0; i < _available; i++ ) _cbuf[((head+i)&(_size-1))] = buffer[i];
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
void Circular_Buffer<T,_size,multi>::sort_descending() {
void Circular_Buffer<T,_size,multi>::sort_descending() {
if ( multi || !_available ) return;
if ( multi || !_available ) return;
sort_ascending();
sort_ascending();
T buffer[_available];
T buffer[_available];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[(head+i)&(_size-1)];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];
std::reverse(&buffer[0], &buffer[_available]); // sort descending
std::reverse(&buffer[0], &buffer[_available]); // sort descending
for ( uint16_t i = 0; i < _available; i++ ) _cbuf[(head+i)&(_size-1)] = buffer[i];
for ( uint16_t i = 0; i < _available; i++ ) _cbuf[((head+i)&(_size-1))] = buffer[i];
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::median(bool override) {
T Circular_Buffer<T,_size,multi>::median(bool override) {
if ( multi || !_available ) return 0;
if ( multi || !_available ) return 0;
if ( override ) sort_ascending();
if ( override ) sort_ascending();
else {
else {
T buffer[_available];
T buffer[_available];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[(head+i)&(_size-1)];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];
std::sort(&buffer[0], &buffer[_available]); // sort ascending
std::sort(&buffer[0], &buffer[_available]); // sort ascending
}
}
if ( !(_available % 2) ) {
if ( !(_available % 2) ) {
return ( _cbuf[(head+((_available/2)-1))&(_size-1)] + _cbuf[(head+(_available/2))&(_size-1)] ) /2;
return ( _cbuf[((head+((_available/2)-1))&(_size-1))] + _cbuf[((head+(_available/2))&(_size-1))] ) /2;
}
}
else return _cbuf[(head+((_available/2)))&(_size-1)];
else return _cbuf[((head+((_available/2)))&(_size-1))];
return 0;
return 0;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::max() {
T Circular_Buffer<T,_size,multi>::max() {
if ( multi || !_available ) return 0;
if ( multi || !_available ) return 0;
T buffer[_available];
T buffer[_available];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[(head+i)&(_size-1)];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];
std::sort(&buffer[0], &buffer[_available]); // sort ascending
std::sort(&buffer[0], &buffer[_available]); // sort ascending
return buffer[_available-1];
return buffer[_available-1];
}
}
template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::min() {
T Circular_Buffer<T,_size,multi>::min() {
if ( multi || !_available ) return 0;
if ( multi || !_available ) return 0;
T buffer[_available];
T buffer[_available];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[(head+i)&(_size-1)];
for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];
std::sort(&buffer[0], &buffer[_available]); // sort ascending
std::sort(&buffer[0], &buffer[_available]); // sort ascending
return buffer[0];
return buffer[0];
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::peekBytes(T *buffer, uint16_t length) {
T Circular_Buffer<T,_size,multi>::peekBytes(T *buffer, uint16_t length) {
if ( multi ) return 0;
if ( multi ) return 0;
uint16_t _count;
uint16_t _count;
( _available < length ) ? _count = _available : _count = length;
( _available < length ) ? _count = _available : _count = length;
if ( _count < ( _size - head ) ) memmove(buffer,_cbuf,_count*sizeof(T));
if ( _count < ( _size - head ) ) memmove(buffer,_cbuf,_count*sizeof(T));
else for ( uint16_t i = 0; i < _count; i++ ) buffer[i] = peek(i);
else for ( uint16_t i = 0; i < _count; i++ ) buffer[i] = peek(i);
return _count;
return _count;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::readBytes(T *buffer, uint16_t length) {
T Circular_Buffer<T,_size,multi>::readBytes(T *buffer, uint16_t length) {
if ( multi ) {
if ( multi ) {
if ( init_ca ) _init();
if ( init_ca ) _init();
memmove(&buffer[0],&_cabuf[(int)_cbuf[(head)&(_size-1)]][2],length*sizeof(T)); // update CA buffer
memmove(&buffer[0],&_cabuf[((head)&(_size-1))][2],length*sizeof(T)); // update CA buffer
read();
read();
return 0;
return 0;
}
}
uint16_t _count;
uint16_t _count;
( _available < length ) ? _count = _available : _count = length; // memmove if aligned
( _available < length ) ? _count = _available : _count = length; // memmove if aligned
if ( _count < ( _size - head ) ) {
if ( _count < ( _size - head ) ) {
_available -= length;
_available -= length;
memmove(buffer,_cbuf,_count*sizeof(T));
memmove(buffer,_cbuf,_count*sizeof(T));
head = (head + _count)&(2*_size-1);
head = ((head + _count)&(2*_size-1));
}
}
else for ( uint16_t i = 0; i < _count; i++ ) buffer[i] = read(); // if buffer rollover
else for ( uint16_t i = 0; i < _count; i++ ) buffer[i] = read(); // if buffer rollover
return _count;
return _count;
}
}


template<typename T, uint16_t _size, uint16_t multi>
template<typename T, uint16_t _size, uint16_t multi>
T Circular_Buffer<T,_size,multi>::pop_back(T *buffer, uint16_t length) {
T Circular_Buffer<T,_size,multi>::pop_back(T *buffer, uint16_t length) {
if ( multi ) {
if ( multi ) {
if ( init_ca ) _init();
if ( init_ca ) _init();
memmove(&buffer[0],&_cabuf[(tail-1)&(_size-1)][2],length*sizeof(T));
memmove(&buffer[0],&_cabuf[((tail-1)&(_size-1))][2],length*sizeof(T));
tail = (tail - 1)&(2*_size-1);
tail = (tail - 1)&(2*_size-1);
if ( _available ) _available--;
if ( _available ) _available--;
return 0;
return 0;
}
}
}
}


#endif // Circular_Buffer_H
#endif // Circular_Buffer_H



Saved diffs