Jordan Hanson / Mbed 2 deprecated AutonomousDAQ

Arianna autonomous DAQ firmware

Dependencies:   mbed SDFileSystemFilinfo AriSnProtocol NetServicesMin AriSnComm MODSERIAL PowerControlClkPatch DS1820OW

SnEventFrame.h@116:8099b754fbb4, 2016-05-03 (annotated)

Committer:
uci1
Date:
Tue May 03 02:01:35 2016 +0000
Revision:
116:8099b754fbb4
Parent:
114:554fa3a956b4
Child:
119:b3d7699d0eb0
One program for all stns via UID/MAC lookup table or generation. Status sends number trg/evt and livetime, not rates. Add 512 sample evt and RFFT-LUTs. Add L1Scaledown trg bit. Allow skip SST reset at start. Fix dt at end of seq. End of comm signal.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
uci1 0:664899e0b988 1 #ifndef SN_SnEventFrame
uci1 0:664899e0b988 2 #define SN_SnEventFrame
uci1 0:664899e0b988 3
uci1 0:664899e0b988 4 #include <stdint.h>
uci1 0:664899e0b988 5 #include "SnConstants.h"
uci1 0:664899e0b988 6
uci1 15:f2569d8e4176 7 //#define EVDEBUG
uci1 15:f2569d8e4176 8
uci1 0:664899e0b988 9 class SnEventFrame {
uci1 0:664899e0b988 10
uci1 0:664899e0b988 11 public:
uci1 0:664899e0b988 12 // i/o version
uci1 8:95a325df1f6b 13 static const uint8_t kIOVers; // MUST BE INCREASED if any member var changes (==> also if kNchans, etc. change!)
uci1 56:0bba0ef15697 14 static const uint32_t kMaxSizeOfV1 =
uci1 0:664899e0b988 15 ((sizeof(uint32_t)*4u)+sizeof(int32_t)+sizeof(uint16_t)
uci1 56:0bba0ef15697 16 +(kTotSampsAtwd4ch*sizeof(uint16_t))+1u);
uci1 56:0bba0ef15697 17 static const uint32_t kMaxSizeOfV2 = kMaxSizeOfV1
uci1 116:8099b754fbb4 18 - (kTotSampsAtwd4ch*sizeof(uint16_t))
uci1 116:8099b754fbb4 19 + (kTotSampsSst4ch*sizeof(uint16_t))
uci1 56:0bba0ef15697 20 + (kNstopBytesSst4ch*sizeof(uint8_t));
uci1 116:8099b754fbb4 21 static const uint32_t kMaxSizeOfV3 = kMaxSizeOfV2; // same as V2 (just 1GHz clock)
uci1 116:8099b754fbb4 22 static const uint32_t kMaxSizeOfV4 = kMaxSizeOfV1
uci1 116:8099b754fbb4 23 - (kTotSampsAtwd4ch*sizeof(uint16_t))
uci1 116:8099b754fbb4 24 + (kTotSampsSst4ch512*sizeof(uint16_t))
uci1 116:8099b754fbb4 25 + (kNstopBytesSst4ch512*sizeof(uint8_t));
uci1 116:8099b754fbb4 26 static const uint32_t kMaxSizeOfV5 = kMaxSizeOfV4; // same as V4 (just 1GHz clock)
uci1 116:8099b754fbb4 27 static const uint32_t kMaxSizeOf = kMaxSizeOfV5; // biggest one
uci1 0:664899e0b988 28
uci1 0:664899e0b988 29 private:
uci1 0:664899e0b988 30 // !!
uci1 0:664899e0b988 31 // !! If any member variables change, update: SizeOf function and kIOVers value! (also if kNchans, etc. change!)
uci1 0:664899e0b988 32 // !!
uci1 0:664899e0b988 33
uci1 0:664899e0b988 34 uint16_t fData[kTotSamps]; // the (uncompressed) waveform data
uci1 0:664899e0b988 35 uint32_t fMbedTime; // mbed time in seconds since epoch
uci1 0:664899e0b988 36 // TODO: time since last event?
uci1 0:664899e0b988 37 uint32_t fEvtNum; // written event number ...
uci1 0:664899e0b988 38 int32_t fDTms; // time since last written event (ms)
uci1 0:664899e0b988 39 uint32_t fTrgNum; // this event is trigger number ...
uci1 0:664899e0b988 40 uint16_t fTrgBits; // trigger bit word
uci1 0:664899e0b988 41 mutable uint32_t fCRC; // CRC on the uncompressed waveform data
uci1 56:0bba0ef15697 42 #if CHIPBOARD!=ATWD4CH
uci1 56:0bba0ef15697 43 uint8_t fStop[kNstopBytes];// the stop bit word (one bit per sample)
uci1 56:0bba0ef15697 44 #endif
uci1 0:664899e0b988 45 // TODO: check if other parameters should be added:
uci1 0:664899e0b988 46 // - stop position?
uci1 0:664899e0b988 47 // - card(s) producing trigger?
uci1 0:664899e0b988 48
uci1 0:664899e0b988 49 void CalcCRC();
uci1 0:664899e0b988 50
uci1 0:664899e0b988 51 static
uci1 0:664899e0b988 52 bool ReadFromFileToBuf(FILE* f,
uci1 0:664899e0b988 53 char* const evtBuf,
uci1 0:664899e0b988 54 const uint8_t loseLSB, const uint8_t loseMSB);
uci1 0:664899e0b988 55
uci1 0:664899e0b988 56 static
uci1 0:664899e0b988 57 bool WriteToFileFromBuf(FILE* f, char* const evtBuf,
uci1 0:664899e0b988 58 const uint8_t loseLSB, const uint8_t loseMSB);
uci1 0:664899e0b988 59
uci1 0:664899e0b988 60 public:
uci1 84:80b15993944e 61 SnEventFrame() { ClearEvent(true, true); }
uci1 0:664899e0b988 62 virtual ~SnEventFrame() {}
uci1 40:1324da35afd4 63
uci1 40:1324da35afd4 64 virtual void CopyTo(SnEventFrame& evt) const {
uci1 56:0bba0ef15697 65 if (&evt!=this) {
uci1 56:0bba0ef15697 66 evt.fMbedTime = fMbedTime;
uci1 56:0bba0ef15697 67 evt.fEvtNum = fEvtNum;
uci1 56:0bba0ef15697 68 evt.fDTms = fDTms;
uci1 56:0bba0ef15697 69 evt.fTrgNum = fTrgNum;
uci1 56:0bba0ef15697 70 evt.fTrgBits = fTrgBits;
uci1 56:0bba0ef15697 71 evt.fCRC = fCRC;
uci1 56:0bba0ef15697 72 memcpy(evt.fData, fData, kTotSamps*sizeof(uint16_t));
uci1 56:0bba0ef15697 73 #if CHIPBOARD!=ATWD4CH
uci1 56:0bba0ef15697 74 memcpy(evt.fStop, fStop, kNstopBytes*sizeof(uint8_t));
uci1 56:0bba0ef15697 75 #endif
uci1 56:0bba0ef15697 76 }
uci1 40:1324da35afd4 77 }
uci1 0:664899e0b988 78
uci1 0:664899e0b988 79 const uint16_t* GetData() const { return fData; }
uci1 0:664899e0b988 80 uint16_t* GetData() { return fData; }
uci1 0:664899e0b988 81 const uint16_t* GetData(const uint8_t ch) const { return fData + (ch*kNsamps); }
uci1 0:664899e0b988 82 uint16_t* GetData(const uint8_t ch) { return fData + (ch*kNsamps); }
uci1 56:0bba0ef15697 83 uint16_t GetData(const uint8_t ch, const uint16_t sm) const
uci1 0:664899e0b988 84 { return fData[(ch*kNsamps)+sm]; }
uci1 56:0bba0ef15697 85 uint16_t& GetData(const uint8_t ch, const uint16_t sm)
uci1 0:664899e0b988 86 { return fData[(ch*kNsamps)+sm]; }
uci1 0:664899e0b988 87
uci1 56:0bba0ef15697 88 #if CHIPBOARD!=ATWD4CH
uci1 56:0bba0ef15697 89 const uint8_t* GetStop() const { return fStop; }
uci1 56:0bba0ef15697 90 uint8_t* GetStop() { return fStop; }
uci1 56:0bba0ef15697 91 #endif
uci1 56:0bba0ef15697 92
uci1 22:f957c4f840ad 93 uint32_t GetMbedTime() const { return fMbedTime; }
uci1 84:80b15993944e 94 uint32_t GetEvtNum() const { return fEvtNum; }
uci1 84:80b15993944e 95 int32_t GetDTms() const { return fDTms; }
uci1 84:80b15993944e 96 uint32_t GetTrgNum() const { return fTrgNum; }
uci1 84:80b15993944e 97 uint16_t GetTrgBits() const { return fTrgBits; }
uci1 84:80b15993944e 98 uint32_t GetCRC() const { return fCRC; }
uci1 22:f957c4f840ad 99
uci1 84:80b15993944e 100 void ClearEvent(const bool clearTrigs,
uci1 84:80b15993944e 101 const bool clearWaveData) {
uci1 21:ce51bb0ba4a5 102 #ifdef EVDEBUG
uci1 21:ce51bb0ba4a5 103 printf("CLEARING EVENT!\r\n");
uci1 21:ce51bb0ba4a5 104 #endif
uci1 22:f957c4f840ad 105 fMbedTime = 0;
uci1 84:80b15993944e 106
uci1 84:80b15993944e 107 if (clearWaveData) {
uci1 84:80b15993944e 108 memset(fData, 0, kTotSamps*sizeof(int16_t));
uci1 56:0bba0ef15697 109 #if CHIPBOARD!=ATWD4CH
uci1 84:80b15993944e 110 memset(fStop, 0, kNstopBytes*sizeof(uint8_t));
uci1 56:0bba0ef15697 111 #endif
uci1 84:80b15993944e 112 fCRC = 0;
uci1 84:80b15993944e 113 }
uci1 84:80b15993944e 114 if (clearTrigs) {
uci1 22:f957c4f840ad 115 fEvtNum = fTrgNum = 0;
uci1 22:f957c4f840ad 116 fTrgBits = 0;
uci1 22:f957c4f840ad 117 }
uci1 0:664899e0b988 118 }
uci1 0:664899e0b988 119
uci1 84:80b15993944e 120 void SetTrgBit(const ETrgBit_t t) { fTrgBits |= t; }
uci1 116:8099b754fbb4 121 void DisableTrgBit(const ETrgBit_t b) { fTrgBits &= ~b; }
uci1 0:664899e0b988 122 void SetTrgNum(const uint32_t t) { fTrgNum = t; }
uci1 0:664899e0b988 123 void SetEvtNum(const uint32_t n) { fEvtNum = n; }
uci1 0:664899e0b988 124 void SetDTms(const int32_t dtms) { fDTms = dtms; }
uci1 0:664899e0b988 125 void SetCurMbedTime() { fMbedTime = time(0); }
uci1 0:664899e0b988 126
uci1 84:80b15993944e 127 // bool IsForcedTrg() const { return (fTrgBits & kFrcTrg)!=0; }
uci1 0:664899e0b988 128
uci1 56:0bba0ef15697 129 #if CHIPBOARD!=ATWD4CH
uci1 56:0bba0ef15697 130 void ReadWaveformsSST(SPI& spi, DigitalOut& readingData) {
uci1 56:0bba0ef15697 131 readingData = 1; // start reading
uci1 56:0bba0ef15697 132
uci1 56:0bba0ef15697 133 // first get waveform data
uci1 56:0bba0ef15697 134 uint16_t* d = fData;
uci1 56:0bba0ef15697 135 for (uint8_t ch=0; ch<kNchans; ++ch) {
uci1 56:0bba0ef15697 136 #ifdef EVDEBUG
uci1 56:0bba0ef15697 137 printf("new channel %hhu\r\n",ch);
uci1 56:0bba0ef15697 138 #endif
uci1 56:0bba0ef15697 139
uci1 56:0bba0ef15697 140 spi.format( 5, 1 ); // throw away leading bits (1 meaningless + 4 MSB 0's bits before 12 bit ADC value)
uci1 56:0bba0ef15697 141 spi.write(0); // get the throw away bits
uci1 56:0bba0ef15697 142 spi.format( 12, 1); // read remaining
uci1 56:0bba0ef15697 143
uci1 56:0bba0ef15697 144 for (uint16_t i=0; i<kNsamps; ++i, ++d) {
uci1 56:0bba0ef15697 145 *d = spi.write(0x00)/* >> 1*/; // get rid of stop bit (TODO: is this right?)
uci1 56:0bba0ef15697 146 if (i==0) {
uci1 56:0bba0ef15697 147 spi.format( 16, 1); // back to normal
uci1 56:0bba0ef15697 148 }
uci1 56:0bba0ef15697 149 #ifdef EVDEBUG
uci1 56:0bba0ef15697 150 if (i==0 || i==1) {
uci1 56:0bba0ef15697 151 printf("d: spi gave (%hu) ",*d);
uci1 56:0bba0ef15697 152 SnBitUtils::printBits(*d, false);
uci1 56:0bba0ef15697 153 }
uci1 56:0bba0ef15697 154 #endif
uci1 56:0bba0ef15697 155 }
uci1 56:0bba0ef15697 156 }
uci1 56:0bba0ef15697 157 // now get stop data
uci1 56:0bba0ef15697 158 uint8_t* s = fStop;
uci1 56:0bba0ef15697 159 uint16_t sd(0);
uci1 56:0bba0ef15697 160 for (uint16_t i=0; i<kNstopBytes; i+=2, s+=2) {
uci1 56:0bba0ef15697 161 if (i==0) {
uci1 56:0bba0ef15697 162 // need to throw away the very first bit
uci1 56:0bba0ef15697 163 // but we can't ask spi to send only 1 bit
uci1 56:0bba0ef15697 164 spi.format( 5, 1 );
uci1 56:0bba0ef15697 165 sd = spi.write(0x00);
uci1 56:0bba0ef15697 166 // toss the first bit totally
uci1 56:0bba0ef15697 167 // move the other 4 bits to the front
uci1 56:0bba0ef15697 168 sd <<= 12;
uci1 56:0bba0ef15697 169 spi.format( 12, 1); // read the rest of the real 16 bits
uci1 56:0bba0ef15697 170 sd |= spi.write(0x00);
uci1 56:0bba0ef15697 171 spi.format( 16, 1); // normal after this
uci1 56:0bba0ef15697 172 } else {
uci1 56:0bba0ef15697 173 sd = spi.write(0x00);
uci1 56:0bba0ef15697 174 }
uci1 56:0bba0ef15697 175 #ifdef EVDEBUG
uci1 56:0bba0ef15697 176 /*
uci1 56:0bba0ef15697 177 printf("s: spi gave (%hu) ",sd);
uci1 56:0bba0ef15697 178 SnBitUtils::printBits(sd, false);
uci1 56:0bba0ef15697 179 */
uci1 56:0bba0ef15697 180 #endif
uci1 56:0bba0ef15697 181 *s = (sd & 0xFF00) >> BITS_IN_CHAR;
uci1 56:0bba0ef15697 182 *(s+1) = sd & 0x00FF;
uci1 56:0bba0ef15697 183 }
uci1 56:0bba0ef15697 184 readingData = 0; // done reading
uci1 56:0bba0ef15697 185 /*
uci1 56:0bba0ef15697 186 // get rid of stop bit (TODO: is this right?)
uci1 56:0bba0ef15697 187 *s >>= 1;
uci1 56:0bba0ef15697 188 *s <<= 1;
uci1 56:0bba0ef15697 189 */
uci1 56:0bba0ef15697 190 #ifdef EVDEBUG
uci1 56:0bba0ef15697 191 /*
uci1 56:0bba0ef15697 192 d = fData;
uci1 56:0bba0ef15697 193 for (uint8_t ch=0; ch<kNchans; ch++) {
uci1 56:0bba0ef15697 194 for (uint16_t i=0; i<kNsamps; i++, d++) {
uci1 56:0bba0ef15697 195 printf("(%hhu,%03hhu,%hu) ",ch,i,*d);
uci1 56:0bba0ef15697 196 }
uci1 56:0bba0ef15697 197 printf("\r\n");
uci1 56:0bba0ef15697 198 }
uci1 56:0bba0ef15697 199 s = fStop;
uci1 56:0bba0ef15697 200 for (uint16_t i=0; i<kNstopBytes; ++i, ++s) {
uci1 56:0bba0ef15697 201 for (int16_t j=(sizeof(uint8_t)*BITS_IN_CHAR)-1; j>-1; --j) {
uci1 56:0bba0ef15697 202 if ( (*s&(1<<j))!=0 ) {
uci1 56:0bba0ef15697 203 printf("stop bit at %hu\r\n",
uci1 56:0bba0ef15697 204 j+(BITS_IN_CHAR*sizeof(uint8_t)*i));
uci1 56:0bba0ef15697 205 }
uci1 56:0bba0ef15697 206 }
uci1 56:0bba0ef15697 207 }
uci1 56:0bba0ef15697 208 */
uci1 56:0bba0ef15697 209 #endif
uci1 56:0bba0ef15697 210 CalcCRC();
uci1 56:0bba0ef15697 211 }
uci1 56:0bba0ef15697 212 #endif
uci1 56:0bba0ef15697 213
uci1 56:0bba0ef15697 214 void ReadWaveformsATWD(SPI& spi,
uci1 56:0bba0ef15697 215 DigitalOut& cardHiBit, DigitalOut& cardLoBit) {
uci1 0:664899e0b988 216 uint16_t* dev=fData;
uci1 0:664899e0b988 217 for( uint8_t ch = 0; ch < kNchans; ch++ ) {
uci1 0:664899e0b988 218 // Pick which register to read.
uci1 0:664899e0b988 219 SnBitUtils::SetChanNumBits(ch, cardHiBit, cardLoBit);
uci1 56:0bba0ef15697 220 for( uint16_t i = 0; i < kNsamps; i++, dev++ ) {
uci1 0:664899e0b988 221 *dev = spi.write(0x00) >> 1;
uci1 0:664899e0b988 222 }
uci1 0:664899e0b988 223 }
uci1 15:f2569d8e4176 224 #ifdef EVDEBUG
uci1 15:f2569d8e4176 225 dev = fData;
uci1 15:f2569d8e4176 226 for (uint8_t ch=0; ch<kNchans; ch++) {
uci1 56:0bba0ef15697 227 for (uint16_t i=0; i<kNsamps; i++, dev++) {
uci1 56:0bba0ef15697 228 printf("(%hhu,%03hhu,%hu) ",ch,i,*dev);
uci1 15:f2569d8e4176 229 }
uci1 15:f2569d8e4176 230 printf("\r\n");
uci1 15:f2569d8e4176 231 }
uci1 15:f2569d8e4176 232 #endif
uci1 0:664899e0b988 233 CalcCRC();
uci1 0:664899e0b988 234 }
uci1 0:664899e0b988 235
uci1 56:0bba0ef15697 236
uci1 56:0bba0ef15697 237 static
uci1 56:0bba0ef15697 238 uint16_t GetTotSamplesForIOVers(const uint8_t rv) {
uci1 56:0bba0ef15697 239 if (rv<2) {
uci1 56:0bba0ef15697 240 return kTotSampsAtwd4ch;
uci1 116:8099b754fbb4 241 } else if ((rv==2)||(rv==3)) {
uci1 116:8099b754fbb4 242 return kTotSampsSst4ch;
uci1 56:0bba0ef15697 243 } else {
uci1 116:8099b754fbb4 244 return kTotSampsSst4ch512;
uci1 56:0bba0ef15697 245 }
uci1 56:0bba0ef15697 246 }
uci1 56:0bba0ef15697 247
uci1 56:0bba0ef15697 248 static
uci1 56:0bba0ef15697 249 uint16_t GetStopBytesForIOVers(const uint8_t rv) {
uci1 56:0bba0ef15697 250 if (rv<2) {
uci1 56:0bba0ef15697 251 return 0;
uci1 116:8099b754fbb4 252 } else if ((rv==2)||(rv==3)) {
uci1 56:0bba0ef15697 253 return kNstopBytesSst4ch;
uci1 116:8099b754fbb4 254 } else {
uci1 116:8099b754fbb4 255 return kNstopBytesSst4ch512;
uci1 56:0bba0ef15697 256 }
uci1 56:0bba0ef15697 257 }
uci1 116:8099b754fbb4 258
uci1 116:8099b754fbb4 259 static
uci1 116:8099b754fbb4 260 uint16_t GetStopBytesForIOVersBufferSafe(const uint8_t rv) {
uci1 116:8099b754fbb4 261 // get the max number of stop bytes that will fit in an fStop buffer
uci1 116:8099b754fbb4 262 const uint16_t nsb = GetStopBytesForIOVers(rv);
uci1 116:8099b754fbb4 263 return (nsb>kNstopBytes) ? kNstopBytes : nsb; // prevent buffer overflow
uci1 116:8099b754fbb4 264 }
uci1 56:0bba0ef15697 265
uci1 0:664899e0b988 266 static
uci1 8:95a325df1f6b 267 uint32_t SizeOf(const uint8_t rv, const uint8_t loseLSB, const uint8_t loseMSB) {
uci1 0:664899e0b988 268 // size of member vars + size of packed waveform + 1 for i/o version
uci1 116:8099b754fbb4 269 #ifdef EVDEBUG
uci1 116:8099b754fbb4 270 printf("event: rv=%hhu, loseLBS=%hhu, loseMSB=%hhu\r\n", rv, loseLSB, loseMSB);
uci1 116:8099b754fbb4 271 #endif
uci1 56:0bba0ef15697 272 uint32_t sz(0);
uci1 56:0bba0ef15697 273 const uint16_t ntotsamps = GetTotSamplesForIOVers(rv);
uci1 56:0bba0ef15697 274 if (rv==1) {
uci1 56:0bba0ef15697 275 sz = kMaxSizeOfV1;
uci1 56:0bba0ef15697 276 } else if (rv==2) {
uci1 56:0bba0ef15697 277 sz = kMaxSizeOfV2;
uci1 114:554fa3a956b4 278 } else if (rv==3) {
uci1 114:554fa3a956b4 279 sz = kMaxSizeOfV3;
uci1 116:8099b754fbb4 280 } else if (rv==4) {
uci1 116:8099b754fbb4 281 sz = kMaxSizeOfV4;
uci1 116:8099b754fbb4 282 } else if (rv==5) {
uci1 116:8099b754fbb4 283 sz = kMaxSizeOfV5;
uci1 0:664899e0b988 284 } else {
uci1 56:0bba0ef15697 285 sz = kMaxSizeOf;
uci1 56:0bba0ef15697 286 }
uci1 116:8099b754fbb4 287 #ifdef EVDEBUG
uci1 116:8099b754fbb4 288 printf("event: ntotsamps=%hu, sz=%u\r\n", ntotsamps, sz);
uci1 116:8099b754fbb4 289 #endif
uci1 56:0bba0ef15697 290 if ((loseLSB==0) && (loseMSB==0)) {
uci1 56:0bba0ef15697 291 return sz;
uci1 56:0bba0ef15697 292 } else {
uci1 116:8099b754fbb4 293 #ifdef EVDEBUG
uci1 116:8099b754fbb4 294 printf("event packed size=%u\r\n",
uci1 116:8099b754fbb4 295 (sz-(ntotsamps*sizeof(uint16_t))
uci1 116:8099b754fbb4 296 +SizeOfPackedWavef(loseLSB, loseMSB)));
uci1 116:8099b754fbb4 297 #endif
uci1 56:0bba0ef15697 298 return (sz-(ntotsamps*sizeof(uint16_t))
uci1 56:0bba0ef15697 299 +SizeOfPackedWavef(loseLSB, loseMSB));
uci1 0:664899e0b988 300 }
uci1 0:664899e0b988 301 }
uci1 0:664899e0b988 302
uci1 0:664899e0b988 303 static
uci1 0:664899e0b988 304 uint32_t SizeOfPackedWavef(const uint8_t loseLSB,
uci1 0:664899e0b988 305 const uint8_t loseMSB) {
uci1 0:664899e0b988 306 const uint8_t p = BITS_IN_SHORT-loseLSB-loseMSB;
uci1 0:664899e0b988 307 return ((p*kTotSamps)/8u) + (((p*kTotSamps)%8u)!=0 ? 1u : 0u);
uci1 0:664899e0b988 308 }
uci1 0:664899e0b988 309
uci1 3:24c5f0f50bf1 310 const char* ReadFrom(const char* const buf,
uci1 3:24c5f0f50bf1 311 const uint8_t loseLSB, const uint8_t loseMSB,
uci1 3:24c5f0f50bf1 312 const uint16_t wvBaseline);
uci1 0:664899e0b988 313
uci1 3:24c5f0f50bf1 314 char* WriteTo(char* const buf,
uci1 3:24c5f0f50bf1 315 const uint8_t loseLSB, const uint8_t loseMSB,
uci1 3:24c5f0f50bf1 316 const uint16_t wvBaseline) const;
uci1 0:664899e0b988 317
uci1 0:664899e0b988 318 bool ReadFrom(FILE* f, char* const evtBuf,
uci1 0:664899e0b988 319 const uint8_t loseLSB, const uint8_t loseMSB,
uci1 0:664899e0b988 320 const uint16_t wvBaseline);
uci1 0:664899e0b988 321 bool WriteTo(FILE* f, char* const evtBuf,
uci1 0:664899e0b988 322 const uint8_t loseLSB, const uint8_t loseMSB,
uci1 0:664899e0b988 323 const uint16_t wvBaseline) const;
uci1 0:664899e0b988 324
uci1 0:664899e0b988 325 static
uci1 0:664899e0b988 326 const uint8_t* UnpackWavef(const uint8_t* const buf,
uci1 0:664899e0b988 327 uint16_t* const data,
uci1 0:664899e0b988 328 const uint8_t loseLSB,
uci1 0:664899e0b988 329 const uint8_t loseMSB,
uci1 56:0bba0ef15697 330 const uint16_t wvBaseline,
uci1 56:0bba0ef15697 331 const uint16_t nsamps);
uci1 0:664899e0b988 332
uci1 0:664899e0b988 333 static
uci1 0:664899e0b988 334 uint8_t* PackWavef(uint8_t* const buf, const uint16_t* const data,
uci1 0:664899e0b988 335 const uint8_t loseLSB, const uint8_t loseMSB,
uci1 56:0bba0ef15697 336 const uint16_t wvBaseline,
uci1 56:0bba0ef15697 337 const uint16_t nsamps);
uci1 0:664899e0b988 338 };
uci1 0:664899e0b988 339
uci1 0:664899e0b988 340
uci1 0:664899e0b988 341 #endif // SN_SnEventFrame