visus
/
framework-arduinoteensy-cxx20
Seguir 1
Destacar 0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 0 Wiki Actividad
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
4 Commits
1 Rama
Árbol: 16a0c39090
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '16a0c39090'
${ noResults }
framework-arduinoteensy-cxx20/libraries/FlexCAN_T4/circular_buffer.h

592 líneas
21KB
Original Blame Histórico 

  1. /*

  2.   MIT License

  3. 

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

  5. 

  6.   Contributors:

  7.   Tim - https://github.com/Defragster

  8.   Mike - https://github.com/mjs513

  9. 

  10.   Designed and tested for PJRC Teensy 3.2, 3.5, and 3.6 boards.

  11.   May or may not work on other microcontrollers, support for them will not be provided.

  12.   Use at your own risk.

  13. 

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

  15. 

  16.   Permission is hereby granted, free of charge, to any person obtaining a copy

  17.   of this software and associated documentation files (the "Software"), to deal

  18.   in the Software without restriction, including without limitation the rights

  19.   to use, copy, modify, merge, publish, distribute, sublicense, and / or sell

  20.   copies of the Software, and to permit persons to whom the Software is

  21.   furnished to do so, subject to the following conditions:

  22. 

  23.   The above copyright notice and this permission notice shall be included in all

  24.   copies or substantial portions of the Software.

  25. 

  26.   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  27.   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  28.   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

  29.   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

  30.   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

  31.   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  32.   SOFTWARE.

  33. */

  34. 

  35. 

  36. #ifndef CIRCULAR_BUFFER_H

  37. #define CIRCULAR_BUFFER_H

  38. #include <algorithm>

  39. 

  40. template<typename T, uint16_t _size, uint16_t multi = 0>

  41. class Circular_Buffer {

  42.     public:

  43. 

  44.         void push_back(T value) { return write(value); }

  45.         void push_front(T value);

  46.         T pop_front() { return read(); }

  47.         T pop_back();

  48.         void write(T value);

  49.         void push_back(const T *buffer, uint16_t length) { write(buffer, length); }

  50.         void write(const T *buffer, uint16_t length);

  51.         void push_front(const T *buffer, uint16_t length);

  52.         T peek(uint16_t pos = 0);

  53.         T peekBytes(T *buffer, uint16_t length);

  54.         T read();

  55.         T pop_front(T *buffer, uint16_t length) { return readBytes(buffer,length); }

  56.         T peek_front(T *buffer, uint16_t length, uint32_t entry = 0);

  57.         T read(T *buffer, uint16_t length) { return readBytes(buffer,length); }

  58.         T readBytes(T *buffer, uint16_t length);

  59.         void flush() { clear(); }

  60.         void clear() { head = tail = _available = 0; }

  61.         void print(const char *p);

  62.         void println(const char *p);

  63.         uint16_t size() { return _available; }

  64.         uint16_t available() { return _available; }

  65.         uint16_t capacity() { return _size; }

  66.         uint16_t length_back() { return (((int)_cabuf[((head+size()-1)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head+size()-1)&(_size-1))][1]); }

  67.         uint16_t length_front() { return (((int)_cabuf[((head)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head)&(_size-1))][1]); }

  68.         T list();

  69.         T variance();

  70.         T deviation();

  71.         T average();

  72.         bool remove(uint16_t pos);

  73.         T median(bool override = 0);

  74.         void sort_ascending();

  75.         void sort_descending();

  76.         T sum();

  77.         T min();

  78.         T max();

  79.         T mean() { return average(); }

  80.         T max_size() { return multi; }

  81.         T pop_back(T *buffer, uint16_t length);

  82.         T* peek_front() { return front(); } 

  83.         T* peek_back() { return back(); } 

  84.         T* front() { return _cabuf[((head)&(_size-1))]+2; }

  85.         T* back() { return _cabuf[((tail-1)&(_size-1))]+2; }

  86.         bool replace(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4 = -1, int pos5 = -1);

  87.         bool isEqual(const T *buffer);

  88.         bool find(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4 = -1, int pos5 = -1);

  89.         bool findRemove(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4 = -1, int pos5 = -1);

  90. 

  91.     protected:

  92.     private:

  93.         volatile uint16_t head = 0;

  94.         volatile uint16_t tail = 0;

  95.         volatile uint16_t _available = 0;

  96. 

  97.         T _cbuf[_size];

  98.         T _cabuf[_size][multi+2];

  99. };

  100. 

  101. 

  102. template<typename T, uint16_t _size, uint16_t multi>

  103. bool Circular_Buffer<T,_size,multi>::remove(uint16_t pos) {

  104.   if ( multi ) {

  105.     if ( pos >= _size ) return 0;

  106. 

  107.     int32_t find_area = -1;

  108. 

  109.     for ( uint16_t i = 0; i < _size; i++ ) {

  110.       if ( ((head+i)&(_size-1)) == pos ) {

  111.         find_area = i;

  112.         break;

  113.       }

  114.     }

  115.     if ( find_area == -1 ) return 0;

  116. 

  117.     while ( ((head+find_area)&(_size-1)) != ((head)&(_size-1)) ) {

  118.       memmove(_cabuf[((head+find_area)&(_size-1))],_cabuf[((head+find_area-1)&(_size-1))], (2+multi)*sizeof(T));

  119.       find_area--;

  120.     }

  121.     head = ((head + 1)&(2*_size-1));

  122.     _available--;

  123.     return 1;

  124.   }

  125.   return 0;

  126. }

  127. 

  128. 

  129. 

  130. 

  131. template<typename T, uint16_t _size, uint16_t multi>

  132. bool Circular_Buffer<T, _size, multi>::findRemove(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4, int pos5) {

  133.   uint8_t input_count = 3;

  134.   int32_t found = -1;

  135.   if ( pos4 != -1 ) input_count = 4;

  136.   if ( pos5 != -1 ) input_count = 5;

  137.   for ( uint16_t j = 0; j < _available; j++ ) {

  138.     switch ( input_count ) {

  139.       case 3: {

  140.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  141.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] ) {

  142.             found = j; 

  143.             break;

  144.           }

  145.         }

  146.       case 4: {

  147.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  148.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] ) {

  149.             found = j;

  150.             break;

  151.           }

  152.         }

  153.       case 5: {

  154.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  155.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] &&

  156.                _cabuf[ ((head+j)&(_size-1)) ][pos5+2] == buffer[pos5] ) {

  157.             found = j;

  158.             break;

  159.           }

  160.         }

  161.     }

  162.     if ( found >= 0 ) {

  163.       remove(found);

  164.       return 1;

  165.     }

  166.   }

  167.   return 0;

  168. }

  169. 

  170. 

  171. 

  172. 

  173. 

  174. 

  175. 

  176. 

  177. 

  178. 

  179. 

  180. 

  181. 

  182. 

  183. template<typename T, uint16_t _size, uint16_t multi>

  184. bool Circular_Buffer<T, _size, multi>::find(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4, int pos5) {

  185.   uint8_t input_count = 3;

  186.   bool found = 0;

  187.   if ( pos4 != -1 ) input_count = 4;

  188.   if ( pos5 != -1 ) input_count = 5;

  189.   for ( uint16_t j = 0; j < _available; j++ ) {

  190.     switch ( input_count ) {

  191.       case 3: {

  192.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  193.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] ) {

  194.             found = 1; 

  195.             break;

  196.           }

  197.         }

  198.       case 4: {

  199.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  200.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] ) {

  201.             found = 1;

  202.             break;

  203.           }

  204.         }

  205.       case 5: {

  206.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  207.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] &&

  208.                _cabuf[ ((head+j)&(_size-1)) ][pos5+2] == buffer[pos5] ) {

  209.             found = 1;

  210.             break;

  211.           }

  212.         }

  213.     }

  214.     if ( found ) {

  215.       memmove(buffer, _cabuf[ ((head+j)&(_size-1)) ]+2,length*sizeof(T));

  216.       break;

  217.     }

  218.   }

  219.   return found;

  220. }

  221. 

  222. 

  223. template<typename T, uint16_t _size, uint16_t multi>

  224. bool Circular_Buffer<T, _size, multi>::replace(T *buffer, uint16_t length, int pos1, int pos2, int pos3, int pos4, int pos5) {

  225.   uint8_t input_count = 3;

  226.   bool found = 0;

  227.   if ( pos4 != -1 ) input_count = 4;

  228.   if ( pos5 != -1 ) input_count = 5;

  229.   for ( uint16_t j = 0; j < _available; j++ ) {

  230.     switch ( input_count ) {

  231.       case 3: {

  232.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  233.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] ) {

  234.             found = 1; 

  235.             break;

  236.           }

  237.         }

  238.       case 4: {

  239.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  240.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] ) {

  241.             found = 1;

  242.             break;

  243.           }

  244.         }

  245.       case 5: {

  246.           if ( _cabuf[ ((head+j)&(_size-1)) ][pos1+2] == buffer[pos1] && _cabuf[ ((head+j)&(_size-1)) ][pos2+2] == buffer[pos2] &&

  247.                _cabuf[ ((head+j)&(_size-1)) ][pos3+2] == buffer[pos3] && _cabuf[ ((head+j)&(_size-1)) ][pos4+2] == buffer[pos4] &&

  248.                _cabuf[ ((head+j)&(_size-1)) ][pos5+2] == buffer[pos5] ) {

  249.             found = 1;

  250.             break;

  251.           }

  252.         }

  253.     }

  254.     if ( found ) {

  255.       _cabuf[ ((head+j)&(_size-1)) ][0] = length & 0xFF00;

  256.       _cabuf[ ((head+j)&(_size-1)) ][1] = length & 0xFF;

  257.       memmove(_cabuf[ ((head+j)&(_size-1)) ]+2,buffer,length*sizeof(T));

  258.       break;

  259.     }

  260.   }

  261.   return found;

  262. }

  263. 

  264. 

  265. 

  266. 

  267. 

  268. 

  269. 

  270. template<typename T, uint16_t _size, uint16_t multi>

  271. bool Circular_Buffer<T,_size,multi>::isEqual(const T *buffer) {

  272.   if ( multi ) {

  273.     bool success = 1;

  274.     for ( uint16_t j = 0; j < _available; j++ ) {

  275.       success = 1;

  276.       for ( uint16_t k = 0; k < (_cabuf[ ((head+j)&(_size-1)) ][0] | _cabuf[ ((head+j)&(_size-1)) ][1]); k++ ) {

  277.         if ( _cabuf[ ((head+j)&(_size-1)) ][k+2] != buffer[k] ) {

  278.           success = 0;

  279.           break;

  280.         }

  281.       }

  282.       if ( success ) return 1;

  283.     }

  284.   }

  285.   return 0;

  286. }

  287. 

  288. 

  289. 

  290. 

  291. 

  292. 

  293. template<typename T, uint16_t _size, uint16_t multi>

  294. void Circular_Buffer<T,_size,multi>::print(const char *p) {

  295.   if ( multi ) return;

  296.   write((T*)p,strlen(p));

  297. }

  298. 

  299. template<typename T, uint16_t _size, uint16_t multi>

  300. void Circular_Buffer<T,_size,multi>::println(const char *p) {

  301.   if ( multi ) return;

  302.   write((T*)p,strlen(p));

  303.   write('\n');

  304. }

  305. 

  306. template<typename T, uint16_t _size, uint16_t multi>

  307. void Circular_Buffer<T,_size,multi>::push_front(const T *buffer, uint16_t length) {

  308.   if ( multi ) {

  309.     if ( tail == (head ^ _size) ) tail = ((tail - 1)&(2*_size-1));

  310.     head = ((head - 1)&(2*_size-1));

  311.     _cabuf[(head&(_size-1))][0] = length & 0xFF00;

  312.     _cabuf[(head&(_size-1))][1] = length & 0xFF;

  313.     memmove(_cabuf[((head)&(_size-1))]+2,buffer,length*sizeof(T));

  314.     if ( _available < _size ) _available++;

  315.     return;

  316.   }

  317.   for ( uint16_t i = length-1; i > 0; i-- ) push_front(buffer[i]);

  318.   push_front(buffer[0]);

  319. }

  320. 

  321. template<typename T, uint16_t _size, uint16_t multi>

  322. T Circular_Buffer<T,_size,multi>::pop_back() {

  323.   if ( _available ) {

  324.     if ( _available ) _available--;

  325.     tail = ((tail - 1)&(2*_size-1));

  326.     return _cbuf[((tail)&(_size-1))];

  327.   }

  328.   return -1;

  329. }

  330. 

  331. template<typename T, uint16_t _size, uint16_t multi>

  332. void Circular_Buffer<T,_size,multi>::push_front(T value) {

  333.   if ( multi ) return;

  334.   head = ((head - 1)&(2*_size-1));

  335.   _cbuf[((head)&(_size-1))] = value;

  336.   if ( _available < _size ) _available++;

  337. }

  338. 

  339. template<typename T, uint16_t _size, uint16_t multi>

  340. void Circular_Buffer<T,_size,multi>::write(const T *buffer, uint16_t length) {

  341.   if ( multi ) {

  342.     _cabuf[((tail)&(_size-1))][0] = length & 0xFF00;

  343.     _cabuf[((tail)&(_size-1))][1] = length & 0xFF;

  344.     memmove(_cabuf[((tail)&(_size-1))]+2,buffer,length*sizeof(T));

  345.     if ( tail == ((head ^ _size)) ) head = ((head + 1)&(2*_size-1));

  346.     tail = ((tail + 1)&(2*_size-1));

  347.     if ( _available < _size ) _available++;

  348.     return;

  349.   }

  350.   if ( ( _available += length ) >= _size ) _available = _size;

  351.   if ( length < ( _size - tail ) ) {

  352.     memmove(_cbuf+tail,buffer,length*sizeof(T));

  353.     tail = ((tail + length)&(2*_size-1));

  354.   }

  355.   else for ( uint16_t i = 0; i < length; i++ ) write(buffer[i]);

  356. }

  357. 

  358. template<typename T, uint16_t _size, uint16_t multi>

  359. void Circular_Buffer<T,_size,multi>::write(T value) {

  360.   if ( multi ) return;

  361.   if ( _available < _size ) _available++;

  362.   _cbuf[((tail)&(_size-1))] = value;

  363.   if ( tail == ((head ^ _size)) ) head = ((head + 1)&(2*_size-1));

  364.   tail = ((tail + 1)&(2*_size-1));

  365. }

  366. 

  367. template<typename T, uint16_t _size, uint16_t multi>

  368. T Circular_Buffer<T,_size,multi>::list() {

  369.   if ( multi ) {

  370.     if ( !size() ) {

  371.       Serial.println("There are no queues available..."); return 0;

  372.     }

  373. 

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

  375. 

  376.     Serial.print("\nFirst Entry: ");

  377.     for ( uint16_t i = 2; i <= (((int)_cabuf[((head)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head)&(_size-1))][1])+1; i++ ) {

  378.       if ( (int)(_cabuf[((head+i)&(_size-1))][i]) != (T)(_cabuf[((head+i)&(_size-1))][i]) ) { // possible float?

  379.         Serial.print(_cabuf[((head)&(_size-1))][i],7);

  380.       }

  381.       else Serial.print(_cabuf[((head)&(_size-1))][i]);

  382.       Serial.print("    ");

  383.     } Serial.print("("); Serial.print((((int)_cabuf[((head)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head)&(_size-1))][1])); Serial.println(" entries.)");

  384. 

  385.     Serial.print("Last Entry:  ");

  386.     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++ ) {

  387.       if ( (int)(_cabuf[((head+size()-1)&(_size-1))][i]) != (T)(_cabuf[((head+size()-1)&(_size-1))][i]) ) { // possible float?

  388.         Serial.print(_cabuf[((head+size()-1)&(_size-1))][i],7);

  389.       }

  390.       else Serial.print(_cabuf[((head+size()-1)&(_size-1))][i]);

  391.       Serial.print("    ");

  392.     } 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.)");

  393. 

  394.     Serial.print("\n[Indice]      [Entries]\n\n"); 

  395.     for ( uint16_t i = 0; i < size(); i++ ) {

  396.       Serial.print("    ");

  397.       Serial.print(((head+i)&(_size-1)));

  398.       Serial.print("\t\t");

  399.       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++ ) {

  400.         if ( (int)(_cabuf[((head+i)&(_size-1))][j]) != (T)(_cabuf[((head+i)&(_size-1))][j]) ) { // possible float?

  401.           Serial.print(_cabuf[((head+i)&(_size-1))][j],7); Serial.print("\t");

  402.         }

  403.         else {

  404.           Serial.print(_cabuf[((head+i)&(_size-1))][j]); Serial.print("\t");

  405.         }

  406.       } Serial.print("("); Serial.print((((int)_cabuf[((head+i)&(_size-1))][0] << 8*sizeof(T)) | (int)_cabuf[((head+i)&(_size-1))][1])); Serial.println(" entries.)");

  407.     }

  408.     return _available;

  409.   }

  410. 

  411. 

  412.   if ( !size() ) {

  413.     Serial.println("There are no queues available..."); return 0;

  414.   }

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

  416. 

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

  418. 

  419.   for ( uint16_t i = 0; i < _available; i++ ) {

  420.     Serial.print("[");

  421.     Serial.print((head+i)&(_size-1)); Serial.print("]      \t");

  422.   }

  423. 

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

  425. 

  426.   for ( uint16_t i = 0; i < _available; i++ ) {

  427.     if ( (int)_cbuf[((head+i)&(_size-1))] != (T)_cbuf[((head+i)&(_size-1))] ) { // possible float?

  428.       Serial.print(_cbuf[((head+i)&(_size-1))],7); Serial.print("\t");

  429.     }

  430.     else {

  431.       Serial.print(_cbuf[((head+i)&(_size-1))]); Serial.print("\t\t");

  432.     }

  433.   } Serial.println('\n');

  434. 

  435. 

  436. 

  437. 

  438.   return _available;

  439. }

  440. 

  441. template<typename T, uint16_t _size, uint16_t multi>

  442. T Circular_Buffer<T,_size,multi>::read() {

  443.   if ( multi ) {

  444.     head = ((head + 1)&(2*_size-1));

  445.     if ( _available ) _available--;

  446.     return 0;

  447.   }

  448.   if ( _available ) _available--;

  449.   T value = _cbuf[((head)&(_size-1))];

  450.   head = ((head + 1)&(2*_size-1));

  451.   return value;

  452. }

  453. 

  454. template<typename T, uint16_t _size, uint16_t multi>

  455. T Circular_Buffer<T,_size,multi>::sum() {

  456.   if ( multi || !_available ) return 0;

  457.   T value = 0;

  458.   for ( uint16_t i = 0; i < _available; i++ ) value += _cbuf[((head+i)&(_size-1))];

  459.   return value;

  460. }

  461. 

  462. template<typename T, uint16_t _size, uint16_t multi>

  463. T Circular_Buffer<T,_size,multi>::average() {

  464.   if ( multi || !_available ) return 0;

  465.   return sum()/_available;

  466. }

  467. 

  468. template<typename T, uint16_t _size, uint16_t multi>

  469. T Circular_Buffer<T,_size,multi>::variance() {

  470.   if ( multi || !_available ) return 0;

  471.   T _mean = average();

  472.   T value = 0;

  473.   for ( uint16_t i = 0; i < _available; i++ ) {

  474.     value += ((_cbuf[((head+i)&(_size-1))] - _mean) * (_cbuf[((head+i)&(_size-1))] - _mean));

  475.   }

  476.   value /= _available;

  477.   return value;

  478. }

  479. 

  480. template<typename T, uint16_t _size, uint16_t multi>

  481. T Circular_Buffer<T,_size,multi>::deviation() {

  482.   if ( multi || !_available ) return 0;

  483.   return sqrt(variance());

  484. }

  485. 

  486. template<typename T, uint16_t _size, uint16_t multi>

  487. T Circular_Buffer<T,_size,multi>::peek(uint16_t pos) {

  488.   if ( multi ) return 0;

  489.   if ( pos > _size ) return 0;

  490.   return _cbuf[((head+pos)&(_size-1))];

  491. }

  492. 

  493. template<typename T, uint16_t _size, uint16_t multi>

  494. void Circular_Buffer<T,_size,multi>::sort_ascending() {

  495.   if ( multi || !_available ) return;

  496.   T buffer[_available];

  497.   for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];

  498.   std::sort(&buffer[0], &buffer[_available]); // sort ascending

  499.   for ( uint16_t i = 0; i < _available; i++ ) _cbuf[((head+i)&(_size-1))] = buffer[i];

  500. }

  501. 

  502. template<typename T, uint16_t _size, uint16_t multi>

  503. void Circular_Buffer<T,_size,multi>::sort_descending() {

  504.   if ( multi || !_available ) return;

  505.   sort_ascending();

  506.   T buffer[_available];

  507.   for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];

  508.   std::reverse(&buffer[0], &buffer[_available]); // sort descending

  509.   for ( uint16_t i = 0; i < _available; i++ ) _cbuf[((head+i)&(_size-1))] = buffer[i];

  510. }

  511. 

  512. template<typename T, uint16_t _size, uint16_t multi>

  513. T Circular_Buffer<T,_size,multi>::median(bool override) {

  514.   if ( multi || !_available ) return 0;

  515.   if ( override ) sort_ascending();

  516.   else {

  517.     T buffer[_available];

  518.     for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];

  519.     std::sort(&buffer[0], &buffer[_available]); // sort ascending

  520.   }

  521.   if ( !(_available % 2) ) {

  522.     return ( _cbuf[((head+((_available/2)-1))&(_size-1))]  +  _cbuf[((head+(_available/2))&(_size-1))] ) /2;

  523.   }

  524.   else return _cbuf[((head+((_available/2)))&(_size-1))];  

  525.   return 0;

  526. }

  527. 

  528. template<typename T, uint16_t _size, uint16_t multi>

  529. T Circular_Buffer<T,_size,multi>::max() {

  530.   if ( multi || !_available ) return 0;

  531.   T buffer[_available];

  532.   for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];

  533.   std::sort(&buffer[0], &buffer[_available]); // sort ascending

  534.   return buffer[_available-1];

  535. }

  536. template<typename T, uint16_t _size, uint16_t multi>

  537. T Circular_Buffer<T,_size,multi>::min() {

  538.   if ( multi || !_available ) return 0;

  539.   T buffer[_available];

  540.   for ( uint16_t i = 0; i < _available; i++ ) buffer[i] = _cbuf[((head+i)&(_size-1))];

  541.   std::sort(&buffer[0], &buffer[_available]); // sort ascending

  542.   return buffer[0];

  543. }

  544. 

  545. template<typename T, uint16_t _size, uint16_t multi>

  546. T Circular_Buffer<T,_size,multi>::peekBytes(T *buffer, uint16_t length) {

  547.   if ( multi ) return 0;

  548.   uint16_t _count;

  549.   ( _available < length ) ? _count = _available : _count = length;

  550.   if ( _count < ( _size - head ) ) memmove(buffer,_cbuf,_count*sizeof(T));

  551.   else for ( uint16_t i = 0; i < _count; i++ ) buffer[i] = peek(i);

  552.   return _count;

  553. }

  554. 

  555. 

  556. template<typename T, uint16_t _size, uint16_t multi>

  557. T Circular_Buffer<T,_size,multi>::peek_front(T *buffer, uint16_t length, uint32_t entry) {

  558.   if ( multi ) {

  559.     memmove(&buffer[0],&_cabuf[((head+entry)&(_size-1))][2],length*sizeof(T)); // update CA buffer

  560.     return 0;

  561.   }

  562. }

  563. 

  564. template<typename T, uint16_t _size, uint16_t multi>

  565. T Circular_Buffer<T,_size,multi>::readBytes(T *buffer, uint16_t length) {

  566.   if ( multi ) {

  567.     memmove(&buffer[0],&_cabuf[((head)&(_size-1))][2],length*sizeof(T)); // update CA buffer

  568.     read();

  569.     return 0;

  570.   }

  571.   uint16_t _count;

  572.   ( _available < length ) ? _count = _available : _count = length; // memmove if aligned

  573.   if ( _count < ( _size - head ) ) {

  574.     _available -= length;

  575.     memmove(buffer,_cbuf,_count*sizeof(T));

  576.     head = ((head + _count)&(2*_size-1));

  577.   }

  578.   else for ( uint16_t i = 0; i < _count; i++ ) buffer[i] = read(); // if buffer rollover

  579.   return _count;

  580. }

  581. 

  582. template<typename T, uint16_t _size, uint16_t multi>

  583. T Circular_Buffer<T,_size,multi>::pop_back(T *buffer, uint16_t length) {

  584.   if ( multi ) {

  585.     memmove(&buffer[0],&_cabuf[((tail-1)&(_size-1))][2],length*sizeof(T));

  586.     tail = (tail - 1)&(2*_size-1);

  587.     if ( _available ) _available--;

  588.     return 0;

  589.   }

  590. }

  591. 

  592. #endif // Circular_Buffer_H