RingBuffer.cpp

00001 #include "mbed.h"
00002 #include "RingBuffer.h"
00003 
00004 //====================================================================================================================================
00005 //                                 Konstruktor und Schreib/Lese Funktionen
00006 //====================================================================================================================================
00007 
00008 RingBuffer::RingBuffer (const int size){
00009     
00010     buffer_size = size;                                                         // Ringbuffergröße festlegen
00011     buffer.data = new uint32_t [size];                                          // Setzt die Dimension des Daten Arrays
00012     buffer.status = new uint8_t [size];                                         // Setzt die Dimension des Status Arrays
00013     buffer.status[0] = 0x00;                                                    // Kein Status vorhanden bei Beginn
00014     
00015     extfct = false;                                                             // Externe Funktion bei fast vollem Buffer
00016     bufferfull = false;                                                         // Buffer ist voll, kein Schreiben möglich 
00017     bufferempty = true;                                                         // Buffer ist leer, kein Lesen möglich
00018     read_pointer = 0;                                                           // Lesezeiger auf Null setzen
00019     write_pointer = 0;                                                          // Schreibezeiger auf Null setzen   
00020      
00021 }
00022 
00023 bool RingBuffer::writeBuffer (uint32_t inputdata){                               // Funktion zum beschreiben des Buffers
00024 
00025     if(!bufferfull){                                                            // Prüfen ob der Buffer voll ist
00026 
00027         buffer.data[write_pointer] = inputdata;                                 // Schreibt Daten in die aktuelle Zelle
00028         write_pointer++;                                                        // Zählt den Schreibezeiger um eins Hoch
00029         buffer.status[write_pointer] = buffer.status[write_pointer - 1];        // Übernehme den vorherigen Statuswert
00030          
00031         if(write_pointer == buffer_size){                                       // Zeiger am Ende des Buffers
00032             write_pointer = 0;                                                  // Schreibezeiger auf Null setzen   
00033         }
00034     
00035         if(extfct && (read_pointer + buffer_size - write_pointer) < 10){       // Externe Methode bei einem Abstand im Fifo von kleiner 10
00036             (*BUFFER_HANDLER)();                                               // Aufruf der Externen Funktion   
00037         }
00038            
00039         if(write_pointer == read_pointer){                                      // Schreibzeiger steht auf Lesezeiger
00040             bufferfull = true;                                                  // Buffer voll, kann nicht mehr Beschrieben werden
00041 
00042         }
00043         else{
00044             bufferempty = false;                                                // Buffer ist nicht leer, kann gelesen werden
00045      
00046         } 
00047       return true;                                                              // Rückgabe das der Wert beschrieben worden ist       
00048     } 
00049       return false;                                                             // Rückgabe das der Wert nicht beschrieben worden ist              
00050 }
00051 
00052 uint32_t RingBuffer::readBuffer (){                                              // Funktion zum beschreiben des Buffers
00053 
00054         uint32_t outputdata;                                                    // Variable zur Übergabe der Daten
00055 
00056     if(!bufferempty){                                                           // Prüfen ob der Buffer leer ist
00057 
00058         outputdata = buffer.data[read_pointer];                                 // Auslesen des Wertes an der aktuellen Stelle
00059         read_pointer++;                                                         // Zählt den Lesezeiger um eins Hoch
00060              
00061         if(read_pointer == buffer_size){                                        // Zeiger am Ende des Buffers
00062             read_pointer = 0;                                                   // lesezeiger auf Null setzen   
00063         }
00064     
00065         if(read_pointer== write_pointer){                                       // Lesezeiger steht auf Schreibzeiger
00066             bufferempty = true;                                                 // Buffer leer, kann nicht mehr gelesen werden
00067         }
00068         else{
00069             bufferfull = false;                                                 // Buffer ist nicht voll, kann geschrieben werden     
00070         }
00071         
00072     }
00073     else{                                                                       // Buffer leer
00074         outputdata = 0x00;                                                      // Rückgabe = 0
00075     }
00076                 
00077     return outputdata;                                                          // Ausgabe des Werts
00078 } 
00079 
00080 //====================================================================================================================================
00081 //                                 Setter und Getter Funktionen
00082 //====================================================================================================================================
00083 
00084 uint8_t RingBuffer::getBufferStatus (){ 
00085     return buffer.status[read_pointer];                                          // Rückgabe des aktuellen Statuswerts
00086 }
00087 
00088 bool RingBuffer::setBufferStatus (int bit){ 
00089     
00090     if(bit < 8){
00091         buffer.status[write_pointer] |= (1 << bit);                               // Setzt das vorher ausgewählte Bit
00092         return true;                                                              // Setzen erfolgreich.       
00093      }
00094         
00095      return false;                                                                // Setzen nicht erfolgreich.        
00096 }
00097 
00098 bool RingBuffer::resetBufferStatus (int bit){ 
00099     
00100     if(bit < 8){
00101         buffer.status[write_pointer] ^= (1 << bit);                               // Resetzt das vorher ausgewählte Bit
00102         return true;                                                              // Restzen erfolgreich.       
00103      }
00104         
00105      return false;                                                                // Resetzen nicht erfolgreich.        
00106 }
00107 
00108 
00109 void RingBuffer::setBF_METHODE (void (*EXTERN_BUFFER_HANDLER)(void)){              // Adresse zur externen Funktion übergeben und Freigabe setzen
00110           extfct = true;                                                          // Externe Funktion vorhanden. Freigabe setzen.
00111           BUFFER_HANDLER = EXTERN_BUFFER_HANDLER;                                 // Funktionspointer der Funktion übernehmen     
00112     }