File content as of revision 12:d472f9811262:

#ifndef SN_SnEventFrame
#define SN_SnEventFrame

#include <stdint.h>
#include "SnConstants.h"

class SnEventFrame {
    
 public:
    // i/o version
    static const uint8_t    kIOVers;   // 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]; }
    
    uint32_t GetEvtNum() const { return fEvtNum; }
    
    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;
                //printf("ch%hhd, s%03hhd = %hd\r\n",ch,i,*dev);
            }
        }
        CalcCRC();
    }
    
    static
    uint32_t SizeOf(const uint8_t rv, 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);
    }
    
    const char* ReadFrom(const char* const buf,
                         const uint8_t loseLSB, const uint8_t loseMSB,
                         const uint16_t wvBaseline);
    
    char* 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