S K UCI / Mbed 2 deprecated AutonomousDAQ

Arianna autonomous DAQ firmware

Dependencies:   mbed SDFileSystemFilinfo AriSnProtocol NetServicesMin AriSnComm MODSERIAL PowerControlClkPatch DS1820OW

SnConfigFrame.cpp@114:554fa3a956b4, 2015-12-04 (annotated)

Committer:
uci1
Date:
Fri Dec 04 02:54:48 2015 +0000
Revision:
114:554fa3a956b4
Parent:
113:a49885445130
Child:
115:29f46e4b65d4
Stn31 CHIPBOARD=SST4ch1GHz. With conf name. No interface chip. Safety nets.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
uci1 0:664899e0b988 1 #include "SnConfigFrame.h"
uci1 0:664899e0b988 2
uci1 0:664899e0b988 3 #include "mbed.h"
uci1 0:664899e0b988 4
uci1 59:21128cc24b04 5 //#define DEBUG
uci1 59:21128cc24b04 6
uci1 0:664899e0b988 7 #include "SnBitUtils.h"
uci1 16:744ce85aede2 8 #include "SnHeaderFrame.h"
uci1 22:f957c4f840ad 9 #include "Watchdog.h"
uci1 76:f8383f0292c2 10 #include "SnSDUtils.h"
uci1 0:664899e0b988 11
uci1 0:664899e0b988 12 extern "C" void mbed_mac_address(char *);
uci1 0:664899e0b988 13
uci1 31:b5bd3b189150 14 bool SnConfigFrame::fgApplySafetyNets = true;
uci1 56:0bba0ef15697 15 #if CHIPBOARD==ATWD4CH
uci1 84:80b15993944e 16 const uint8_t SnConfigFrame::kIOVers = 11;
uci1 114:554fa3a956b4 17 #elif CHIPBOARD==SST4CH
uci1 84:80b15993944e 18 const uint8_t SnConfigFrame::kIOVers = 12;
uci1 114:554fa3a956b4 19 #elif CHIPBOARD==SST4CH_1GHz
uci1 114:554fa3a956b4 20 const uint8_t SnConfigFrame::kIOVers = 13;
uci1 114:554fa3a956b4 21 #else
uci1 114:554fa3a956b4 22 #error CHIPBOARD value not used in config frame i/o version
uci1 56:0bba0ef15697 23 #endif
uci1 67:ec999336fcd1 24
uci1 67:ec999336fcd1 25 #ifdef USE_INTERFACE_CHIP
uci1 3:24c5f0f50bf1 26 const char* const SnConfigFrame::kDefConfFile = "/local/DEFCONF.DAT";
uci1 59:21128cc24b04 27 const char* const SnConfigFrame::kDefRemIpFilen = "/local/REMOTIP.TXT";
uci1 59:21128cc24b04 28 const char* const SnConfigFrame::kDefRemPortFilen = "/local/REMOTPRT.TXT";
uci1 59:21128cc24b04 29 const char* const SnConfigFrame::kDefMbedIPFilen = "/local/MBEDIP.TXT";
uci1 59:21128cc24b04 30 const char* const SnConfigFrame::kDefMbedMaskFilen = "/local/MBEDMASK.TXT";
uci1 59:21128cc24b04 31 const char* const SnConfigFrame::kDefMbedGateFilen = "/local/MBEDGATE.TXT";
uci1 67:ec999336fcd1 32 #endif
uci1 67:ec999336fcd1 33
uci1 28:484943132bb0 34 const char* const SnConfigFrame::kDefIPflag = "DEF";
uci1 84:80b15993944e 35 const uint32_t SnConfigFrame::kDefIPvalue = 0;
uci1 1:e392595b4b76 36 const uint32_t SnConfigFrame::kMinCommWinPrdLowPwr = 14400; // exclusive min low power comm win period (s)
uci1 1:e392595b4b76 37 const uint32_t SnConfigFrame::kMaxCommWinPrdLowPwr = 259200; // exclusive max low power comm win period (s)
uci1 1:e392595b4b76 38 const uint32_t SnConfigFrame::kMinCommWinDurLowPwr = 300; // exclusive min low power comm win duration (s)
uci1 1:e392595b4b76 39 const uint32_t SnConfigFrame::kMaxCommWinDurLowPwr = 3600; // exclusive max low power comm win duration (s)
uci1 1:e392595b4b76 40 const uint8_t SnConfigFrame::kConfLblLen;
uci1 0:664899e0b988 41
uci1 0:664899e0b988 42 uint64_t SnConfigFrame::fgMacAdr = 0;
uci1 0:664899e0b988 43
uci1 0:664899e0b988 44 void SnConfigFrame::SetMacAddress() {
uci1 0:664899e0b988 45 static const uint8_t b64 = sizeof(uint64_t);
uci1 0:664899e0b988 46 static char c[b64];
uci1 67:ec999336fcd1 47 // NOTE: the function below may not be the one provided by MBED!
uci1 67:ec999336fcd1 48 // see main.cpp
uci1 0:664899e0b988 49 mbed_mac_address(&(c[0]));
uci1 0:664899e0b988 50 // like a big endian union
uci1 0:664899e0b988 51 fgMacAdr = 0;
uci1 0:664899e0b988 52 const char* a = c+(b64-1);
uci1 0:664899e0b988 53 for (uint8_t i=0; i<b64; i++, a--) {
uci1 0:664899e0b988 54 fgMacAdr |= static_cast<uint64_t>(*a) << (i<<3);
uci1 0:664899e0b988 55 }
uci1 67:ec999336fcd1 56 #ifdef DEBUG
uci1 67:ec999336fcd1 57 printf("MAC=%012llX\r\n", fgMacAdr>>16); // 64 -> 48 bits
uci1 67:ec999336fcd1 58 #endif
uci1 0:664899e0b988 59 }
uci1 0:664899e0b988 60
uci1 0:664899e0b988 61 void SnConfigFrame::SetHardDefaults() {
uci1 114:554fa3a956b4 62 sprintf(fLabel,"Stn31-1GHzDefaultR114");
uci1 0:664899e0b988 63 fConfTime = 1338854400u; // Tue, 05 Jun 2012 00:00:00 GMT
uci1 0:664899e0b988 64 fRun = 0;
uci1 40:1324da35afd4 65 fFirstSeq = 0;
uci1 54:ea1234a44fe8 66 fEvtsPerSeq = 300;
uci1 56:0bba0ef15697 67 #if CHIPBOARD==ATWD4CH
uci1 67:ec999336fcd1 68 fRunMode = kRSListOneCW;
uci1 1:e392595b4b76 69 fStreamHiLoPlas = 0;
uci1 67:ec999336fcd1 70 #else // not ATWD4CH
uci1 67:ec999336fcd1 71 fRunMode = kDualThreshBit | kDiffTrigBit | kRSListOneCW;
uci1 56:0bba0ef15697 72 #endif
uci1 0:664899e0b988 73 fWvLoseLSB = 0;
uci1 1:e392595b4b76 74 fWvLoseMSB = 4;
uci1 0:664899e0b988 75 fWvBaseline = 0;
uci1 84:80b15993944e 76 fDatPackType = kSDcard | kIrid | kAfar | kUSB; // starting with io vers 11+, this is no longer changeable
uci1 0:664899e0b988 77 uint16_t* dc = &(fDAC[0][0]);
uci1 0:664899e0b988 78 for (uint16_t i=0; i<kTotDacs; i++, dc++) {
uci1 0:664899e0b988 79 *dc = 3072u;
uci1 0:664899e0b988 80 }
uci1 56:0bba0ef15697 81 #if CHIPBOARD==ATWD4CH
uci1 0:664899e0b988 82 fNumPlas = 1;
uci1 0:664899e0b988 83 uint16_t* pl = &(fPLA[0]);
uci1 0:664899e0b988 84 for (uint8_t j=0; j<kNplas; j++, pl++) {
uci1 0:664899e0b988 85 *pl = 0x7FFFu;
uci1 0:664899e0b988 86 }
uci1 56:0bba0ef15697 87 #endif
uci1 28:484943132bb0 88 fNumCardsMajLog = 2;
uci1 54:ea1234a44fe8 89 fEnableThermTrig = 0;
uci1 67:ec999336fcd1 90 fForceTrigPeriod = 0;
uci1 0:664899e0b988 91 fHeartBeatPeriod = 0;
uci1 84:80b15993944e 92 //fAmpsOn = 0x0Fu; removed vers 11+
uci1 67:ec999336fcd1 93 fEvtThrtlPeriodMs = 0;
uci1 76:f8383f0292c2 94 fPowerMode = kIridComWin | kAfarComWin;
uci1 39:2f17131d22a5 95 fBatVoltToLowPwr = 0;
uci1 39:2f17131d22a5 96 fBatVoltFromLowPwr = 0;
uci1 67:ec999336fcd1 97 fVoltCheckPeriod = 127u;
uci1 54:ea1234a44fe8 98 fCommWinPeriod = 600u;
uci1 1:e392595b4b76 99 fCommWinDuration = 600u;
uci1 28:484943132bb0 100 fCommSendData = static_cast<int16_t>(kUseBits);
uci1 0:664899e0b988 101 fCommWinPrdLowPwr = 86100u;
uci1 0:664899e0b988 102 fCommWinDurLowPwr = 300u;
uci1 84:80b15993944e 103 for (uint8_t i=0; i<kNumDatStreams; ++i) {
uci1 85:3ced48ef94c5 104 fCommWinConnTOMins[i] = GetDefaultConnTOMinOf(GetDataStreamForIndex(i));
uci1 85:3ced48ef94c5 105 fCommWinListTOMins[i] = GetDefaultListTOMinOf(GetDataStreamForIndex(i));
uci1 84:80b15993944e 106 }
uci1 22:f957c4f840ad 107 fWatchDogPeriod = WDFAILSAFE;
uci1 67:ec999336fcd1 108 #if CHIPBOARD==ATWD4CH
uci1 84:80b15993944e 109 // fTempCheckPeriod = 0;
uci1 70:1cee873a35b6 110 #else // not ATWD4CH
uci1 70:1cee873a35b6 111 fTempCheckPeriod = -8;
uci1 67:ec999336fcd1 112 #endif
uci1 28:484943132bb0 113 SetDefaultIPs();
uci1 8:95a325df1f6b 114 fIsLowPower = false;
uci1 8:95a325df1f6b 115 memcpy(fNormLabel, fLabel, kConfLblLen);
uci1 8:95a325df1f6b 116 fNormPowerMode = fPowerMode;
uci1 8:95a325df1f6b 117
uci1 54:ea1234a44fe8 118 ApplyConnectListenSafetyNets();
uci1 8:95a325df1f6b 119 }
uci1 8:95a325df1f6b 120
uci1 28:484943132bb0 121 void SnConfigFrame::SetDefaultRemoteServ() {
uci1 59:21128cc24b04 122 if (false==ReadDefaultRemoteServer()) {
uci1 59:21128cc24b04 123 sprintf(fRemoteServer,"%s","128.195.204.151");
uci1 59:21128cc24b04 124 }
uci1 28:484943132bb0 125 }
uci1 28:484943132bb0 126
uci1 28:484943132bb0 127 void SnConfigFrame::SetDefaultRemotePort() {
uci1 59:21128cc24b04 128 if (false==ReadDefaultRemotePort()) {
uci1 59:21128cc24b04 129 fRemotePort = 6655;
uci1 59:21128cc24b04 130 }
uci1 28:484943132bb0 131 }
uci1 28:484943132bb0 132
uci1 28:484943132bb0 133 void SnConfigFrame::SetDefaultMbedIP() {
uci1 59:21128cc24b04 134 // see ReadDefaultIPFile
uci1 59:21128cc24b04 135 //
uci1 59:21128cc24b04 136 // these hardcoded defaults are only here
uci1 59:21128cc24b04 137 // "in case". they make it difficult/impossible
uci1 59:21128cc24b04 138 // to swap boards in the field without internet
uci1 59:21128cc24b04 139 // access to change the mbed program
uci1 28:484943132bb0 140 const uint64_t ip = GetMacAddress();
uci1 59:21128cc24b04 141 if (false==ReadDefaultMbedIP()) {
uci1 59:21128cc24b04 142 switch (ip) {
uci1 67:ec999336fcd1 143 case 0x0002F7F0AEE00000: // stn 20, atwd mb 1
uci1 67:ec999336fcd1 144 sprintf(fMbedIP,"%s","157.132.94.30");
uci1 67:ec999336fcd1 145 break;
uci1 59:21128cc24b04 146 case 0x0002F7F2244B0000: // stn 13, board 102
uci1 59:21128cc24b04 147 sprintf(fMbedIP,"%s","157.132.94.31");
uci1 59:21128cc24b04 148 break;
uci1 59:21128cc24b04 149 case 0x0002F7F20A9C0000: // stn 14, board 104
uci1 59:21128cc24b04 150 sprintf(fMbedIP,"%s","157.132.94.33");
uci1 59:21128cc24b04 151 break;
uci1 67:ec999336fcd1 152 case 0x0002F7F21A8A0000: // board 111
uci1 67:ec999336fcd1 153 sprintf(fMbedIP,"%s","157.132.94.34");
uci1 67:ec999336fcd1 154 break;
uci1 67:ec999336fcd1 155 case 0x0002F7F0C3B60000: // station 3, atwd mb 5
uci1 59:21128cc24b04 156 sprintf(fMbedIP,"%s","157.132.94.35");
uci1 59:21128cc24b04 157 break;
uci1 59:21128cc24b04 158 case 0x0002F7F0C41C0000: // station 4
uci1 67:ec999336fcd1 159 case 0x0002F7F1F7A80000: // stn 15, board 110
uci1 59:21128cc24b04 160 sprintf(fMbedIP,"%s","157.132.94.37");
uci1 59:21128cc24b04 161 break;
uci1 67:ec999336fcd1 162 case 0x0002F7F0C61A0000: // station 10, atwd mb 8
uci1 59:21128cc24b04 163 sprintf(fMbedIP,"%s","157.132.94.39");
uci1 59:21128cc24b04 164 break;
uci1 59:21128cc24b04 165 case 0x0002F7F0C4450000: // station 6
uci1 59:21128cc24b04 166 case 0x0002F7F1E9ED0000: // board 108
uci1 67:ec999336fcd1 167 case 0x0002F7F224440000: // stn 19, board 105
uci1 59:21128cc24b04 168 sprintf(fMbedIP,"%s","157.132.94.41");
uci1 59:21128cc24b04 169 break;
uci1 59:21128cc24b04 170 case 0x0002F7F175B70000: // station 11
uci1 67:ec999336fcd1 171 case 0x0002F7F202C10000: // stn 17, board 109
uci1 59:21128cc24b04 172 sprintf(fMbedIP,"%s","157.132.94.43");
uci1 59:21128cc24b04 173 break;
uci1 86:051a09841ca3 174 case 0x0002F7F1F6340000: // stn 31, board 107
uci1 86:051a09841ca3 175 sprintf(fMbedIP,"%s","157.132.94.47");
uci1 86:051a09841ca3 176 break;
uci1 86:051a09841ca3 177 case 0x0002F7F1F21A0000: // stn 32, board 112
uci1 86:051a09841ca3 178 sprintf(fMbedIP,"%s","157.132.94.48");
uci1 86:051a09841ca3 179 break;
uci1 86:051a09841ca3 180 case 0x0002F7F1F2120000: // stn 30, board 113
uci1 86:051a09841ca3 181 sprintf(fMbedIP,"%s","157.132.94.49");
uci1 86:051a09841ca3 182 break;
uci1 59:21128cc24b04 183 default: // what??
uci1 86:051a09841ca3 184 sprintf(fMbedIP,"%s","157.132.94.46"); // usually for tent
uci1 59:21128cc24b04 185 break;
uci1 59:21128cc24b04 186 };
uci1 59:21128cc24b04 187 }
uci1 28:484943132bb0 188 }
uci1 28:484943132bb0 189 // brian dornick 3107
uci1 28:484943132bb0 190 void SnConfigFrame::SetDefaultMaskIP() {
uci1 59:21128cc24b04 191 if (false==ReadDefaultMbedMask()) {
uci1 59:21128cc24b04 192 sprintf(fMbedMask,"%s","255.255.255.0");
uci1 59:21128cc24b04 193 }
uci1 28:484943132bb0 194 }
uci1 28:484943132bb0 195
uci1 28:484943132bb0 196 void SnConfigFrame::SetDefaultGateIP() {
uci1 59:21128cc24b04 197 if (false==ReadDefaultMbedGate()) {
uci1 59:21128cc24b04 198 sprintf(fMbedGate,"%s","157.132.94.1");
uci1 59:21128cc24b04 199 }
uci1 59:21128cc24b04 200 }
uci1 59:21128cc24b04 201
uci1 67:ec999336fcd1 202 #ifdef USE_INTERFACE_CHIP
uci1 59:21128cc24b04 203 bool SnConfigFrame::ReadOneIPFrom(const char* ipfname,
uci1 59:21128cc24b04 204 char* ipstr) {
uci1 59:21128cc24b04 205 bool ok = false;
uci1 59:21128cc24b04 206 FILE* ipf = fopen(ipfname, "r");
uci1 59:21128cc24b04 207 if (ipf!=0) {
uci1 59:21128cc24b04 208 uint8_t ipbytes[4] = {0,0,0,0};
uci1 59:21128cc24b04 209 const int nr = fscanf(ipf,"%hhu.%hhu.%hhu.%hhu\n",
uci1 59:21128cc24b04 210 &(ipbytes[0]), &(ipbytes[1]),
uci1 59:21128cc24b04 211 &(ipbytes[2]), &(ipbytes[3]));
uci1 59:21128cc24b04 212 if (4==nr) {
uci1 59:21128cc24b04 213 const int nc =
uci1 59:21128cc24b04 214 sprintf(ipstr,"%hhu.%hhu.%hhu.%hhu",
uci1 59:21128cc24b04 215 ipbytes[0], ipbytes[1],
uci1 59:21128cc24b04 216 ipbytes[2], ipbytes[3]);
uci1 59:21128cc24b04 217 ok = nc>0;
uci1 59:21128cc24b04 218 }
uci1 76:f8383f0292c2 219 fclose(ipf);
uci1 59:21128cc24b04 220 }
uci1 59:21128cc24b04 221 #ifdef DEBUG
uci1 59:21128cc24b04 222 printf("ReadOneIPInto : ipstr=[%s], ok=%d\r\n",
uci1 59:21128cc24b04 223 ipstr, (int)ok);
uci1 59:21128cc24b04 224 #endif
uci1 59:21128cc24b04 225 return ok;
uci1 59:21128cc24b04 226 }
uci1 67:ec999336fcd1 227 #endif
uci1 59:21128cc24b04 228
uci1 59:21128cc24b04 229 bool SnConfigFrame::ReadDefaultRemoteServer() {
uci1 67:ec999336fcd1 230 #ifdef USE_INTERFACE_CHIP
uci1 59:21128cc24b04 231 const bool ok = ReadOneIPFrom(kDefRemIpFilen, fRemoteServer);
uci1 59:21128cc24b04 232 #ifdef DEBUG
uci1 59:21128cc24b04 233 printf("remote = %s\r\n", fRemoteServer);
uci1 59:21128cc24b04 234 #endif
uci1 59:21128cc24b04 235 return ok;
uci1 67:ec999336fcd1 236 #else // do not USE_INTERFACE_CHIP
uci1 67:ec999336fcd1 237 return false;
uci1 67:ec999336fcd1 238 #endif // USE_INTERFACE_CHIP
uci1 59:21128cc24b04 239 }
uci1 59:21128cc24b04 240
uci1 59:21128cc24b04 241 bool SnConfigFrame::ReadDefaultRemotePort() {
uci1 67:ec999336fcd1 242 #ifdef USE_INTERFACE_CHIP
uci1 59:21128cc24b04 243 bool ok = false;
uci1 59:21128cc24b04 244 FILE* pf = fopen(kDefRemPortFilen, "r");
uci1 59:21128cc24b04 245 if (pf!=0) {
uci1 59:21128cc24b04 246 ok = (1==fscanf(pf, "%hu\n", &fRemotePort));
uci1 76:f8383f0292c2 247 fclose(pf);
uci1 59:21128cc24b04 248 }
uci1 59:21128cc24b04 249 #ifdef DEBUG
uci1 59:21128cc24b04 250 printf("port = %hu\r\n", fRemotePort);
uci1 59:21128cc24b04 251 #endif
uci1 59:21128cc24b04 252 return ok;
uci1 67:ec999336fcd1 253 #else // do not USE_INTERFACE_CHIP
uci1 67:ec999336fcd1 254 return false;
uci1 67:ec999336fcd1 255 #endif // USE_INTERFACE_CHIP
uci1 59:21128cc24b04 256 }
uci1 59:21128cc24b04 257
uci1 59:21128cc24b04 258 bool SnConfigFrame::ReadDefaultMbedIP() {
uci1 67:ec999336fcd1 259 #ifdef USE_INTERFACE_CHIP
uci1 59:21128cc24b04 260 const bool ok = ReadOneIPFrom(kDefMbedIPFilen, fMbedIP);
uci1 59:21128cc24b04 261 #ifdef DEBUG
uci1 59:21128cc24b04 262 printf("mbed = %s\r\n", fMbedIP);
uci1 59:21128cc24b04 263 #endif
uci1 59:21128cc24b04 264 return ok;
uci1 67:ec999336fcd1 265 #else // do not USE_INTERFACE_CHIP
uci1 67:ec999336fcd1 266 return false;
uci1 67:ec999336fcd1 267 #endif // USE_INTERFACE_CHIP
uci1 59:21128cc24b04 268 }
uci1 59:21128cc24b04 269
uci1 59:21128cc24b04 270 bool SnConfigFrame::ReadDefaultMbedMask() {
uci1 67:ec999336fcd1 271 #ifdef USE_INTERFACE_CHIP
uci1 59:21128cc24b04 272 const bool ok = ReadOneIPFrom(kDefMbedMaskFilen, fMbedMask);
uci1 59:21128cc24b04 273 #ifdef DEBUG
uci1 59:21128cc24b04 274 printf("mask = %s\r\n", fMbedMask);
uci1 59:21128cc24b04 275 #endif
uci1 59:21128cc24b04 276 return ok;
uci1 67:ec999336fcd1 277 #else // do not USE_INTERFACE_CHIP
uci1 67:ec999336fcd1 278 return false;
uci1 67:ec999336fcd1 279 #endif // USE_INTERFACE_CHIP
uci1 59:21128cc24b04 280 }
uci1 59:21128cc24b04 281
uci1 59:21128cc24b04 282 bool SnConfigFrame::ReadDefaultMbedGate() {
uci1 67:ec999336fcd1 283 #ifdef USE_INTERFACE_CHIP
uci1 59:21128cc24b04 284 const bool ok = ReadOneIPFrom(kDefMbedGateFilen, fMbedGate);
uci1 59:21128cc24b04 285 #ifdef DEBUG
uci1 59:21128cc24b04 286 printf("gate = %s\r\n", fMbedGate);
uci1 59:21128cc24b04 287 #endif
uci1 59:21128cc24b04 288 return ok;
uci1 67:ec999336fcd1 289 #else // do not USE_INTERFACE_CHIP
uci1 67:ec999336fcd1 290 return false;
uci1 67:ec999336fcd1 291 #endif // USE_INTERFACE_CHIP
uci1 59:21128cc24b04 292 }
uci1 59:21128cc24b04 293
uci1 28:484943132bb0 294
uci1 28:484943132bb0 295 void SnConfigFrame::SetDefaultIPs() {
uci1 59:21128cc24b04 296 GetMacAddress(); // just to make sure it gets read
uci1 67:ec999336fcd1 297 SetDefaultRemoteServ();
uci1 67:ec999336fcd1 298 SetDefaultRemotePort();
uci1 67:ec999336fcd1 299 SetDefaultMbedIP();
uci1 67:ec999336fcd1 300 SetDefaultMaskIP();
uci1 67:ec999336fcd1 301 SetDefaultGateIP();
uci1 28:484943132bb0 302 }
uci1 28:484943132bb0 303
uci1 84:80b15993944e 304 void SnConfigFrame::ApplyConnectListenSafetyNets(const uint8_t dataStreamIdx) {
uci1 84:80b15993944e 305 const float maxto_f = (fCommWinDuration/(60.*static_cast<float>(kNcomms)));
uci1 84:80b15993944e 306 const uint8_t maxto = (maxto_f < kDefTimeoutMin) ? kDefTimeoutMin :
uci1 84:80b15993944e 307 (maxto_f > 255.0) ? kDefTimeoutSafe : static_cast<uint8_t>(maxto_f);
uci1 84:80b15993944e 308 if (fCommWinConnTOMins[dataStreamIdx] < kDefTimeoutMin) {
uci1 84:80b15993944e 309 fCommWinConnTOMins[dataStreamIdx] = kDefTimeoutMin;
uci1 84:80b15993944e 310 }
uci1 84:80b15993944e 311 if (fCommWinConnTOMins[dataStreamIdx] > maxto) {
uci1 84:80b15993944e 312 fCommWinConnTOMins[dataStreamIdx] = maxto;
uci1 40:1324da35afd4 313 }
uci1 84:80b15993944e 314 if (fCommWinListTOMins[dataStreamIdx] < kDefTimeoutMin) {
uci1 84:80b15993944e 315 fCommWinListTOMins[dataStreamIdx] = kDefTimeoutMin;
uci1 84:80b15993944e 316 }
uci1 84:80b15993944e 317 if (fCommWinListTOMins[dataStreamIdx] > maxto) {
uci1 84:80b15993944e 318 fCommWinListTOMins[dataStreamIdx] = maxto;
uci1 40:1324da35afd4 319 }
uci1 84:80b15993944e 320 }
uci1 84:80b15993944e 321
uci1 84:80b15993944e 322 void SnConfigFrame::ApplyConnectListenSafetyNets() {
uci1 84:80b15993944e 323 for (uint8_t i=0; i<kNumDatStreams; ++i) {
uci1 84:80b15993944e 324 ApplyConnectListenSafetyNets(i);
uci1 40:1324da35afd4 325 }
uci1 40:1324da35afd4 326 }
uci1 40:1324da35afd4 327
uci1 28:484943132bb0 328 void SnConfigFrame::ApplySafetyNets() {
uci1 40:1324da35afd4 329 if (fFirstSeq>kMaxFirstSeq) {
uci1 40:1324da35afd4 330 fFirstSeq=kMaxFirstSeq;
uci1 40:1324da35afd4 331 }
uci1 56:0bba0ef15697 332 #if CHIPBOARD==ATWD4CH
uci1 28:484943132bb0 333 if (fNumPlas>kNplas) {
uci1 28:484943132bb0 334 fNumPlas=kNplas;
uci1 28:484943132bb0 335 }
uci1 56:0bba0ef15697 336 #endif
uci1 28:484943132bb0 337 if (fNumCardsMajLog>kNchans) {
uci1 28:484943132bb0 338 fNumCardsMajLog=kNchans;
uci1 28:484943132bb0 339 }
uci1 28:484943132bb0 340 if (fNumCardsMajLog<1u) {
uci1 28:484943132bb0 341 fNumCardsMajLog=1u;
uci1 28:484943132bb0 342 }
uci1 28:484943132bb0 343 if ( (fForceTrigPeriod>0) &&
uci1 28:484943132bb0 344 (fForceTrigPeriod<kMinForcePer) ) {
uci1 28:484943132bb0 345 fForceTrigPeriod = kMinForcePer;
uci1 28:484943132bb0 346 }
uci1 28:484943132bb0 347 if (fEvtThrtlPeriodMs>kMaxThrottlePerMs) {
uci1 28:484943132bb0 348 fEvtThrtlPeriodMs=kMaxThrottlePerMs;
uci1 28:484943132bb0 349 }
uci1 28:484943132bb0 350 if ( (IsPoweredFor(kIridComWin)==false) &&
uci1 28:484943132bb0 351 (IsPoweredFor(kAfarComWin)==false) ) {
uci1 28:484943132bb0 352 EnablePowerFor(kIridComWin);
uci1 28:484943132bb0 353 EnablePowerFor(kAfarComWin);
uci1 28:484943132bb0 354 }
uci1 39:2f17131d22a5 355 if (fBatVoltToLowPwr>kMaxBatVoltLowPwr) {
uci1 39:2f17131d22a5 356 fBatVoltToLowPwr=kMaxBatVoltLowPwr;
uci1 39:2f17131d22a5 357 }
uci1 39:2f17131d22a5 358 if (fBatVoltFromLowPwr>kMaxBatVoltLowPwr) {
uci1 39:2f17131d22a5 359 fBatVoltFromLowPwr=kMaxBatVoltLowPwr;
uci1 39:2f17131d22a5 360 }
uci1 39:2f17131d22a5 361 if (fBatVoltFromLowPwr<fBatVoltToLowPwr) {
uci1 39:2f17131d22a5 362 fBatVoltFromLowPwr=fBatVoltToLowPwr;
uci1 28:484943132bb0 363 }
uci1 28:484943132bb0 364 if (fCommWinPeriod>kMaxCommWinPeriod) {
uci1 28:484943132bb0 365 fCommWinPeriod=kMaxCommWinPeriod;
uci1 28:484943132bb0 366 }
uci1 40:1324da35afd4 367 if (fCommWinPeriod<kMinCommWinPeriod) {
uci1 40:1324da35afd4 368 fCommWinPeriod=kMinCommWinPeriod;
uci1 40:1324da35afd4 369 }
uci1 28:484943132bb0 370 if (fCommWinDuration<kMinCommWinDur) {
uci1 28:484943132bb0 371 fCommWinDuration=kMinCommWinDur;
uci1 28:484943132bb0 372 }
uci1 28:484943132bb0 373 if (fCommWinPrdLowPwr>kMaxCommWinPeriod) {
uci1 28:484943132bb0 374 fCommWinPrdLowPwr=kMaxCommWinPeriod;
uci1 28:484943132bb0 375 }
uci1 28:484943132bb0 376 if (fCommWinDurLowPwr<kMinCommWinDur) {
uci1 28:484943132bb0 377 fCommWinDurLowPwr=kMinCommWinDur;
uci1 28:484943132bb0 378 }
uci1 40:1324da35afd4 379 ApplyConnectListenSafetyNets();
uci1 28:484943132bb0 380 if (fWatchDogPeriod>kMaxWatchDogPer) {
uci1 28:484943132bb0 381 fWatchDogPeriod=kMaxWatchDogPer;
uci1 28:484943132bb0 382 }
uci1 28:484943132bb0 383 if (fWatchDogPeriod<kMinWatchDogPer) {
uci1 28:484943132bb0 384 fWatchDogPeriod=kMinWatchDogPer;
uci1 28:484943132bb0 385 }
uci1 28:484943132bb0 386 }
uci1 28:484943132bb0 387
uci1 21:ce51bb0ba4a5 388 uint32_t SnConfigFrame::GetTimeoutTime(const uint32_t startTime,
uci1 21:ce51bb0ba4a5 389 const uint32_t delta) const {
uci1 40:1324da35afd4 390 // --.-----lst------.--delta--.--
uci1 40:1324da35afd4 391 // . . .
uci1 40:1324da35afd4 392 // start current returnVal
uci1 40:1324da35afd4 393 //
uci1 40:1324da35afd4 394 // lio=lst+delta bound by comm wind dur
uci1 40:1324da35afd4 395 // returns start + lio
uci1 40:1324da35afd4 396
uci1 21:ce51bb0ba4a5 397 const uint32_t ct = time(0);
uci1 40:1324da35afd4 398 uint32_t lst = ct-startTime;
uci1 21:ce51bb0ba4a5 399 if ( (ct<startTime) || (ct==0) ||
uci1 21:ce51bb0ba4a5 400 (lst>kSecsPerDay) ) {
uci1 21:ce51bb0ba4a5 401 // possible clock problems
uci1 84:80b15993944e 402 lst = static_cast<uint32_t>(kDefTimeoutSafe)*60u;
uci1 21:ce51bb0ba4a5 403 }
uci1 21:ce51bb0ba4a5 404 const uint32_t lio =
uci1 21:ce51bb0ba4a5 405 ((lst+delta) < GetCommWinDuration()) ?
uci1 21:ce51bb0ba4a5 406 lst+delta : GetCommWinDuration();
uci1 21:ce51bb0ba4a5 407 return lio+startTime;
uci1 21:ce51bb0ba4a5 408 }
uci1 21:ce51bb0ba4a5 409
uci1 8:95a325df1f6b 410 void SnConfigFrame::ChangeToLowPower() {
uci1 8:95a325df1f6b 411
uci1 8:95a325df1f6b 412 // save old label
uci1 8:95a325df1f6b 413 memcpy(fNormLabel, fLabel, kConfLblLen);
uci1 8:95a325df1f6b 414
uci1 8:95a325df1f6b 415 // append label
uci1 8:95a325df1f6b 416 // this will allow the new config to be put in the DB
uci1 8:95a325df1f6b 417 int slen = strlen(fLabel);
uci1 8:95a325df1f6b 418 static const char* tag = "_LOWPOW";
uci1 8:95a325df1f6b 419 const int ml = strlen(tag)+1;
uci1 8:95a325df1f6b 420 if (slen > (kConfLblLen-ml) ) {
uci1 8:95a325df1f6b 421 memset(fLabel+kConfLblLen-ml, '\0', ml);
uci1 8:95a325df1f6b 422 }
uci1 8:95a325df1f6b 423 strncat(fLabel, tag, ml-1);
uci1 8:95a325df1f6b 424
uci1 8:95a325df1f6b 425 // save power settings
uci1 8:95a325df1f6b 426 fNormPowerMode = fPowerMode;
uci1 8:95a325df1f6b 427
uci1 8:95a325df1f6b 428 // change power settings
uci1 8:95a325df1f6b 429 DisablePowerFor(kAmpsDatTak);
uci1 8:95a325df1f6b 430 DisablePowerFor(kCardDatTak);
uci1 8:95a325df1f6b 431 DisablePowerFor(kIridDatTak);
uci1 8:95a325df1f6b 432 DisablePowerFor(kAfarDatTak);
uci1 8:95a325df1f6b 433 DisablePowerFor(kAmpsComWin);
uci1 8:95a325df1f6b 434 DisablePowerFor(kCardComWin);
uci1 56:0bba0ef15697 435 if ( IsSBDonlyLowPwrMode() ) {
uci1 56:0bba0ef15697 436 EnablePowerFor(kIridComWin);
uci1 56:0bba0ef15697 437 DisablePowerFor(kAfarComWin);
uci1 56:0bba0ef15697 438 } else if ( (IsPoweredFor(kIridComWin)==false) &&
uci1 56:0bba0ef15697 439 (IsPoweredFor(kAfarComWin)==false) ) {
uci1 8:95a325df1f6b 440 // TODO: turn on only iridum maybe?
uci1 8:95a325df1f6b 441 EnablePowerFor(kIridComWin);
uci1 8:95a325df1f6b 442 EnablePowerFor(kAfarComWin);
uci1 56:0bba0ef15697 443 } // else same as normal for Irid and Afar Com Win
uci1 56:0bba0ef15697 444
uci1 8:95a325df1f6b 445 // set mode to low power
uci1 8:95a325df1f6b 446 fIsLowPower = true;
uci1 84:80b15993944e 447
uci1 84:80b15993944e 448 if (fgApplySafetyNets) {
uci1 84:80b15993944e 449 ApplySafetyNets();
uci1 84:80b15993944e 450 }
uci1 8:95a325df1f6b 451 }
uci1 8:95a325df1f6b 452
uci1 8:95a325df1f6b 453 void SnConfigFrame::ChangeToNormPower() {
uci1 8:95a325df1f6b 454 // put label back
uci1 8:95a325df1f6b 455 memcpy(fLabel, fNormLabel, kConfLblLen);
uci1 8:95a325df1f6b 456 // put power settings back
uci1 8:95a325df1f6b 457 fPowerMode = fNormPowerMode;
uci1 8:95a325df1f6b 458 // set mode to normal
uci1 8:95a325df1f6b 459 fIsLowPower = false;
uci1 84:80b15993944e 460
uci1 84:80b15993944e 461 if (fgApplySafetyNets) {
uci1 84:80b15993944e 462 ApplySafetyNets();
uci1 84:80b15993944e 463 }
uci1 0:664899e0b988 464 }
uci1 0:664899e0b988 465
uci1 0:664899e0b988 466 void SnConfigFrame::GetPackParsFor(const EDatPackBit d,
uci1 0:664899e0b988 467 uint8_t& loseLSB, uint8_t& loseMSB,
uci1 0:664899e0b988 468 uint16_t& wvBase) const {
uci1 0:664899e0b988 469 const bool pack = IsDatPackedFor(d);
uci1 0:664899e0b988 470 loseLSB = pack ? GetWvLoseLSB() : 0u;
uci1 0:664899e0b988 471 loseMSB = pack ? GetWvLoseMSB() : 0u;
uci1 0:664899e0b988 472 wvBase = pack ? GetWvBaseline() : 0u;
uci1 0:664899e0b988 473 }
uci1 0:664899e0b988 474
uci1 0:664899e0b988 475 void SnConfigFrame::GetHiLoPlas(const uint16_t pla,
uci1 0:664899e0b988 476 uint16_t& hiPla,
uci1 0:664899e0b988 477 uint16_t& loPla,
uci1 0:664899e0b988 478 const bool r2l) {
uci1 0:664899e0b988 479 // split the PLA bitword into 2: one for the high threshold
uci1 0:664899e0b988 480 // and one for the low threshold. "lows" in the string will become
uci1 0:664899e0b988 481 // "highs" in the low threshold PLA.
uci1 0:664899e0b988 482 //
uci1 0:664899e0b988 483 // example 1)
uci1 0:664899e0b988 484 // PLA string = HLHL....
uci1 0:664899e0b988 485 // hi thresh = H.H.....
uci1 0:664899e0b988 486 // lo thresh = .H.H....
uci1 0:664899e0b988 487 //
uci1 0:664899e0b988 488 // example 2)
uci1 0:664899e0b988 489 // PLA string = HBL.....
uci1 0:664899e0b988 490 // hi thresh = HL......
uci1 0:664899e0b988 491 // lo thresh = .LH.....
uci1 0:664899e0b988 492 //
uci1 0:664899e0b988 493 // (with . = A here, to make the example more readable)
uci1 0:664899e0b988 494 //
uci1 0:664899e0b988 495 // A = 11, B = 00
uci1 0:664899e0b988 496 // H = 01 or 10, alternating
uci1 0:664899e0b988 497 // L = 10 or 01, alternating
uci1 0:664899e0b988 498 // 01 at leftmost bits is H
uci1 0:664899e0b988 499 // for example:
uci1 0:664899e0b988 500 // 0x7FFF = 01 11 11 11 11 11 11 11
uci1 0:664899e0b988 501 // => HAAAAAAA for LEFT TO RIGHT
uci1 0:664899e0b988 502 // => AAAAAAAH for RIGHT TO LEFT
uci1 0:664899e0b988 503 // 0x56FF = 01 01 01 10 11 11 11 11
uci1 0:664899e0b988 504 // => HLHHAAAA for LEFT TO RIGHT
uci1 0:664899e0b988 505 // => AAAAHHLH for RIGHT TO LEFT
uci1 0:664899e0b988 506 //
uci1 0:664899e0b988 507 // so HHHHHHHH is
uci1 0:664899e0b988 508 // 01 10 01 10 01 10 01 10 always (r2l or l2r)
uci1 0:664899e0b988 509 //
uci1 0:664899e0b988 510 // r2l = whether to read bits right to left (true) or not (false)
uci1 0:664899e0b988 511 // Mahshid liked right to left
uci1 0:664899e0b988 512 // Liang liked left to right
uci1 0:664899e0b988 513 // so we allow for either
uci1 0:664899e0b988 514
uci1 0:664899e0b988 515 const int8_t start = (r2l) ? 0 : BITS_IN_SHORT-2;
uci1 0:664899e0b988 516 const int8_t end = (r2l) ? BITS_IN_SHORT : -2;
uci1 39:2f17131d22a5 517 const int8_t step = (r2l) ? 2 : -2;
uci1 0:664899e0b988 518
uci1 0:664899e0b988 519 uint8_t hi= (r2l) ? 0x2 : 0x1;
uci1 0:664899e0b988 520 uint8_t lo= (r2l) ? 0x1 : 0x2;
uci1 0:664899e0b988 521
uci1 0:664899e0b988 522 // set all bits to 0
uci1 0:664899e0b988 523 hiPla = 0;
uci1 0:664899e0b988 524 loPla = 0;
uci1 0:664899e0b988 525
uci1 0:664899e0b988 526 for (int8_t i=start; i!=end; i+=step, hi^=0x3, lo^=0x3) {
uci1 0:664899e0b988 527 const uint8_t b = (pla & (0x3<<i)) >> i;
uci1 0:664899e0b988 528 if (b==hi) {
uci1 0:664899e0b988 529 hiPla |= hi << i;
uci1 0:664899e0b988 530 loPla |= 0x3 << i;
uci1 0:664899e0b988 531 } else if (b==lo) {
uci1 0:664899e0b988 532 hiPla |= 0x3 << i;
uci1 0:664899e0b988 533 loPla |= hi << i;
uci1 0:664899e0b988 534 } else if (b==0x3) {
uci1 0:664899e0b988 535 // any
uci1 0:664899e0b988 536 hiPla |= 0x3 << i;
uci1 0:664899e0b988 537 loPla |= 0x3 << i;
uci1 0:664899e0b988 538 } else {
uci1 0:664899e0b988 539 // no check that b is something else.. should be impossible.
uci1 0:664899e0b988 540 // between
uci1 0:664899e0b988 541 hiPla |= lo << i;
uci1 0:664899e0b988 542 loPla |= lo << i;
uci1 0:664899e0b988 543 }
uci1 0:664899e0b988 544 }
uci1 0:664899e0b988 545
uci1 0:664899e0b988 546 }
uci1 0:664899e0b988 547
uci1 0:664899e0b988 548 bool SnConfigFrame::ReadFromFile(const char* cfile) {
uci1 0:664899e0b988 549 // intended only for reading default config file
uci1 0:664899e0b988 550
uci1 3:24c5f0f50bf1 551 /*
uci1 3:24c5f0f50bf1 552 DIR* d;
uci1 3:24c5f0f50bf1 553 struct dirent* dent;
uci1 3:24c5f0f50bf1 554 printf("files in /local:\r\n");
uci1 3:24c5f0f50bf1 555 if ( (d = opendir( "/local" ))!=NULL ) {
uci1 3:24c5f0f50bf1 556 while ( (dent = readdir(d))!=NULL ) {
uci1 3:24c5f0f50bf1 557 printf("%s\r\n",dent->d_name);
uci1 3:24c5f0f50bf1 558 }
uci1 3:24c5f0f50bf1 559 closedir(d);
uci1 3:24c5f0f50bf1 560 }
uci1 3:24c5f0f50bf1 561 */
uci1 56:0bba0ef15697 562 #ifdef DEBUG
uci1 56:0bba0ef15697 563 printf("trying to read config [%s]\r\n",cfile);
uci1 56:0bba0ef15697 564 #endif
uci1 0:664899e0b988 565 bool ret = false;
uci1 0:664899e0b988 566 FILE* cf = fopen(cfile,"rb");
uci1 0:664899e0b988 567 if (cf!=0) {
uci1 56:0bba0ef15697 568 #ifdef DEBUG
uci1 56:0bba0ef15697 569 printf("opened file\r\n");
uci1 56:0bba0ef15697 570 #endif
uci1 16:744ce85aede2 571 // check the header and file size to be
uci1 16:744ce85aede2 572 // protect a bit against corruption
uci1 16:744ce85aede2 573 uint8_t hc; uint32_t hl;
uci1 16:744ce85aede2 574 SnHeaderFrame::ReadFrom(cf, hc, hl);
uci1 56:0bba0ef15697 575 #ifdef DEBUG
uci1 56:0bba0ef15697 576 printf("hc=%hhu, hl=%u\r\n",hc,hl);
uci1 56:0bba0ef15697 577 #endif
uci1 16:744ce85aede2 578 if (hc==SnHeaderFrame::kConfigCode) {
uci1 16:744ce85aede2 579 const int fpos = ftell(cf);
uci1 16:744ce85aede2 580 // how many bytes?
uci1 16:744ce85aede2 581 fseek(cf, 0, SEEK_END); // go to end
uci1 16:744ce85aede2 582 const int fend = ftell(cf);
uci1 16:744ce85aede2 583 fseek(cf, fpos, SEEK_SET); // go back
uci1 56:0bba0ef15697 584
uci1 56:0bba0ef15697 585 #ifdef DEBUG
uci1 56:0bba0ef15697 586 printf("fend-fpos=%d-%d=%d\r\n",fend,fpos,fend-fpos);
uci1 56:0bba0ef15697 587 #endif
uci1 16:744ce85aede2 588 if (hl == fend-fpos) {
uci1 16:744ce85aede2 589 ReadFrom(cf);
uci1 16:744ce85aede2 590 ret = (ferror(cf)==0);
uci1 56:0bba0ef15697 591 #ifdef DEBUG
uci1 56:0bba0ef15697 592 printf("ret = %d\r\n",(int)ret);
uci1 56:0bba0ef15697 593 #endif
uci1 16:744ce85aede2 594 }
uci1 16:744ce85aede2 595 }
uci1 0:664899e0b988 596 fclose(cf);
uci1 0:664899e0b988 597 }
uci1 0:664899e0b988 598 return ret;
uci1 0:664899e0b988 599 }
uci1 0:664899e0b988 600
uci1 0:664899e0b988 601 bool SnConfigFrame::WriteToFile(const char* cfile) const {
uci1 0:664899e0b988 602 // intended only for writing default config file
uci1 0:664899e0b988 603
uci1 0:664899e0b988 604 bool ret = false;
uci1 0:664899e0b988 605 FILE* cf = fopen(cfile,"wb");
uci1 0:664899e0b988 606 if (cf!=0) {
uci1 0:664899e0b988 607 WriteTo(cf);
uci1 0:664899e0b988 608 ret = (ferror(cf)==0);
uci1 0:664899e0b988 609 fclose(cf);
uci1 0:664899e0b988 610 }
uci1 0:664899e0b988 611 return ret;
uci1 76:f8383f0292c2 612 }
uci1 76:f8383f0292c2 613
uci1 76:f8383f0292c2 614 void SnConfigFrame::SetSDNeedToInitFlag() {
uci1 76:f8383f0292c2 615 // reset the SD card init cache, in case the SD ignore run mode changed
uci1 76:f8383f0292c2 616 SnSDUtils::SetDoNeedToInit();
uci1 76:f8383f0292c2 617 }
uci1 84:80b15993944e 618
uci1 84:80b15993944e 619 void SnConfigFrame::GetIpStrFromVal(const uint32_t ip,
uci1 84:80b15993944e 620 char(& str)[SnConfigFrame::kIPLen]) {
uci1 84:80b15993944e 621 if (ip==kDefIPvalue) {
uci1 84:80b15993944e 622 snprintf(str, kIPLen, kDefIPflag);
uci1 84:80b15993944e 623 } else {
uci1 84:80b15993944e 624 // little endian, but same method is used in ipToVal so the
uci1 84:80b15993944e 625 // conversions will be consistent on this machine, but of course,
uci1 84:80b15993944e 626 // the remote machine better send the right integer...
uci1 84:80b15993944e 627 union {
uci1 84:80b15993944e 628 uint8_t c[4];
uci1 84:80b15993944e 629 uint32_t u;
uci1 84:80b15993944e 630 } x;
uci1 84:80b15993944e 631 x.u = ip;
uci1 84:80b15993944e 632 snprintf(str, kIPLen, "%hhu.%hhu.%hhu.%hhu",
uci1 84:80b15993944e 633 x.c[3], x.c[2], x.c[1], x.c[0]);
uci1 84:80b15993944e 634 }
uci1 84:80b15993944e 635 }
uci1 84:80b15993944e 636
uci1 84:80b15993944e 637 uint32_t SnConfigFrame::GetIpValFromStr(const char(& str)[SnConfigFrame::kIPLen]) {
uci1 84:80b15993944e 638 if (strncmp(str, kDefIPflag, kIPLen)==0) {
uci1 84:80b15993944e 639 return kDefIPvalue;
uci1 84:80b15993944e 640 } else {
uci1 84:80b15993944e 641 union {
uci1 84:80b15993944e 642 uint8_t c[4];
uci1 84:80b15993944e 643 uint32_t u;
uci1 84:80b15993944e 644 } x;
uci1 84:80b15993944e 645 // 17 = space for terminating null
uci1 84:80b15993944e 646 // little endian, but same method is used in ipToVal so the
uci1 84:80b15993944e 647 // conversions will be consistent on this machine, but of course,
uci1 84:80b15993944e 648 // the remote machine better send the right integer...
uci1 84:80b15993944e 649 sscanf(str, "%hhu.%hhu.%hhu.%hhu",
uci1 84:80b15993944e 650 x.c+3, x.c+2, x.c+1, x.c);
uci1 84:80b15993944e 651 return x.u;
uci1 84:80b15993944e 652 }
uci1 84:80b15993944e 653 }