Jordan Hanson / Mbed 2 deprecated AutonomousDAQ

Arianna autonomous DAQ firmware

Dependencies:   mbed SDFileSystemFilinfo AriSnProtocol NetServicesMin AriSnComm MODSERIAL PowerControlClkPatch DS1820OW

SnConfigFrame.h@31:b5bd3b189150, 2013-01-23 (annotated)

Committer:
uci1
Date:
Wed Jan 23 19:29:01 2013 +0000
Revision:
31:b5bd3b189150
Parent:
30:f869ed4bcc08
Child:
39:2f17131d22a5
Added option in SnConstants to allow for proper switching of peripheral power in stations that have the Afar and Iridium power lines spliced together. Afar, SBD and Twitter comms enabled. Afar and Iridium powered together.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
uci1 3:24c5f0f50bf1 1 #ifndef SN_SnConfigFrame
uci1 3:24c5f0f50bf1 2 #define SN_SnConfigFrame
uci1 3:24c5f0f50bf1 3
uci1 3:24c5f0f50bf1 4 #include <stdint.h>
uci1 3:24c5f0f50bf1 5 #include "SnConstants.h"
uci1 3:24c5f0f50bf1 6 #include "SnBitUtils.h"
uci1 3:24c5f0f50bf1 7
uci1 16:744ce85aede2 8 //#define DEBUG
uci1 16:744ce85aede2 9
uci1 3:24c5f0f50bf1 10 class SnConfigFrame {
uci1 3:24c5f0f50bf1 11 public:
uci1 31:b5bd3b189150 12 static bool fgApplySafetyNets; // whether to apply safety bounds on certain parameters in ReadFrom (default: true)
uci1 31:b5bd3b189150 13
uci1 3:24c5f0f50bf1 14 static const uint32_t kMinCommWinPrdLowPwr; // exclusive min low power comm win period (s)
uci1 3:24c5f0f50bf1 15 static const uint32_t kMaxCommWinPrdLowPwr; // exclusive max low power comm win period (s)
uci1 3:24c5f0f50bf1 16 static const uint32_t kMinCommWinDurLowPwr; // exclusive min low power comm win duration (s)
uci1 3:24c5f0f50bf1 17 static const uint32_t kMaxCommWinDurLowPwr; // exclusive max low power comm win duration (s)
uci1 3:24c5f0f50bf1 18 static const uint8_t kConfLblLen=64; // length of configuration label char array (63+'\0')
uci1 8:95a325df1f6b 19 static const uint8_t kIPLen=16; // length of IP string. matches MBED's Socket class (so no ipv6)
uci1 3:24c5f0f50bf1 20
uci1 3:24c5f0f50bf1 21 static const char* const kDefConfFile; // default configuration file
uci1 28:484943132bb0 22 static const char* const kDefIPflag; // flag to use IP default
uci1 3:24c5f0f50bf1 23
uci1 8:95a325df1f6b 24 static const uint32_t kMaxSizeOfV1 =
uci1 8:95a325df1f6b 25 + (9u*sizeof(uint32_t)) + (6u*sizeof(uint16_t))
uci1 8:95a325df1f6b 26 + (10u*sizeof(uint8_t)) + (3u*kNplas*sizeof(uint16_t))
uci1 3:24c5f0f50bf1 27 + (kTotDacs*sizeof(uint16_t))
uci1 3:24c5f0f50bf1 28 + (kConfLblLen*sizeof(uint8_t));
uci1 8:95a325df1f6b 29 static const uint32_t kMaxSizeOfV2 =
uci1 8:95a325df1f6b 30 kMaxSizeOfV1 + sizeof(uint32_t) + sizeof(uint8_t);
uci1 8:95a325df1f6b 31 static const uint32_t kMaxSizeOfV3 =
uci1 8:95a325df1f6b 32 kMaxSizeOfV2 + (2u*sizeof(uint16_t)) + (4u*kIPLen*sizeof(char));
uci1 18:55f1581f2ee4 33 static const uint32_t kMaxSizeOfV4 = kMaxSizeOfV3 + (sizeof(float)-sizeof(uint16_t));
uci1 18:55f1581f2ee4 34 static const uint32_t kMaxSizeOf = kMaxSizeOfV4;
uci1 3:24c5f0f50bf1 35
uci1 3:24c5f0f50bf1 36 enum EDatPackBit {
uci1 3:24c5f0f50bf1 37 kSDcard = BIT(0),
uci1 3:24c5f0f50bf1 38 kIrid = BIT(1),
uci1 3:24c5f0f50bf1 39 kAfar = BIT(2),
uci1 3:24c5f0f50bf1 40 kUSB = BIT(3)
uci1 3:24c5f0f50bf1 41 };
uci1 3:24c5f0f50bf1 42
uci1 3:24c5f0f50bf1 43 enum ESendDataBit {
uci1 3:24c5f0f50bf1 44 // can't use BIT(0)! (-0 = 0 => send nothing)
uci1 13:7a1fb885a8e4 45 kAllFiles = BIT(1), // if bit=0 => send most recent file
uci1 13:7a1fb885a8e4 46 kTimeout = BIT(2), // if bit=0 => ignore timeout
uci1 13:7a1fb885a8e4 47 kDelete = BIT(3), // if bit=0 => do not delete sent files
uci1 13:7a1fb885a8e4 48 kForceSBDdata = BIT(4), // if bit=0 => do not send data over SBD
uci1 13:7a1fb885a8e4 49 kUseBits = -BIT(15) // useful to initialize fCommSendData as a bit word
uci1 3:24c5f0f50bf1 50 };
uci1 3:24c5f0f50bf1 51
uci1 4:a91682e19d6b 52 enum EPowerModeBit {
uci1 4:a91682e19d6b 53 kAmpsDatTak = BIT(0),
uci1 4:a91682e19d6b 54 kCardDatTak = BIT(1),
uci1 4:a91682e19d6b 55 kIridDatTak = BIT(2),
uci1 4:a91682e19d6b 56 kAfarDatTak = BIT(3),
uci1 4:a91682e19d6b 57 kAmpsComWin = BIT(4),
uci1 4:a91682e19d6b 58 kCardComWin = BIT(5),
uci1 4:a91682e19d6b 59 kIridComWin = BIT(6),
uci1 4:a91682e19d6b 60 kAfarComWin = BIT(7)
uci1 4:a91682e19d6b 61 };
uci1 4:a91682e19d6b 62
uci1 3:24c5f0f50bf1 63 enum ERunMode {
uci1 8:95a325df1f6b 64 kSingleSeqBit = BIT(0), // if 0, infinite sequences
uci1 8:95a325df1f6b 65 kCountPowerBit = BIT(1), // if 0, count events
uci1 3:24c5f0f50bf1 66 };
uci1 3:24c5f0f50bf1 67
uci1 3:24c5f0f50bf1 68 // i/o version
uci1 3:24c5f0f50bf1 69 static const uint8_t kIOVers; // MUST BE INCREASED if any member var changes (==> also if kNchans, etc. change!)
uci1 3:24c5f0f50bf1 70
uci1 3:24c5f0f50bf1 71 private:
uci1 3:24c5f0f50bf1 72 // !!
uci1 3:24c5f0f50bf1 73 // !! If any member variables change, update: SizeOf function and kIOVers value! (also if kNchans, etc. change!)
uci1 3:24c5f0f50bf1 74 // !!
uci1 3:24c5f0f50bf1 75
uci1 3:24c5f0f50bf1 76 // mbed mac address
uci1 3:24c5f0f50bf1 77 static uint64_t fgMacAdr; // mbed mac address
uci1 3:24c5f0f50bf1 78 // conf header
uci1 3:24c5f0f50bf1 79 char fLabel[kConfLblLen]; // configuration label
uci1 3:24c5f0f50bf1 80 uint32_t fConfTime; // cpu config time
uci1 3:24c5f0f50bf1 81 uint32_t fRun; // run number
uci1 3:24c5f0f50bf1 82 uint32_t fFirstEvt; // starting event number
uci1 3:24c5f0f50bf1 83 uint32_t fEvtsPerSeq; // number of events per file
uci1 3:24c5f0f50bf1 84 uint8_t fRunMode; // mode of running (see ERunMode)
uci1 3:24c5f0f50bf1 85 uint8_t fStreamHiLoPlas; // (1byte bool) if true, add the separated hi/lo thresh PLA patterns to the i/o
uci1 3:24c5f0f50bf1 86 // data packing
uci1 3:24c5f0f50bf1 87 uint8_t fWvLoseLSB; // number of least significant bits to lose when packing waveform data
uci1 3:24c5f0f50bf1 88 uint8_t fWvLoseMSB; // number of most significant bits to lose when packing waveform data
uci1 3:24c5f0f50bf1 89 uint16_t fWvBaseline; // global baseline to use when packing data (useful to reduce clipping on the high end)
uci1 3:24c5f0f50bf1 90 uint8_t fDatPackType; // type of data packing. OR'd bitword: if bit 1, will pack for writing. see EDatPackBit. default: always pack (all 1's)
uci1 3:24c5f0f50bf1 91 // trigger setup
uci1 3:24c5f0f50bf1 92 uint16_t fDAC[kNchans][kNfpgaDacs]; //[card id][dac id] values should be 0-4095 here (not checked tho)
uci1 3:24c5f0f50bf1 93 uint8_t fNumPlas; // number of patterns to use. must be <= kNplas.
uci1 3:24c5f0f50bf1 94 uint16_t fPLA[kNplas]; //[pattern id] (same for each card)
uci1 3:24c5f0f50bf1 95 uint8_t fNumCardsMajLog; // number of cards participating in the MajLogic trigger (1 to 4)
uci1 3:24c5f0f50bf1 96 uint8_t fEnableThermTrig; // (1byte bool) whether or not to allow thermal triggers
uci1 18:55f1581f2ee4 97 float fForceTrigPeriod; // number of seconds between force triggers (0=none)
uci1 3:24c5f0f50bf1 98 uint16_t fHeartBeatPeriod; // number of seconds between heartbeats (0=none)
uci1 3:24c5f0f50bf1 99 uint8_t fAmpsOn; // which amps are on (bit word. uint8_t => 8 amps max)
uci1 3:24c5f0f50bf1 100 uint16_t fEvtThrtlPeriodMs; // throttle period to write events (ms)
uci1 3:24c5f0f50bf1 101 // power
uci1 4:a91682e19d6b 102 uint8_t fPowerMode; // power mode bit word: see EPowerModeBit
uci1 3:24c5f0f50bf1 103 int16_t fBatVoltLowPwr; // battery level at which to switch to low power (not used?)
uci1 8:95a325df1f6b 104 uint16_t fVoltCheckPeriod; // how often to check the voltages (s)
uci1 3:24c5f0f50bf1 105 // communication
uci1 3:24c5f0f50bf1 106 uint32_t fCommWinPeriod; // seconds between communication window startup (0=always on)
uci1 3:24c5f0f50bf1 107 uint32_t fCommWinDuration; // seconds that communication window stays open (0=always open)
uci1 3:24c5f0f50bf1 108 int16_t fCommSendData; // data to send during comm win (=0: none, >0=send up to x events from last file until comm win closes, <0=see ESendDataBit)
uci1 3:24c5f0f50bf1 109 uint32_t fCommWinPrdLowPwr; // low power communication window period (seconds) (range enforced)
uci1 3:24c5f0f50bf1 110 uint32_t fCommWinDurLowPwr; // low power communication window duration (seconds) (range enforced)
uci1 8:95a325df1f6b 111 char fRemoteServer[kIPLen]; // IP address of remote server (for afar)
uci1 8:95a325df1f6b 112 uint16_t fRemotePort; // port number of remote server (for afar)
uci1 8:95a325df1f6b 113 char fMbedIP[kIPLen]; // IP address of this mbed
uci1 8:95a325df1f6b 114 char fMbedMask[kIPLen]; // IP address of this mbed mask
uci1 8:95a325df1f6b 115 char fMbedGate[kIPLen]; // IP address of this mbed gateway
uci1 3:24c5f0f50bf1 116 // watchdog
uci1 3:24c5f0f50bf1 117 uint32_t fWatchDogPeriod; // number of seconds of inactivity for watchdog to issue a reset
uci1 3:24c5f0f50bf1 118
uci1 8:95a325df1f6b 119 // in case of low power, store regular settings
uci1 8:95a325df1f6b 120 // these are not sent over i/o or stored in the file
uci1 8:95a325df1f6b 121 // so they are not included in SizeOf
uci1 8:95a325df1f6b 122 bool fIsLowPower;
uci1 8:95a325df1f6b 123 char fNormLabel[kConfLblLen];
uci1 8:95a325df1f6b 124 uint8_t fNormPowerMode;
uci1 8:95a325df1f6b 125
uci1 3:24c5f0f50bf1 126 void SetHardDefaults();
uci1 3:24c5f0f50bf1 127
uci1 3:24c5f0f50bf1 128 static
uci1 8:95a325df1f6b 129 uint32_t SizeOf(const uint8_t rv,
uci1 8:95a325df1f6b 130 const bool streamHiLoPlas,
uci1 3:24c5f0f50bf1 131 const uint8_t nplas,
uci1 3:24c5f0f50bf1 132 const uint8_t lblLen) {
uci1 3:24c5f0f50bf1 133 // private because it cannot be used to read from a buffer
uci1 3:24c5f0f50bf1 134 // (the label length and fStreamHiLoPlas are not known a priori)
uci1 3:24c5f0f50bf1 135 // returns the num of bytes needed to stream this object
uci1 3:24c5f0f50bf1 136 // = size of member vars + 1 for i/o version + extra PLA strings (maybe)
uci1 8:95a325df1f6b 137 uint32_t maxsize = kMaxSizeOf;
uci1 8:95a325df1f6b 138 if (rv==1) {
uci1 8:95a325df1f6b 139 maxsize = kMaxSizeOfV1;
uci1 8:95a325df1f6b 140 } else if (rv==2) {
uci1 8:95a325df1f6b 141 maxsize = kMaxSizeOfV2;
uci1 19:74155d652c37 142 } else if (rv==3) {
uci1 19:74155d652c37 143 maxsize = kMaxSizeOfV3;
uci1 8:95a325df1f6b 144 }
uci1 8:95a325df1f6b 145 uint32_t sz = maxsize - kConfLblLen + lblLen;
uci1 3:24c5f0f50bf1 146 static const uint32_t mhlp = 2u*kNplas*sizeof(uint16_t);
uci1 3:24c5f0f50bf1 147 const int32_t dp = (nplas-kNplas)*sizeof(uint16_t);
uci1 3:24c5f0f50bf1 148 const uint8_t fac = (streamHiLoPlas) ? 3u : 1u;
uci1 3:24c5f0f50bf1 149 sz += (fac*dp);
uci1 3:24c5f0f50bf1 150 if (streamHiLoPlas==false) {
uci1 3:24c5f0f50bf1 151 sz -= mhlp;
uci1 3:24c5f0f50bf1 152 }
uci1 3:24c5f0f50bf1 153 return sz;
uci1 3:24c5f0f50bf1 154 }
uci1 28:484943132bb0 155
uci1 28:484943132bb0 156 void SetDefaultIPs();
uci1 28:484943132bb0 157 void SetDefaultRemoteServ();
uci1 28:484943132bb0 158 void SetDefaultRemotePort();
uci1 28:484943132bb0 159 void SetDefaultMbedIP();
uci1 28:484943132bb0 160 void SetDefaultMaskIP();
uci1 28:484943132bb0 161 void SetDefaultGateIP();
uci1 28:484943132bb0 162 void ApplySafetyNets();
uci1 28:484943132bb0 163
uci1 3:24c5f0f50bf1 164 public:
uci1 31:b5bd3b189150 165 SnConfigFrame(const bool applySafety=true) : fIsLowPower(false) {
uci1 31:b5bd3b189150 166 fgApplySafetyNets = applySafety;
uci1 31:b5bd3b189150 167 Reset();
uci1 31:b5bd3b189150 168 }
uci1 3:24c5f0f50bf1 169 virtual ~SnConfigFrame() {}
uci1 3:24c5f0f50bf1 170
uci1 8:95a325df1f6b 171 bool IsCountingPowerReadings() const { return ((fRunMode & kCountPowerBit)!=0); }
uci1 8:95a325df1f6b 172 bool IsSingleSeqRunMode() const { return ((fRunMode & kSingleSeqBit)!=0); }
uci1 8:95a325df1f6b 173 bool IsLowPowerMode() const { return fIsLowPower; }
uci1 3:24c5f0f50bf1 174 const char* GetLabel() const { return fLabel; }
uci1 3:24c5f0f50bf1 175 uint32_t GetLabelStrLen() const { return strlen(fLabel); }
uci1 3:24c5f0f50bf1 176 uint32_t GetRun() const { return fRun; }
uci1 3:24c5f0f50bf1 177 uint32_t GetFirstEvt() const { return fFirstEvt; }
uci1 3:24c5f0f50bf1 178 uint32_t GetEvtsPerFile() const { return fEvtsPerSeq; }
uci1 3:24c5f0f50bf1 179 uint16_t GetEvtThrtlPeriodMs() const { return fEvtThrtlPeriodMs; }
uci1 18:55f1581f2ee4 180 float GetForceTrigPeriod() const { return fForceTrigPeriod; }
uci1 3:24c5f0f50bf1 181 uint16_t GetHeartbeatPeriod() const { return fHeartBeatPeriod; }
uci1 8:95a325df1f6b 182 uint16_t GetBatVoltLowPwr() const { return fBatVoltLowPwr; }
uci1 8:95a325df1f6b 183 uint16_t GetVoltCheckPeriod() const { return fVoltCheckPeriod; }
uci1 3:24c5f0f50bf1 184 uint32_t GetWatchdogPeriod() const { return fWatchDogPeriod; }
uci1 3:24c5f0f50bf1 185 uint16_t GetDac(const uint8_t ch, const uint8_t dn) const { return fDAC[ch][dn]; }
uci1 3:24c5f0f50bf1 186 uint8_t GetNumPlas() const { return fNumPlas; }
uci1 3:24c5f0f50bf1 187 uint16_t GetPla(const uint8_t pn) const { return fPLA[pn]; }
uci1 3:24c5f0f50bf1 188 uint8_t GetNumCardsMajLog() const { return fNumCardsMajLog; }
uci1 3:24c5f0f50bf1 189 bool IsThermTrigEnabled() const { return fEnableThermTrig!=0; }
uci1 3:24c5f0f50bf1 190 bool IsEachAmpOn() const {
uci1 3:24c5f0f50bf1 191 bool allon=true;
uci1 3:24c5f0f50bf1 192 for (uint8_t i=0; (i<kNchans) && allon; i++) {
uci1 3:24c5f0f50bf1 193 allon = (fAmpsOn & BIT(i))!=0;
uci1 3:24c5f0f50bf1 194 }
uci1 3:24c5f0f50bf1 195 return allon;
uci1 3:24c5f0f50bf1 196 }
uci1 3:24c5f0f50bf1 197 // TODO: allow check for individual amps, when they can be turned on individually
uci1 3:24c5f0f50bf1 198
uci1 8:95a325df1f6b 199 const char* GetRemoteServer() const { return fRemoteServer; }
uci1 8:95a325df1f6b 200 uint16_t GetRemotePort() const { return fRemotePort; }
uci1 8:95a325df1f6b 201 const char* GetMbedIP() const { return fMbedIP; }
uci1 8:95a325df1f6b 202 const char* GetMbedMask() const { return fMbedMask; }
uci1 8:95a325df1f6b 203 const char* GetMbedGate() const { return fMbedGate; }
uci1 8:95a325df1f6b 204 uint32_t GetCommWinPeriod() const { return fIsLowPower ? fCommWinPrdLowPwr : fCommWinPeriod; }
uci1 8:95a325df1f6b 205 uint32_t GetCommWinDuration() const { return fIsLowPower ? fCommWinDurLowPwr : fCommWinDuration; }
uci1 3:24c5f0f50bf1 206 int16_t GetCommSendData() const { return fCommSendData; }
uci1 3:24c5f0f50bf1 207
uci1 3:24c5f0f50bf1 208 bool IsSendingAllFiles() const
uci1 3:24c5f0f50bf1 209 { return (fCommSendData<0) && ((fCommSendData & kAllFiles)!=0); }
uci1 3:24c5f0f50bf1 210 bool IsObeyingTimeout() const
uci1 3:24c5f0f50bf1 211 { return (fCommSendData<0) && ((fCommSendData & kTimeout)!=0); }
uci1 3:24c5f0f50bf1 212 bool IsDeletingFiles() const
uci1 3:24c5f0f50bf1 213 { return (fCommSendData<0) && ((fCommSendData & kDelete)!=0); }
uci1 15:f2569d8e4176 214 bool IsForcingSBDdata() const
uci1 15:f2569d8e4176 215 { return (fCommSendData<0) && ((fCommSendData & kForceSBDdata)!=0); }
uci1 3:24c5f0f50bf1 216
uci1 4:a91682e19d6b 217 uint8_t GetPowerMode() const { return fPowerMode; }
uci1 30:f869ed4bcc08 218 int GetPowPinSetting(const EPowerModeBit p, const bool isOn) const {
uci1 5:9cea89700c66 219 if (p==kCardDatTak || p==kCardComWin ||
uci1 5:9cea89700c66 220 p==kAmpsDatTak || p==kAmpsComWin) {
uci1 30:f869ed4bcc08 221 return isOn ? 0 : 1;
uci1 5:9cea89700c66 222 } else {
uci1 30:f869ed4bcc08 223 return isOn ? 1 : 0;
uci1 5:9cea89700c66 224 }
uci1 5:9cea89700c66 225 }
uci1 30:f869ed4bcc08 226 int GetPowPinSetting(const EPowerModeBit p) const {
uci1 30:f869ed4bcc08 227 // return int to correspond to what DigitalOut::operator= expects
uci1 30:f869ed4bcc08 228 return GetPowPinSetting(p, IsPoweredFor(p));
uci1 30:f869ed4bcc08 229 }
uci1 8:95a325df1f6b 230 bool IsPoweredFor(const EPowerModeBit p) const {
uci1 8:95a325df1f6b 231 return ((fPowerMode & p)!=0);
uci1 8:95a325df1f6b 232 }
uci1 8:95a325df1f6b 233
uci1 8:95a325df1f6b 234 void EnablePowerFor(const EPowerModeBit p) { fPowerMode |= p; }
uci1 8:95a325df1f6b 235 void DisablePowerFor(const EPowerModeBit p) { fPowerMode &= ~p; }
uci1 8:95a325df1f6b 236
uci1 8:95a325df1f6b 237 void ChangeToLowPower();
uci1 8:95a325df1f6b 238 void ChangeToNormPower();
uci1 3:24c5f0f50bf1 239
uci1 3:24c5f0f50bf1 240 const char* GetOutFileName(const char* dir) const;
uci1 3:24c5f0f50bf1 241
uci1 21:ce51bb0ba4a5 242 uint32_t GetTimeoutTime(const uint32_t startTime,
uci1 21:ce51bb0ba4a5 243 const uint32_t delta) const;
uci1 21:ce51bb0ba4a5 244
uci1 21:ce51bb0ba4a5 245
uci1 3:24c5f0f50bf1 246 // waveform packing info
uci1 3:24c5f0f50bf1 247 uint16_t GetWvBaseline() const { return fWvBaseline; }
uci1 3:24c5f0f50bf1 248 uint8_t GetWvLoseLSB() const { return fWvLoseLSB; }
uci1 3:24c5f0f50bf1 249 uint8_t GetWvLoseMSB() const { return fWvLoseMSB; }
uci1 3:24c5f0f50bf1 250 bool IsDatPackedFor(const EDatPackBit d) const { return (fDatPackType & d)!=0; }
uci1 3:24c5f0f50bf1 251 void GetPackParsFor(const EDatPackBit d,
uci1 3:24c5f0f50bf1 252 uint8_t& loseLSB, uint8_t& loseMSB,
uci1 3:24c5f0f50bf1 253 uint16_t& wvBase) const;
uci1 3:24c5f0f50bf1 254
uci1 3:24c5f0f50bf1 255 // i/o
uci1 3:24c5f0f50bf1 256 template<class T>
uci1 3:24c5f0f50bf1 257 void ReadFrom(T& b) {
uci1 3:24c5f0f50bf1 258 // no check on the length of buf is done here
uci1 3:24c5f0f50bf1 259 // that should be been done already
uci1 3:24c5f0f50bf1 260 //
uci1 3:24c5f0f50bf1 261 // must match WriteTo
uci1 3:24c5f0f50bf1 262
uci1 3:24c5f0f50bf1 263 uint8_t Rv=0;
uci1 3:24c5f0f50bf1 264 b = SnBitUtils::ReadFrom(b, Rv); // i/o version
uci1 12:d472f9811262 265 #ifdef DEBUG
uci1 3:24c5f0f50bf1 266 printf("Rv=%hhu\r\n",Rv);
uci1 12:d472f9811262 267 #endif
uci1 3:24c5f0f50bf1 268 if (Rv>0) {
uci1 3:24c5f0f50bf1 269 uint32_t llen=kConfLblLen;
uci1 3:24c5f0f50bf1 270 b = SnBitUtils::ReadFrom(b, llen);
uci1 12:d472f9811262 271 #ifdef DEBUG
uci1 3:24c5f0f50bf1 272 printf("llen=%u\r\n",llen);
uci1 12:d472f9811262 273 #endif
uci1 3:24c5f0f50bf1 274 b = SnBitUtils::ReadFrom(b, fLabel, llen);
uci1 12:d472f9811262 275 #ifdef DEBUG
uci1 3:24c5f0f50bf1 276 printf("lbl=%s\r\n",fLabel);
uci1 12:d472f9811262 277 #endif
uci1 3:24c5f0f50bf1 278 b = SnBitUtils::ReadFrom(b, fConfTime);
uci1 12:d472f9811262 279 #ifdef DEBUG
uci1 3:24c5f0f50bf1 280 printf("ct=%u\r\n",fConfTime);
uci1 12:d472f9811262 281 #endif
uci1 3:24c5f0f50bf1 282 b = SnBitUtils::ReadFrom(b, fRun);
uci1 12:d472f9811262 283 #ifdef DEBUG
uci1 3:24c5f0f50bf1 284 printf("run=%u\r\n",fRun);
uci1 12:d472f9811262 285 #endif
uci1 3:24c5f0f50bf1 286 b = SnBitUtils::ReadFrom(b, fFirstEvt);
uci1 12:d472f9811262 287 #ifdef DEBUG
uci1 3:24c5f0f50bf1 288 printf("fe=%u\r\n",fFirstEvt);
uci1 12:d472f9811262 289 #endif
uci1 3:24c5f0f50bf1 290 if (Rv>1) {
uci1 3:24c5f0f50bf1 291 b = SnBitUtils::ReadFrom(b, fEvtsPerSeq);
uci1 12:d472f9811262 292 #ifdef DEBUG
uci1 3:24c5f0f50bf1 293 printf("eps=%u\r\n",fEvtsPerSeq);
uci1 12:d472f9811262 294 #endif
uci1 3:24c5f0f50bf1 295 b = SnBitUtils::ReadFrom(b, fRunMode);
uci1 12:d472f9811262 296 #ifdef DEBUG
uci1 3:24c5f0f50bf1 297 printf("rm=%hhu\r\n",fRunMode);
uci1 12:d472f9811262 298 #endif
uci1 3:24c5f0f50bf1 299 }
uci1 3:24c5f0f50bf1 300 b = SnBitUtils::ReadFrom(b, fStreamHiLoPlas);
uci1 12:d472f9811262 301 #ifdef DEBUG
uci1 3:24c5f0f50bf1 302 printf("shilo=%d\r\n",(int)fStreamHiLoPlas);
uci1 12:d472f9811262 303 #endif
uci1 3:24c5f0f50bf1 304 b = SnBitUtils::ReadFrom(b, fWvLoseLSB);
uci1 12:d472f9811262 305 #ifdef DEBUG
uci1 3:24c5f0f50bf1 306 printf("lsb=%hhu\r\n",fWvLoseLSB);
uci1 12:d472f9811262 307 #endif
uci1 3:24c5f0f50bf1 308 b = SnBitUtils::ReadFrom(b, fWvLoseMSB);
uci1 12:d472f9811262 309 #ifdef DEBUG
uci1 3:24c5f0f50bf1 310 printf("msb=%hhu\r\n",fWvLoseMSB);
uci1 12:d472f9811262 311 #endif
uci1 3:24c5f0f50bf1 312 b = SnBitUtils::ReadFrom(b, fWvBaseline);
uci1 12:d472f9811262 313 #ifdef DEBUG
uci1 3:24c5f0f50bf1 314 printf("bl=%hu\r\n",fWvBaseline);
uci1 12:d472f9811262 315 #endif
uci1 3:24c5f0f50bf1 316 b = SnBitUtils::ReadFrom(b, fDatPackType);
uci1 12:d472f9811262 317 #ifdef DEBUG
uci1 3:24c5f0f50bf1 318 printf("dp=%hhu\r\n",fDatPackType);
uci1 12:d472f9811262 319 #endif
uci1 3:24c5f0f50bf1 320 uint16_t* dc = &(fDAC[0][0]);
uci1 3:24c5f0f50bf1 321 for (uint16_t i=0; i<kTotDacs; i++, dc++) {
uci1 3:24c5f0f50bf1 322 b = SnBitUtils::ReadFrom(b, *dc);
uci1 12:d472f9811262 323 #ifdef DEBUG
uci1 3:24c5f0f50bf1 324 printf("dac[%hu]=%hu\r\n",i,*dc);
uci1 12:d472f9811262 325 #endif
uci1 3:24c5f0f50bf1 326 }
uci1 3:24c5f0f50bf1 327 b = SnBitUtils::ReadFrom(b, fNumPlas);
uci1 12:d472f9811262 328 #ifdef DEBUG
uci1 3:24c5f0f50bf1 329 printf("npla=%hhu\r\n",fNumPlas);
uci1 12:d472f9811262 330 #endif
uci1 3:24c5f0f50bf1 331 uint16_t* pl = &(fPLA[0]);
uci1 3:24c5f0f50bf1 332 for (uint8_t j=0; j<fNumPlas; j++, pl++) {
uci1 3:24c5f0f50bf1 333 b = SnBitUtils::ReadFrom(b, *pl);
uci1 12:d472f9811262 334 #ifdef DEBUG
uci1 3:24c5f0f50bf1 335 printf("pla[%hhu]=%hu\r\n",j,*pl);
uci1 12:d472f9811262 336 #endif
uci1 3:24c5f0f50bf1 337 }
uci1 3:24c5f0f50bf1 338 b = SnBitUtils::ReadFrom(b, fNumCardsMajLog);
uci1 12:d472f9811262 339 #ifdef DEBUG
uci1 3:24c5f0f50bf1 340 printf("mj=%hhu\r\n",fNumCardsMajLog);
uci1 12:d472f9811262 341 #endif
uci1 3:24c5f0f50bf1 342 b = SnBitUtils::ReadFrom(b, fEnableThermTrig);
uci1 12:d472f9811262 343 #ifdef DEBUG
uci1 3:24c5f0f50bf1 344 printf("thm=%d\r\n",(int)fEnableThermTrig);
uci1 12:d472f9811262 345 #endif
uci1 18:55f1581f2ee4 346 if (Rv>3) {
uci1 18:55f1581f2ee4 347 b = SnBitUtils::ReadFrom(b, fForceTrigPeriod);
uci1 18:55f1581f2ee4 348 } else {
uci1 18:55f1581f2ee4 349 uint16_t ftrg(0);
uci1 18:55f1581f2ee4 350 b = SnBitUtils::ReadFrom(b, ftrg);
uci1 18:55f1581f2ee4 351 fForceTrigPeriod = ftrg;
uci1 18:55f1581f2ee4 352 }
uci1 12:d472f9811262 353 #ifdef DEBUG
uci1 18:55f1581f2ee4 354 printf("force=%g\r\n",fForceTrigPeriod);
uci1 12:d472f9811262 355 #endif
uci1 3:24c5f0f50bf1 356 b = SnBitUtils::ReadFrom(b, fHeartBeatPeriod);
uci1 12:d472f9811262 357 #ifdef DEBUG
uci1 3:24c5f0f50bf1 358 printf("heart=%hu\r\n",fHeartBeatPeriod);
uci1 12:d472f9811262 359 #endif
uci1 3:24c5f0f50bf1 360 b = SnBitUtils::ReadFrom(b, fAmpsOn);
uci1 12:d472f9811262 361 #ifdef DEBUG
uci1 3:24c5f0f50bf1 362 printf("amps=%hhu\r\n",fAmpsOn);
uci1 12:d472f9811262 363 #endif
uci1 3:24c5f0f50bf1 364 b = SnBitUtils::ReadFrom(b, fEvtThrtlPeriodMs);
uci1 12:d472f9811262 365 #ifdef DEBUG
uci1 3:24c5f0f50bf1 366 printf("throt=%hu\r\n",fEvtThrtlPeriodMs);
uci1 12:d472f9811262 367 #endif
uci1 3:24c5f0f50bf1 368 b = SnBitUtils::ReadFrom(b, fPowerMode);
uci1 12:d472f9811262 369 #ifdef DEBUG
uci1 3:24c5f0f50bf1 370 printf("pow=%hhu\r\n",fPowerMode);
uci1 12:d472f9811262 371 #endif
uci1 3:24c5f0f50bf1 372 b = SnBitUtils::ReadFrom(b, fBatVoltLowPwr);
uci1 12:d472f9811262 373 #ifdef DEBUG
uci1 8:95a325df1f6b 374 printf("batlow=%hd\r\n",fBatVoltLowPwr);
uci1 12:d472f9811262 375 #endif
uci1 8:95a325df1f6b 376 if (Rv>2) {
uci1 8:95a325df1f6b 377 b = SnBitUtils::ReadFrom(b, fVoltCheckPeriod);
uci1 12:d472f9811262 378 #ifdef DEBUG
uci1 8:95a325df1f6b 379 printf("vltchk=%hu\r\n",fVoltCheckPeriod);
uci1 12:d472f9811262 380 #endif
uci1 8:95a325df1f6b 381 }
uci1 3:24c5f0f50bf1 382 b = SnBitUtils::ReadFrom(b, fCommWinPeriod);
uci1 12:d472f9811262 383 #ifdef DEBUG
uci1 3:24c5f0f50bf1 384 printf("cmper=%u\r\n",fCommWinPeriod);
uci1 12:d472f9811262 385 #endif
uci1 3:24c5f0f50bf1 386 b = SnBitUtils::ReadFrom(b, fCommWinDuration);
uci1 12:d472f9811262 387 #ifdef DEBUG
uci1 3:24c5f0f50bf1 388 printf("cmdur=%u\r\n",fCommWinDuration);
uci1 12:d472f9811262 389 #endif
uci1 3:24c5f0f50bf1 390 b = SnBitUtils::ReadFrom(b, fCommSendData);
uci1 12:d472f9811262 391 #ifdef DEBUG
uci1 3:24c5f0f50bf1 392 printf("send=%d\r\n",fCommSendData);
uci1 12:d472f9811262 393 #endif
uci1 3:24c5f0f50bf1 394 b = SnBitUtils::ReadFrom(b, fCommWinPrdLowPwr);
uci1 12:d472f9811262 395 #ifdef DEBUG
uci1 3:24c5f0f50bf1 396 printf("cmperlp=%u\r\n",fCommWinPrdLowPwr);
uci1 12:d472f9811262 397 #endif
uci1 3:24c5f0f50bf1 398 b = SnBitUtils::ReadFrom(b, fCommWinDurLowPwr);
uci1 12:d472f9811262 399 #ifdef DEBUG
uci1 3:24c5f0f50bf1 400 printf("cmdurlp=%u\r\n",fCommWinDurLowPwr);
uci1 12:d472f9811262 401 #endif
uci1 8:95a325df1f6b 402 if (Rv>2) {
uci1 8:95a325df1f6b 403 b = SnBitUtils::ReadFrom(b, fRemoteServer, kIPLen);
uci1 28:484943132bb0 404 if (strncmp(fRemoteServer, kDefIPflag,kIPLen)==0) {
uci1 28:484943132bb0 405 SetDefaultRemoteServ();
uci1 28:484943132bb0 406 }
uci1 12:d472f9811262 407 #ifdef DEBUG
uci1 8:95a325df1f6b 408 printf("rserv=%s\r\n",fRemoteServer);
uci1 12:d472f9811262 409 #endif
uci1 8:95a325df1f6b 410 b = SnBitUtils::ReadFrom(b, fRemotePort);
uci1 28:484943132bb0 411 if (fRemotePort==0) {
uci1 28:484943132bb0 412 SetDefaultRemotePort();
uci1 28:484943132bb0 413 }
uci1 12:d472f9811262 414 #ifdef DEBUG
uci1 8:95a325df1f6b 415 printf("rport=%hu\r\n",fRemotePort);
uci1 12:d472f9811262 416 #endif
uci1 8:95a325df1f6b 417 b = SnBitUtils::ReadFrom(b, fMbedIP, kIPLen);
uci1 28:484943132bb0 418 if (strncmp(fMbedIP, kDefIPflag,kIPLen)==0) {
uci1 28:484943132bb0 419 SetDefaultMbedIP();
uci1 28:484943132bb0 420 }
uci1 12:d472f9811262 421 #ifdef DEBUG
uci1 8:95a325df1f6b 422 printf("mbedip=%s\r\n",fMbedIP);
uci1 12:d472f9811262 423 #endif
uci1 8:95a325df1f6b 424 b = SnBitUtils::ReadFrom(b, fMbedMask, kIPLen);
uci1 28:484943132bb0 425 if (strncmp(fMbedMask, kDefIPflag,kIPLen)==0) {
uci1 28:484943132bb0 426 SetDefaultMaskIP();
uci1 28:484943132bb0 427 }
uci1 12:d472f9811262 428 #ifdef DEBUG
uci1 8:95a325df1f6b 429 printf("mbedmask=%s\r\n",fMbedMask);
uci1 12:d472f9811262 430 #endif
uci1 8:95a325df1f6b 431 b = SnBitUtils::ReadFrom(b, fMbedGate, kIPLen);
uci1 28:484943132bb0 432 if (strncmp(fMbedGate, kDefIPflag,kIPLen)==0) {
uci1 28:484943132bb0 433 SetDefaultGateIP();
uci1 28:484943132bb0 434 }
uci1 12:d472f9811262 435 #ifdef DEBUG
uci1 8:95a325df1f6b 436 printf("mbedgate=%s\r\n",fMbedGate);
uci1 12:d472f9811262 437 #endif
uci1 8:95a325df1f6b 438 }
uci1 3:24c5f0f50bf1 439 b = SnBitUtils::ReadFrom(b, fWatchDogPeriod);
uci1 12:d472f9811262 440 #ifdef DEBUG
uci1 3:24c5f0f50bf1 441 printf("watch=%u\r\n",fWatchDogPeriod);
uci1 12:d472f9811262 442 #endif
uci1 3:24c5f0f50bf1 443 if (fStreamHiLoPlas!=0) {
uci1 3:24c5f0f50bf1 444 uint16_t hi, lo;
uci1 3:24c5f0f50bf1 445 for (uint8_t j=0; j<fNumPlas; j++) {
uci1 3:24c5f0f50bf1 446 b = SnBitUtils::ReadFrom(b, hi);
uci1 12:d472f9811262 447 #ifdef DEBUG
uci1 3:24c5f0f50bf1 448 printf("hi=%hu\r\n",hi);
uci1 12:d472f9811262 449 #endif
uci1 3:24c5f0f50bf1 450 b = SnBitUtils::ReadFrom(b, lo);
uci1 12:d472f9811262 451 #ifdef DEBUG
uci1 3:24c5f0f50bf1 452 printf("lo=%hu\r\n",lo);
uci1 12:d472f9811262 453 #endif
uci1 3:24c5f0f50bf1 454 // don't save these
uci1 3:24c5f0f50bf1 455 }
uci1 3:24c5f0f50bf1 456 }
uci1 3:24c5f0f50bf1 457 }
uci1 28:484943132bb0 458
uci1 31:b5bd3b189150 459 if (fgApplySafetyNets) {
uci1 31:b5bd3b189150 460 ApplySafetyNets();
uci1 31:b5bd3b189150 461 }
uci1 28:484943132bb0 462
uci1 12:d472f9811262 463 #ifdef DEBUG
uci1 3:24c5f0f50bf1 464 printf("read from done\r\n");
uci1 12:d472f9811262 465 #endif
uci1 3:24c5f0f50bf1 466 }
uci1 3:24c5f0f50bf1 467
uci1 3:24c5f0f50bf1 468 template <class T>
uci1 3:24c5f0f50bf1 469 void WriteTo(T& b) const {
uci1 3:24c5f0f50bf1 470 // no check on the length of the buf is done here
uci1 3:24c5f0f50bf1 471 // that should be done already
uci1 3:24c5f0f50bf1 472 //
uci1 3:24c5f0f50bf1 473 // must match ReadFromBuf
uci1 3:24c5f0f50bf1 474 //
uci1 3:24c5f0f50bf1 475 // intentionally not writing mac address here, so we don't have to read it in
uci1 3:24c5f0f50bf1 476
uci1 3:24c5f0f50bf1 477 const uint32_t llen = strlen(fLabel);
uci1 3:24c5f0f50bf1 478 b = SnBitUtils::WriteTo(b, kIOVers); // i/o version
uci1 3:24c5f0f50bf1 479 b = SnBitUtils::WriteTo(b, llen);
uci1 3:24c5f0f50bf1 480 b = SnBitUtils::WriteTo(b, fLabel, llen);
uci1 3:24c5f0f50bf1 481 b = SnBitUtils::WriteTo(b, fConfTime);
uci1 3:24c5f0f50bf1 482 b = SnBitUtils::WriteTo(b, fRun);
uci1 3:24c5f0f50bf1 483 b = SnBitUtils::WriteTo(b, fFirstEvt);
uci1 3:24c5f0f50bf1 484 b = SnBitUtils::WriteTo(b, fEvtsPerSeq);
uci1 3:24c5f0f50bf1 485 b = SnBitUtils::WriteTo(b, fRunMode);
uci1 3:24c5f0f50bf1 486 b = SnBitUtils::WriteTo(b, fStreamHiLoPlas);
uci1 3:24c5f0f50bf1 487 b = SnBitUtils::WriteTo(b, fWvLoseLSB);
uci1 3:24c5f0f50bf1 488 b = SnBitUtils::WriteTo(b, fWvLoseMSB);
uci1 3:24c5f0f50bf1 489 b = SnBitUtils::WriteTo(b, fWvBaseline);
uci1 3:24c5f0f50bf1 490 b = SnBitUtils::WriteTo(b, fDatPackType);
uci1 3:24c5f0f50bf1 491 const uint16_t* dc = &(fDAC[0][0]);
uci1 3:24c5f0f50bf1 492 for (uint16_t i=0; i<kTotDacs; i++, dc++) {
uci1 3:24c5f0f50bf1 493 b = SnBitUtils::WriteTo(b, *dc);
uci1 3:24c5f0f50bf1 494 }
uci1 3:24c5f0f50bf1 495 b = SnBitUtils::WriteTo(b, fNumPlas);
uci1 3:24c5f0f50bf1 496 const uint16_t* pl = &(fPLA[0]);
uci1 3:24c5f0f50bf1 497 for (uint8_t j=0; j<fNumPlas; j++, pl++) {
uci1 3:24c5f0f50bf1 498 b = SnBitUtils::WriteTo(b, *pl);
uci1 3:24c5f0f50bf1 499 }
uci1 3:24c5f0f50bf1 500 b = SnBitUtils::WriteTo(b, fNumCardsMajLog);
uci1 3:24c5f0f50bf1 501 b = SnBitUtils::WriteTo(b, fEnableThermTrig);
uci1 3:24c5f0f50bf1 502 b = SnBitUtils::WriteTo(b, fForceTrigPeriod);
uci1 3:24c5f0f50bf1 503 b = SnBitUtils::WriteTo(b, fHeartBeatPeriod);
uci1 3:24c5f0f50bf1 504 b = SnBitUtils::WriteTo(b, fAmpsOn);
uci1 3:24c5f0f50bf1 505 b = SnBitUtils::WriteTo(b, fEvtThrtlPeriodMs);
uci1 3:24c5f0f50bf1 506 b = SnBitUtils::WriteTo(b, fPowerMode);
uci1 3:24c5f0f50bf1 507 b = SnBitUtils::WriteTo(b, fBatVoltLowPwr);
uci1 8:95a325df1f6b 508 b = SnBitUtils::WriteTo(b, fVoltCheckPeriod);
uci1 3:24c5f0f50bf1 509 b = SnBitUtils::WriteTo(b, fCommWinPeriod);
uci1 3:24c5f0f50bf1 510 b = SnBitUtils::WriteTo(b, fCommWinDuration);
uci1 3:24c5f0f50bf1 511 b = SnBitUtils::WriteTo(b, fCommSendData);
uci1 3:24c5f0f50bf1 512 b = SnBitUtils::WriteTo(b, fCommWinPrdLowPwr);
uci1 3:24c5f0f50bf1 513 b = SnBitUtils::WriteTo(b, fCommWinDurLowPwr);
uci1 8:95a325df1f6b 514 b = SnBitUtils::WriteTo(b, fRemoteServer, kIPLen);
uci1 8:95a325df1f6b 515 b = SnBitUtils::WriteTo(b, fRemotePort);
uci1 8:95a325df1f6b 516 b = SnBitUtils::WriteTo(b, fMbedIP, kIPLen);
uci1 8:95a325df1f6b 517 b = SnBitUtils::WriteTo(b, fMbedMask, kIPLen);
uci1 8:95a325df1f6b 518 b = SnBitUtils::WriteTo(b, fMbedGate, kIPLen);
uci1 3:24c5f0f50bf1 519 b = SnBitUtils::WriteTo(b, fWatchDogPeriod);
uci1 3:24c5f0f50bf1 520 if (fStreamHiLoPlas!=0) {
uci1 3:24c5f0f50bf1 521 pl = fPLA;
uci1 3:24c5f0f50bf1 522 uint16_t hi, lo;
uci1 3:24c5f0f50bf1 523 for (uint8_t j=0; j<fNumPlas; j++, pl++) {
uci1 3:24c5f0f50bf1 524 GetHiLoPlas(*pl, hi, lo);
uci1 3:24c5f0f50bf1 525 b = SnBitUtils::WriteTo(b, hi);
uci1 3:24c5f0f50bf1 526 b = SnBitUtils::WriteTo(b, lo);
uci1 3:24c5f0f50bf1 527 }
uci1 3:24c5f0f50bf1 528 }
uci1 3:24c5f0f50bf1 529 }
uci1 3:24c5f0f50bf1 530
uci1 3:24c5f0f50bf1 531 bool ReadFromFile(const char* cfile);
uci1 3:24c5f0f50bf1 532 bool WriteToFile(const char* cfile) const;
uci1 3:24c5f0f50bf1 533
uci1 3:24c5f0f50bf1 534 void Reset() {
uci1 3:24c5f0f50bf1 535 memset(fLabel, 0, sizeof(char)*kConfLblLen);
uci1 3:24c5f0f50bf1 536 if (ReadFromFile(kDefConfFile)==false) {
uci1 3:24c5f0f50bf1 537 // couldn't get default. use hardcoded version.
uci1 3:24c5f0f50bf1 538 SetHardDefaults();
uci1 3:24c5f0f50bf1 539 }
uci1 16:744ce85aede2 540 #ifdef DEBUG
uci1 16:744ce85aede2 541 printf("config reset to %s\r\n",fLabel);
uci1 16:744ce85aede2 542 #endif
uci1 3:24c5f0f50bf1 543 }
uci1 3:24c5f0f50bf1 544
uci1 8:95a325df1f6b 545 uint32_t SizeOf(const uint8_t rv) const {
uci1 3:24c5f0f50bf1 546 // returns the num of bytes needed to stream this object
uci1 3:24c5f0f50bf1 547 // = size of member vars + 1 for i/o version + extra PLA strings (maybe)
uci1 3:24c5f0f50bf1 548 // + length of label string
uci1 8:95a325df1f6b 549 return SizeOf(rv, fStreamHiLoPlas!=0, fNumPlas, strlen(fLabel));
uci1 3:24c5f0f50bf1 550 }
uci1 3:24c5f0f50bf1 551
uci1 3:24c5f0f50bf1 552 static void SetMacAddress();
uci1 3:24c5f0f50bf1 553 static uint64_t GetMacAddress() {
uci1 3:24c5f0f50bf1 554 if (fgMacAdr==0) {
uci1 3:24c5f0f50bf1 555 SetMacAddress();
uci1 3:24c5f0f50bf1 556 }
uci1 3:24c5f0f50bf1 557 return fgMacAdr;
uci1 3:24c5f0f50bf1 558 }
uci1 3:24c5f0f50bf1 559
uci1 3:24c5f0f50bf1 560 static uint32_t GetLabelMaxLen() { return kConfLblLen; }
uci1 3:24c5f0f50bf1 561
uci1 3:24c5f0f50bf1 562 static void GetHiLoPlas(const uint16_t pla,
uci1 3:24c5f0f50bf1 563 uint16_t& hiPla,
uci1 3:24c5f0f50bf1 564 uint16_t& loPla,
uci1 3:24c5f0f50bf1 565 const bool r2l=false);
uci1 3:24c5f0f50bf1 566 };
uci1 3:24c5f0f50bf1 567
uci1 3:24c5f0f50bf1 568 #endif // SN_SnConfigFrame