Diff: SnEventFrame.h

Revision:

0:664899e0b988

Child:

1:e392595b4b76

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SnEventFrame.h	Sat Jun 30 02:03:51 2012 +0000
@@ -0,0 +1,134 @@
+#ifndef SN_SnEventFrame
+#define SN_SnEventFrame
+
+#include <stdint.h>
+#include "SnConstants.h"
+
+class SnEventFrame {
+    
+ public:
+    // i/o version
+    static const int8_t     kIOVers = 1;   // MUST BE INCREASED if any member var changes (==> also if kNchans, etc. change!)
+    static const uint32_t   kMaxSizeOf = 
+            ((sizeof(uint32_t)*4u)+sizeof(int32_t)+sizeof(uint16_t)
+            +(kTotSamps*sizeof(uint16_t))+1u);
+
+ private:
+    // !!
+    // !! If any member variables change, update: SizeOf function and kIOVers value! (also if kNchans, etc. change!)
+    // !!
+    
+    uint16_t            fData[kTotSamps];  // the (uncompressed) waveform data
+    uint32_t            fMbedTime;         // mbed time in seconds since epoch
+    // TODO: time since last event?
+    uint32_t            fEvtNum;           // written event number ...
+     int32_t            fDTms;             // time since last written event (ms)
+    uint32_t            fTrgNum;           // this event is trigger number ...
+    uint16_t            fTrgBits;          // trigger bit word
+    mutable uint32_t    fCRC;              // CRC on the uncompressed waveform data
+    // TODO: check if other parameters should be added:
+    // - stop position?
+    // - card(s) producing trigger?
+    // - power & voltage during acquisition?
+    
+    void            CalcCRC();
+    
+    static
+    bool ReadFromFileToBuf(FILE* f,
+                           char* const evtBuf,
+                           const uint8_t loseLSB, const uint8_t loseMSB);
+
+    static
+    bool WriteToFileFromBuf(FILE* f, char* const evtBuf,
+                            const uint8_t loseLSB, const uint8_t loseMSB);
+    
+ public:
+    SnEventFrame() { ClearEvent(); }
+    virtual ~SnEventFrame() {}
+    
+    const uint16_t* GetData() const { return fData; }
+          uint16_t* GetData()       { return fData; }
+    const uint16_t* GetData(const uint8_t ch) const { return fData + (ch*kNsamps); }
+          uint16_t* GetData(const uint8_t ch)       { return fData + (ch*kNsamps); }
+          uint16_t  GetData(const uint8_t ch, const uint8_t sm) const
+        { return fData[(ch*kNsamps)+sm]; }
+          uint16_t& GetData(const uint8_t ch, const uint8_t sm)
+        { return fData[(ch*kNsamps)+sm]; }
+    
+    void ClearEvent() {
+        fMbedTime = fEvtNum = fTrgNum = 0;
+        fTrgBits = 0;
+        memset(fData, 0, kTotSamps*sizeof(int16_t));
+        fCRC = 0;
+    }
+    
+    void SetTrgBit(const ESnTrgTypes t) { fTrgBits |= kTrgBW[t]; }
+    void SetTrgNum(const uint32_t t)    { fTrgNum = t; }
+    void SetEvtNum(const uint32_t n)    { fEvtNum = n; }
+    void SetDTms(const int32_t dtms)    { fDTms = dtms; }
+    void SetCurMbedTime()               { fMbedTime = time(0); }
+    
+    bool IsForcedTrg() const { return (fTrgBits & kTrgBW[kFrcTrg])!=0; }
+    
+    void ReadWaveforms(SPI& spi,
+                       DigitalOut& cardHiBit, DigitalOut& cardLoBit) {
+        uint16_t* dev=fData;
+        for( uint8_t ch = 0; ch < kNchans; ch++ ) {
+            // Pick which register to read.
+            SnBitUtils::SetChanNumBits(ch, cardHiBit, cardLoBit);
+            for( uint8_t i = 0; i < kNsamps; i++, dev++ ) {        
+                *dev = spi.write(0x00) >> 1;
+                //fprintf(stderr,"ch%hhd, s%03hhd = %hd\r\n",ch,i,*dev);
+            }
+        }
+        CalcCRC();
+    }
+    
+    static
+    uint32_t SizeOf(const uint8_t loseLSB, const uint8_t loseMSB) {
+        // size of member vars + size of packed waveform + 1 for i/o version
+        if ((loseLSB==0) && (loseMSB==0)) {
+            return kMaxSizeOf;
+        } else {
+            return (kMaxSizeOf-(kTotSamps*sizeof(uint16_t))
+                               +SizeOfPackedWavef(loseLSB, loseMSB));
+        }
+    }
+    
+    static
+    uint32_t SizeOfPackedWavef(const uint8_t loseLSB,
+                               const uint8_t loseMSB) {
+        const uint8_t p = BITS_IN_SHORT-loseLSB-loseMSB;
+        return ((p*kTotSamps)/8u) + (((p*kTotSamps)%8u)!=0 ? 1u : 0u);
+    }
+    
+    void ReadFrom(const char* const buf,
+                  const uint8_t loseLSB, const uint8_t loseMSB,
+                  const uint16_t wvBaseline);
+    
+    void WriteTo(char* const buf,
+                 const uint8_t loseLSB, const uint8_t loseMSB,
+                 const uint16_t wvBaseline) const;
+    
+    bool ReadFrom(FILE* f, char* const evtBuf,
+                  const uint8_t loseLSB, const uint8_t loseMSB,
+                  const uint16_t wvBaseline);
+    bool WriteTo(FILE* f, char* const evtBuf,
+                 const uint8_t loseLSB, const uint8_t loseMSB,
+                 const uint16_t wvBaseline) const;
+        
+    static
+    const uint8_t* UnpackWavef(const uint8_t* const buf,
+                               uint16_t* const data,
+                               const uint8_t loseLSB,
+                               const uint8_t loseMSB,
+                               const uint16_t wvBaseline);
+    
+    static
+    uint8_t* PackWavef(uint8_t* const buf, const uint16_t* const data,
+                       const uint8_t loseLSB, const uint8_t loseMSB,
+                       const uint16_t wvBaseline);
+};
+
+
+#endif // SN_SnEventFrame