S K UCI / Mbed 2 deprecated AutonomousDAQ

Arianna autonomous DAQ firmware

Dependencies:   mbed SDFileSystemFilinfo AriSnProtocol NetServicesMin AriSnComm MODSERIAL PowerControlClkPatch DS1820OW

SnConfigFrame.h@40:1324da35afd4, 2013-10-05 (annotated)

Committer:
uci1
Date:
Sat Oct 05 04:45:22 2013 +0000
Revision:
40:1324da35afd4
Parent:
39:2f17131d22a5
Child:
56:0bba0ef15697
first commit of major overhaul to 2013-2014 mbed code. NOT YET FULLY TESTED. too many changes to list (fix local file receive, fix rates, external comm packes, big SD cards, get to comm win w/o SD, v8 config frame, v4 files, SBD buffering changes...)

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