S K UCI / Mbed 2 deprecated AutonomousDAQ

Arianna autonomous DAQ firmware

Dependencies:   mbed SDFileSystemFilinfo AriSnProtocol NetServicesMin AriSnComm MODSERIAL PowerControlClkPatch DS1820OW

SnConfigFrame.cpp@103:0ea896a0953a, 2015-11-22 (annotated)

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