RingBuffer.h

00001 #include "mbed.h"
00002 
00003 #ifndef RingBuffer_h
00004 #define RingBuffer_h
00005 
00006 /*! Diese Klasse erstellt einen 32 Bit Ringbuffer mit einen vom Nutzer vorgegebenen Größenbereich. In dem Ringbuffer können 
00007 entsprechend 32 Bit Daten für Messaufzeichnungen genutzt werden. Zudem gibt es 8 Bit in einem Statusregister die frei definiert
00008 werden können. Es gibt für jedes einzelne Bit des Statusregisters eine Setter und Getter Methode. Nachdem der Ringbuffer komplett 
00009 beschrieben wurde, wird wieder der erste Wert überschrieben. Wenn der Abstand zwischen Lese- und Schreibezeiger zu gering wird,
00010 kann eine vom User definierte Funktion aufgerufen werden.
00011  * @code
00012  * #include "mbed.h"
00013  * #include "RingBuffer.h"
00014  *
00015  * int Event_Routine(){ .... }                        // Irgendeine Funktion die bei fast vollem Fifo aufgerufen wird           
00016  *
00017  * bool write;
00018  * uint8_t status;
00019  *
00020  * int main() {
00021  *    
00022  *     Ringbuffer adcbuffer(250);                       // Erstellen einer Instanz mit 250 Werten
00023  * 
00024  *     write = adcbuffer.writeBuffer(16658);            // Schreibt einen Wert in den Buffer. Wenn Rückgabe write
00025  *                                                      // true ist wurde dieser erfolgreich beschrieben.
00026  *
00027  *     adcbuffer.setBF_METHODE(Event_Routine);          // Bei fast vollem Fifo wird die Routine aufgerufen
00028  *
00029  *     adcbuffer.setBufferStatus(4);                    // Setzt das 4. Bit des Statusregisters
00030  *
00031  *     adcbuffer.resetBufferStatus(6);                  // Löscht das 6. Bit des Statusregisters
00032  *
00033  *     status = adcbuffer.getBufferStatus();            // Liest das Statusregister aus
00034  *
00035  *      while(1){
00036  *        printf("Value: %i\r\n", adcbuffer.readBuffer());   // Ausgabe der geschriebenen Werte
00037  *      }
00038  *    }
00039  *
00040  * @endcode
00041  */
00042 
00043 
00044 class RingBuffer 
00045 {
00046 
00047     public:
00048     /*! Konstruktor zum Erstellen einer Instanz mit einer vom User festgelegten Größe */
00049     /*!
00050         \param size <b>Größe</b> Anzahl der maximal gespeicherten Werte im Buffer
00051     */     
00052     RingBuffer (const int size);
00053     
00054     /*! Destruktor entfernt den RingBuffer */
00055     ~RingBuffer (){};
00056     
00057     /*! Schreibt Daten in die aktuelle Zelle. Wenn die Rückgabe true ist, dann wurde der Wert geschrieben. Wenn nicht, ist der Buffer voll.  */
00058     /*!
00059         \param inputdata <b>Daten</b> 32 Bit Integer Daten für die aktuelle Zelle
00060     */     
00061     bool writeBuffer (uint32_t inputdata);
00062 
00063     /*! Setzt ein Bit im Statusvektor des Buffers. Wenn der Rückgabewert True ist, würde der Wert übernommen*/
00064     /*!
00065         \param bit  Welches Bit der Zelle gesetzt werden soll
00066     */     
00067     bool setBufferStatus (int bit);
00068  
00069     /*!ResSetzt ein Bit im Statusvektor des Buffers. Wenn der Rückgabewert True ist, würde der Wert übernommen*/
00070     /*!
00071         \param bit  Welches Bit der Zelle zurück gesetzt werden soll
00072     */     
00073     bool resetBufferStatus (int bit);
00074     
00075     
00076     /*! Liest den Status aus der aktuelle Zelle und gibt diesen zurück. */    
00077     uint8_t getBufferStatus ();
00078     
00079  
00080     /*! Liest Daten aus der aktuelle Zelle. Wenn die Werte nicht ausgelesen werden konnten, dann ist der Rückgabewert 0 */    
00081     uint32_t readBuffer ();
00082       
00083      /*! Setzt eine weitere Routine die verwendet werden kann, wenn der Buffer fast voll ist. Um die Daten z.B. zu übernehmen */ 
00084      /*!
00085            \param BUFFER_HANDLER Adresse zur weiteren Routine
00086      */ 
00087     void setBF_METHODE (void (*BUFFER_HANDLER)(void));   
00088     
00089     protected:   
00090     //! Größe des Buffers
00091     int buffer_size;
00092     //! Lesezeiger der auf die nächste zulesenede Stelle zeigt
00093     uint32_t read_pointer;
00094     //! Schreibzeiger der auf die nächste zubeschreibene Stelle zeigt
00095     uint32_t write_pointer; 
00096     //! Buffer ist voll
00097     bool bufferfull;
00098     //! Buffer ist leer
00099     bool bufferempty;
00100     //! Freigabe zur Verwendung externer Funktionen 
00101     bool extfct;
00102     //! Externe Funktion bei fast vollem Buffer aufrufen
00103     void (*BUFFER_HANDLER)(void);  
00104     
00105     private:
00106     //! Eigentlicher Datenspeicher mit einem 32Bit Daten- und einem 8Bit Statusvektor    
00107     struct buffer          
00108     {       uint32_t *data;
00109             uint8_t *status;   
00110      };
00111     //Erstellt eine Instanz des Buffers
00112     buffer buffer;       
00113             
00114 };
00115     
00116 
00117 #endif