Jordan Hanson / Mbed 2 deprecated AutonomousDAQ

Arianna autonomous DAQ firmware

Dependencies:   mbed SDFileSystemFilinfo AriSnProtocol NetServicesMin AriSnComm MODSERIAL PowerControlClkPatch DS1820OW

SnCommWin.cpp@16:744ce85aede2, 2012-09-12 (annotated)

Committer:
uci1
Date:
Wed Sep 12 04:47:22 2012 +0000
Revision:
16:744ce85aede2
Parent:
15:f2569d8e4176
Child:
18:55f1581f2ee4
SBD comm seems to be working. USB comm seems to be working (at 115200 baud). AFAR comm seems to be working. This version is set for USB communication and has zero text output.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
uci1 2:e67f7c158087 1 #include "SnCommWin.h"
uci1 2:e67f7c158087 2
uci1 6:6f002d202f59 3 #include "SnHeaderFrame.h"
uci1 2:e67f7c158087 4 #include "SnConfigFrame.h"
uci1 8:95a325df1f6b 5 #include "SnEventFrame.h"
uci1 8:95a325df1f6b 6 #include "SnPowerFrame.h"
uci1 8:95a325df1f6b 7 #include "SnStatusFrame.h"
uci1 2:e67f7c158087 8 #include "SnSDUtils.h"
uci1 16:744ce85aede2 9 #include "SnConstants.h"
uci1 16:744ce85aede2 10
uci1 16:744ce85aede2 11 //#define DEBUG
uci1 16:744ce85aede2 12
uci1 16:744ce85aede2 13 uint32_t SnCommWin::GetConnectTimeout() const { return kConnectTimeout; }
uci1 16:744ce85aede2 14 uint32_t SnCommWin::GetListenTimeout() const { return kListenTimeout; }
uci1 2:e67f7c158087 15
uci1 12:d472f9811262 16 bool SnCommWin::IsTimedOut(const uint32_t timeout_clock) const {
uci1 16:744ce85aede2 17 if (timeout_clock==0) {
uci1 16:744ce85aede2 18 // for not obeying timeout option
uci1 16:744ce85aede2 19 return false;
uci1 16:744ce85aede2 20 } else {
uci1 16:744ce85aede2 21 const uint32_t ct = time(0);
uci1 16:744ce85aede2 22 if ( (ct==0) ||
uci1 16:744ce85aede2 23 (abs(static_cast<double>(timeout_clock-ct))>kSecsPerDay) ) {
uci1 16:744ce85aede2 24 // clock problems!
uci1 16:744ce85aede2 25 // timeout now. hope the clock problems
uci1 16:744ce85aede2 26 // get fixed in the next comm window
uci1 12:d472f9811262 27 return true;
uci1 16:744ce85aede2 28 } else {
uci1 16:744ce85aede2 29 return (ct>timeout_clock);
uci1 12:d472f9811262 30 }
uci1 12:d472f9811262 31 }
uci1 12:d472f9811262 32 }
uci1 12:d472f9811262 33
uci1 2:e67f7c158087 34 SnCommWin::ECommWinResult SnCommWin::SendData(SnConfigFrame& conf,
uci1 2:e67f7c158087 35 SnEventFrame& evt,
uci1 8:95a325df1f6b 36 SnPowerFrame& pow,
uci1 2:e67f7c158087 37 char* const genBuf,
uci1 3:24c5f0f50bf1 38 const uint32_t bsize,
uci1 12:d472f9811262 39 const uint32_t timeout,
uci1 12:d472f9811262 40 const uint32_t handshakeTimeout) {
uci1 12:d472f9811262 41 #ifdef DEBUG
uci1 3:24c5f0f50bf1 42 printf("SnCommWin::SendData\r\n");
uci1 12:d472f9811262 43 #endif
uci1 2:e67f7c158087 44 ECommWinResult res = kUndefFail;
uci1 15:f2569d8e4176 45 if ( (GetCommType() != SnConfigFrame::kIrid) ||
uci1 15:f2569d8e4176 46 (conf.IsForcingSBDdata()) ) {
uci1 15:f2569d8e4176 47 // only send large amounts if we're not communicating by Iridum,
uci1 15:f2569d8e4176 48 // or if we are being forced to send the data over SBD
uci1 15:f2569d8e4176 49 if (conf.IsSendingAllFiles()) {
uci1 12:d472f9811262 50 #ifdef DEBUG
uci1 15:f2569d8e4176 51 printf("sending all files\r\n");
uci1 12:d472f9811262 52 #endif
uci1 15:f2569d8e4176 53 res = SnSDUtils::SendAllFiles(this, timeout,
uci1 15:f2569d8e4176 54 genBuf, bsize, conf, evt, pow,
uci1 15:f2569d8e4176 55 handshakeTimeout);
uci1 15:f2569d8e4176 56 } else {
uci1 15:f2569d8e4176 57 if (conf.GetCommSendData()==0) {
uci1 12:d472f9811262 58 #ifdef DEBUG
uci1 15:f2569d8e4176 59 printf("no data to send\r\n");
uci1 12:d472f9811262 60 #endif
uci1 15:f2569d8e4176 61 res = kOkNoMsg;
uci1 15:f2569d8e4176 62 } else {
uci1 15:f2569d8e4176 63 const uint32_t nev = (conf.GetCommSendData()>0) ?
uci1 15:f2569d8e4176 64 conf.GetCommSendData() // send N events
uci1 15:f2569d8e4176 65 : 0u; // send all events in last file
uci1 12:d472f9811262 66 #ifdef DEBUG
uci1 16:744ce85aede2 67 printf("calling SendData. f=%s, nev=%u\r\n",SnSDUtils::GetCurFileName(), nev);
uci1 12:d472f9811262 68 #endif
uci1 15:f2569d8e4176 69 res = SendData(SnSDUtils::GetCurFile(), SnSDUtils::GetCurFileName(),
uci1 15:f2569d8e4176 70 conf, evt, pow, genBuf, bsize, nev, timeout, handshakeTimeout);
uci1 12:d472f9811262 71 #ifdef DEBUG
uci1 15:f2569d8e4176 72 printf("after send data cur file, res=%d\r\n",(int)res);
uci1 12:d472f9811262 73 #endif
uci1 15:f2569d8e4176 74 }
uci1 2:e67f7c158087 75 }
uci1 15:f2569d8e4176 76 } else {
uci1 15:f2569d8e4176 77 return kOkNoMsg;
uci1 2:e67f7c158087 78 }
uci1 2:e67f7c158087 79 return res;
uci1 2:e67f7c158087 80 }
uci1 2:e67f7c158087 81
uci1 2:e67f7c158087 82 SnCommWin::ECommWinResult SnCommWin::SendData(FILE* inf, const char* infn,
uci1 2:e67f7c158087 83 const SnConfigFrame& curConf,
uci1 2:e67f7c158087 84 SnEventFrame& evt,
uci1 8:95a325df1f6b 85 SnPowerFrame& pow,
uci1 2:e67f7c158087 86 char* const genBuf,
uci1 6:6f002d202f59 87 const uint32_t bsize,
uci1 2:e67f7c158087 88 const uint32_t nevts,
uci1 6:6f002d202f59 89 const uint32_t timeout_clock,
uci1 12:d472f9811262 90 const uint32_t handshakeTimeout) {
uci1 2:e67f7c158087 91 // nevts==0 ==> send all events
uci1 2:e67f7c158087 92
uci1 12:d472f9811262 93 #ifdef DEBUG
uci1 12:d472f9811262 94 printf("SnCommWin::SendData file (%p), fn=%s\r\n",inf,infn);
uci1 12:d472f9811262 95 #endif
uci1 2:e67f7c158087 96 ECommWinResult res = kUndefFail;
uci1 12:d472f9811262 97 bool didDel = false;
uci1 2:e67f7c158087 98 if (inf!=0) {
uci1 12:d472f9811262 99 #ifdef DEBUG
uci1 12:d472f9811262 100 printf("sending file name %s\r\n",infn);
uci1 12:d472f9811262 101 #endif
uci1 16:744ce85aede2 102
uci1 6:6f002d202f59 103 // send the file name
uci1 6:6f002d202f59 104 res = SendFilename(infn, genBuf, timeout_clock);
uci1 3:24c5f0f50bf1 105 if (res>kAllFails) {
uci1 6:6f002d202f59 106 if (genBuf!=0) {
uci1 12:d472f9811262 107 #ifdef DEBUG
uci1 12:d472f9811262 108 printf("calling send file contents\r\n");
uci1 12:d472f9811262 109 #endif
uci1 16:744ce85aede2 110
uci1 6:6f002d202f59 111 // send the contents
uci1 8:95a325df1f6b 112 res = SendFileContents(inf, curConf, evt, pow, genBuf,
uci1 12:d472f9811262 113 nevts, timeout_clock);
uci1 12:d472f9811262 114 #ifdef DEBUG
uci1 12:d472f9811262 115 printf("res=%d (fails=%d)\r\n",(int)res,(int)kAllFails);
uci1 12:d472f9811262 116 #endif
uci1 12:d472f9811262 117 if (res>kAllFails) {
uci1 12:d472f9811262 118 #ifdef DEBUG
uci1 12:d472f9811262 119 printf("calling wait handshake\r\n");
uci1 12:d472f9811262 120 #endif
uci1 6:6f002d202f59 121 // wait for handshake
uci1 6:6f002d202f59 122 uint8_t hndshk=0;
uci1 12:d472f9811262 123 res = WaitHandshake(handshakeTimeout, genBuf, bsize, hndshk);
uci1 6:6f002d202f59 124 if ( (res==SnCommWin::kOkWithMsg) // got handshake
uci1 6:6f002d202f59 125 && (nevts==0) // sent whole file
uci1 6:6f002d202f59 126 && curConf.IsDeletingFiles() // want to delete
uci1 12:d472f9811262 127 && (inf!=SnSDUtils::GetCurFile()) // not current file
uci1 6:6f002d202f59 128 && (hndshk==SnHeaderFrame::kHnShOkComplCode)) { // whole file received
uci1 6:6f002d202f59 129 // delete it
uci1 6:6f002d202f59 130 SnSDUtilsWhisperer::DeleteFile(inf, infn);
uci1 12:d472f9811262 131 didDel=true;
uci1 6:6f002d202f59 132 }
uci1 3:24c5f0f50bf1 133 }
uci1 2:e67f7c158087 134 }
uci1 2:e67f7c158087 135 }
uci1 12:d472f9811262 136 } else {
uci1 12:d472f9811262 137 #ifdef DEBUG
uci1 12:d472f9811262 138 printf("inf=0!\r\n");
uci1 12:d472f9811262 139 #endif
uci1 12:d472f9811262 140 }
uci1 12:d472f9811262 141 if ( (inf!=SnSDUtils::GetCurFile()) && (didDel==false) ) {
uci1 12:d472f9811262 142 SnSDUtils::CloseOutputFile(inf);
uci1 2:e67f7c158087 143 }
uci1 2:e67f7c158087 144 return res;
uci1 2:e67f7c158087 145 }
uci1 8:95a325df1f6b 146
uci1 8:95a325df1f6b 147 SnCommWin::ECommWinResult SnCommWin::WaitHandshake(const uint32_t timeout,
uci1 8:95a325df1f6b 148 char* const buf,
uci1 8:95a325df1f6b 149 const uint32_t bsize,
uci1 8:95a325df1f6b 150 uint8_t& hndShkCode) {
uci1 12:d472f9811262 151 // ensure we don't wait forever
uci1 12:d472f9811262 152 const uint32_t to = (timeout>0) ? timeout : kListenTimeout;
uci1 12:d472f9811262 153 #ifdef DEBUG
uci1 12:d472f9811262 154 printf("WaitHandshake, to=%u\r\n",to);
uci1 12:d472f9811262 155 #endif
uci1 8:95a325df1f6b 156
uci1 12:d472f9811262 157 const int mlen = ReceiveAll(buf, SnHeaderFrame::SizeOf(), to);
uci1 8:95a325df1f6b 158 if (mlen>0 && static_cast<uint32_t>(mlen) == SnHeaderFrame::SizeOf()) {
uci1 8:95a325df1f6b 159 uint32_t msgLen=0;
uci1 8:95a325df1f6b 160 const char* b = buf;
uci1 8:95a325df1f6b 161 SnHeaderFrame::ReadFrom(b, hndShkCode, msgLen);
uci1 12:d472f9811262 162 #ifdef DEBUG
uci1 12:d472f9811262 163 printf("got handshake code=%02x, len=%u\r\n",hndShkCode,msgLen);
uci1 12:d472f9811262 164 #endif
uci1 8:95a325df1f6b 165 if ((hndShkCode & SnHeaderFrame::kHndShkBits)!=0) {
uci1 8:95a325df1f6b 166 return SnCommWin::kOkWithMsg;
uci1 8:95a325df1f6b 167 } else {
uci1 8:95a325df1f6b 168 // TODO: somehow handle unexpected message?
uci1 8:95a325df1f6b 169 return SnCommWin::kUnexpectedRec;
uci1 8:95a325df1f6b 170 }
uci1 8:95a325df1f6b 171 }
uci1 8:95a325df1f6b 172 return SnCommWin::kOkNoMsg;
uci1 8:95a325df1f6b 173 }
uci1 8:95a325df1f6b 174
uci1 8:95a325df1f6b 175 SnCommWin::ECommWinResult SnCommWin::GetConfig(SnConfigFrame& conf,
uci1 8:95a325df1f6b 176 const uint32_t timeOut,
uci1 8:95a325df1f6b 177 char* const confBuf,
uci1 8:95a325df1f6b 178 const uint32_t bsize) {
uci1 8:95a325df1f6b 179 // confBuf assumed to alread be of allocated size
uci1 8:95a325df1f6b 180
uci1 12:d472f9811262 181 #ifdef DEBUG
uci1 8:95a325df1f6b 182 printf("GetConfig, to=%u\r\n",timeOut);
uci1 12:d472f9811262 183 #endif
uci1 8:95a325df1f6b 184
uci1 8:95a325df1f6b 185 SnCommWin::ECommWinResult res = SnCommWin::kUndefFail;
uci1 8:95a325df1f6b 186 if (bsize<SnHeaderFrame::kMaxSizeOf || bsize<SnConfigFrame::kMaxSizeOf) {
uci1 8:95a325df1f6b 187 res = SnCommWin::kUndefFail;
uci1 8:95a325df1f6b 188 } else {
uci1 8:95a325df1f6b 189 // get header
uci1 8:95a325df1f6b 190 const int hlen = ReceiveAll(confBuf, SnHeaderFrame::SizeOf(), timeOut);
uci1 8:95a325df1f6b 191 if (hlen>0 && static_cast<uint32_t>(hlen)==SnHeaderFrame::SizeOf()) {
uci1 8:95a325df1f6b 192 uint8_t mcode=0; uint32_t mlen=0;
uci1 8:95a325df1f6b 193 const char* b = confBuf;
uci1 8:95a325df1f6b 194 SnHeaderFrame::ReadFrom(b, mcode, mlen);
uci1 12:d472f9811262 195 #ifdef DEBUG
uci1 8:95a325df1f6b 196 printf("mcode=%02x, mlen=%u\r\n", mcode, mlen);
uci1 12:d472f9811262 197 #endif
uci1 12:d472f9811262 198 if (mcode==SnHeaderFrame::kNoConfigCode) {
uci1 12:d472f9811262 199 // no config to get
uci1 16:744ce85aede2 200 res = SnCommWin::kOkWthMsgNoConf;
uci1 12:d472f9811262 201 } else if (mcode!=SnHeaderFrame::kConfigCode) {
uci1 8:95a325df1f6b 202 res = SnCommWin::kUnexpectedRec;
uci1 8:95a325df1f6b 203 } else {
uci1 8:95a325df1f6b 204 // get config
uci1 8:95a325df1f6b 205 const int clen = ReceiveAll(confBuf, mlen, timeOut);
uci1 8:95a325df1f6b 206 if (clen>0 && static_cast<uint32_t>(clen)==mlen) {
uci1 8:95a325df1f6b 207 b = confBuf;
uci1 8:95a325df1f6b 208 conf.ReadFrom(b);
uci1 16:744ce85aede2 209 res = SnCommWin::kOkWithMsg;
uci1 8:95a325df1f6b 210 } else {
uci1 8:95a325df1f6b 211 res = SnCommWin::kUnexpectedRec;
uci1 8:95a325df1f6b 212 }
uci1 8:95a325df1f6b 213 }
uci1 8:95a325df1f6b 214 } else {
uci1 16:744ce85aede2 215 res = SnCommWin::kOkNoMsg;
uci1 8:95a325df1f6b 216 }
uci1 8:95a325df1f6b 217 }
uci1 8:95a325df1f6b 218 return res;
uci1 8:95a325df1f6b 219 }
uci1 8:95a325df1f6b 220
uci1 8:95a325df1f6b 221 SnCommWin::ECommWinResult SnCommWin::SendStatus(const SnConfigFrame& conf,
uci1 8:95a325df1f6b 222 const SnEventFrame& evt,
uci1 8:95a325df1f6b 223 const SnPowerFrame& pow,
uci1 10:3c93db1cfb12 224 const uint16_t seq,
uci1 10:3c93db1cfb12 225 const float thmrate,
uci1 10:3c93db1cfb12 226 const float evtrate,
uci1 8:95a325df1f6b 227 char* const genBuf,
uci1 8:95a325df1f6b 228 const uint32_t timeout_clock) {
uci1 8:95a325df1f6b 229 // TODO: check if connected?
uci1 12:d472f9811262 230 #ifdef DEBUG
uci1 12:d472f9811262 231 printf("########### Send Status\r\n");
uci1 12:d472f9811262 232 #endif
uci1 8:95a325df1f6b 233 const uint32_t ssize = SnStatusFrame::SizeOf(SnStatusFrame::kIOVers, conf);
uci1 8:95a325df1f6b 234 char* b = genBuf;
uci1 8:95a325df1f6b 235 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kStatusCode, ssize);
uci1 10:3c93db1cfb12 236 SnStatusFrame::WriteTo(b, GetCommType(), conf, evt, genBuf, seq, thmrate, evtrate);
uci1 10:3c93db1cfb12 237 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kPowerCode,
uci1 10:3c93db1cfb12 238 pow.SizeOf(SnPowerFrame::kIOvers));
uci1 10:3c93db1cfb12 239 pow.WriteTo(b);
uci1 10:3c93db1cfb12 240 int msiz = b-genBuf;
uci1 10:3c93db1cfb12 241 int mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 8:95a325df1f6b 242 #ifdef DEBUG
uci1 8:95a325df1f6b 243 printf("status frame:\r\n");
uci1 15:f2569d8e4176 244 for (uint32_t i=0; i<msiz; i++) {
uci1 8:95a325df1f6b 245 printf("%02X ",genBuf[i]);
uci1 8:95a325df1f6b 246 }
uci1 8:95a325df1f6b 247 printf("\r\n");
uci1 8:95a325df1f6b 248 #endif
uci1 8:95a325df1f6b 249 if (mlen==msiz) {
uci1 12:d472f9811262 250 #ifdef DEBUG
uci1 10:3c93db1cfb12 251 printf("status+power sent\r\n");
uci1 12:d472f9811262 252 #endif
uci1 8:95a325df1f6b 253 b = genBuf;
uci1 10:3c93db1cfb12 254 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kEventCode,
uci1 10:3c93db1cfb12 255 evt.SizeOf(SnEventFrame::kIOVers,
uci1 10:3c93db1cfb12 256 conf.GetWvLoseLSB(), conf.GetWvLoseMSB()));
uci1 10:3c93db1cfb12 257 evt.WriteTo(b, conf.GetWvLoseLSB(), conf.GetWvLoseMSB(),
uci1 10:3c93db1cfb12 258 conf.GetWvBaseline());
uci1 16:744ce85aede2 259 #ifdef DEBUG
uci1 16:744ce85aede2 260 printf("sending event\r\n");
uci1 16:744ce85aede2 261 #endif
uci1 10:3c93db1cfb12 262 return SnCommWin::kOkMsgSent;
uci1 8:95a325df1f6b 263 }
uci1 8:95a325df1f6b 264 return SnCommWin::kFailPartSent;
uci1 8:95a325df1f6b 265 }
uci1 8:95a325df1f6b 266
uci1 12:d472f9811262 267 SnCommWin::ECommWinResult SnCommWin::SendFilename(const char* inf,
uci1 8:95a325df1f6b 268 char* const genBuf,
uci1 8:95a325df1f6b 269 const uint32_t timeout_clock) {
uci1 12:d472f9811262 270 #ifdef DEBUG
uci1 12:d472f9811262 271 printf("SnCommWin::SendFilename %s\r\n",inf);
uci1 12:d472f9811262 272 #endif
uci1 16:744ce85aede2 273
uci1 12:d472f9811262 274 // remove the directory
uci1 12:d472f9811262 275 const char* fn = strrchr(inf, '/');
uci1 12:d472f9811262 276 if (fn==0) {
uci1 12:d472f9811262 277 // no directory
uci1 12:d472f9811262 278 fn = inf;
uci1 12:d472f9811262 279 } else if (fn!=inf) {
uci1 12:d472f9811262 280 ++fn; // move past the '/' if it was found
uci1 12:d472f9811262 281 }
uci1 12:d472f9811262 282 #ifdef DEBUG
uci1 12:d472f9811262 283 printf("send %s\r\n",fn);
uci1 12:d472f9811262 284 #endif
uci1 8:95a325df1f6b 285 const size_t flen = strlen(fn);
uci1 8:95a325df1f6b 286 char* b = genBuf;
uci1 8:95a325df1f6b 287 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFilenameCode, flen);
uci1 12:d472f9811262 288 b = SnBitUtils::WriteTo(b, fn, flen);
uci1 12:d472f9811262 289 const int msiz = b-genBuf;
uci1 8:95a325df1f6b 290 const int mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 291 #ifdef DEBUG
uci1 12:d472f9811262 292 printf("time = %u, timeout = %u\r\n",time(0), timeout_clock);
uci1 12:d472f9811262 293 #endif
uci1 8:95a325df1f6b 294 return (msiz==mlen) ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
uci1 8:95a325df1f6b 295 }
uci1 8:95a325df1f6b 296
uci1 12:d472f9811262 297 int SnCommWin::SendFileBlock(FILE* inf,
uci1 12:d472f9811262 298 const uint8_t blockHeaderCode,
uci1 12:d472f9811262 299 const uint32_t blockSize,
uci1 12:d472f9811262 300 char* const genBuf,
uci1 12:d472f9811262 301 const uint32_t timeout) {
uci1 12:d472f9811262 302 // sends the block from the file. does not check if the file has sufficient bytes
uci1 12:d472f9811262 303 // this should be done before calling this function
uci1 12:d472f9811262 304 // (where the number of bytes in the file can be cached)
uci1 12:d472f9811262 305 char* b = genBuf;
uci1 12:d472f9811262 306 SnHeaderFrame::WriteTo(b, blockHeaderCode, blockSize);
uci1 12:d472f9811262 307 SnBitUtils::ReadFrom(inf, b, blockSize);
uci1 12:d472f9811262 308 #ifdef DEBUG
uci1 12:d472f9811262 309 printf("Sending block hc %02x, len=%u\r\n",blockHeaderCode,blockSize+SnHeaderFrame::SizeOf());
uci1 12:d472f9811262 310 #endif
uci1 12:d472f9811262 311 return SendAll(genBuf, blockSize+SnHeaderFrame::SizeOf(), timeout);
uci1 12:d472f9811262 312 }
uci1 12:d472f9811262 313
uci1 12:d472f9811262 314 SnCommWin::ECommWinResult SnCommWin::SendFileContents(FILE* inf,
uci1 12:d472f9811262 315 const SnConfigFrame& curConf,
uci1 12:d472f9811262 316 SnEventFrame& evt,
uci1 12:d472f9811262 317 SnPowerFrame& pow,
uci1 12:d472f9811262 318 char* const genBuf,
uci1 12:d472f9811262 319 uint32_t nevts,
uci1 12:d472f9811262 320 const uint32_t timeout_clock) {
uci1 12:d472f9811262 321 // firstEvt==0 ==> start at beginning
uci1 12:d472f9811262 322 // nevts==0 ==> all events
uci1 12:d472f9811262 323
uci1 12:d472f9811262 324 #ifdef DEBUG
uci1 12:d472f9811262 325 printf("SendFileContents (byte streaming)\r\n");
uci1 12:d472f9811262 326 #endif
uci1 12:d472f9811262 327
uci1 12:d472f9811262 328 // store position in file so we can go back to it afterwards
uci1 12:d472f9811262 329 // this is probably not necessary, because if this file is open
uci1 12:d472f9811262 330 // in write-only mode, we're screwed..
uci1 12:d472f9811262 331 const int fpos = ftell(inf);
uci1 12:d472f9811262 332 if (fpos>0) {
uci1 12:d472f9811262 333 fseek(inf, 0, SEEK_SET);
uci1 12:d472f9811262 334 }
uci1 12:d472f9811262 335 // how many bytes?
uci1 12:d472f9811262 336 fseek(inf, 0, SEEK_END); // go to end
uci1 12:d472f9811262 337 const int fend = ftell(inf);
uci1 12:d472f9811262 338 fseek(inf, 0, SEEK_SET); // go to start
uci1 12:d472f9811262 339 #ifdef DEBUG
uci1 12:d472f9811262 340 printf("fend=%d\r\n",fend);
uci1 12:d472f9811262 341 printf("fpos=%d\r\n",fpos);
uci1 12:d472f9811262 342 #endif
uci1 12:d472f9811262 343
uci1 12:d472f9811262 344 // variables used when sending data
uci1 12:d472f9811262 345 char* b = genBuf;
uci1 12:d472f9811262 346 int msiz, mlen;
uci1 12:d472f9811262 347
uci1 12:d472f9811262 348 // first is the file header, which has no SnHeaderFrame
uci1 12:d472f9811262 349 msiz = SnSDUtils::SizeOfFileHeader(SnSDUtils::kIOvers);
uci1 12:d472f9811262 350 bool ok = (ftell(inf)+msiz)<=fend;
uci1 12:d472f9811262 351 if (ok) {
uci1 12:d472f9811262 352 mlen = SendFileBlock(inf, SnHeaderFrame::kFileHeadrCode,
uci1 12:d472f9811262 353 msiz, genBuf, timeout_clock);
uci1 12:d472f9811262 354 ok &= (msiz+SnHeaderFrame::SizeOf())==mlen;
uci1 12:d472f9811262 355
uci1 12:d472f9811262 356 #ifdef DEBUG
uci1 12:d472f9811262 357 printf("sent file header. ok=%d\r\n",(int)ok);
uci1 12:d472f9811262 358 #endif
uci1 12:d472f9811262 359
uci1 12:d472f9811262 360 // the header info for each block
uci1 12:d472f9811262 361 uint8_t hcode;
uci1 12:d472f9811262 362 uint32_t hlen;
uci1 12:d472f9811262 363
uci1 12:d472f9811262 364 // count number of events / power readings sent
uci1 12:d472f9811262 365 uint32_t evtsSent=0, powsSent=0;
uci1 12:d472f9811262 366
uci1 12:d472f9811262 367 // now just loop through file and send each block
uci1 12:d472f9811262 368 while ( ok
uci1 12:d472f9811262 369 && (feof(inf)==0)
uci1 12:d472f9811262 370 && (ferror(inf)==0)
uci1 12:d472f9811262 371 && ((ftell(inf)+SnHeaderFrame::SizeOf())<=fend) ) {
uci1 12:d472f9811262 372 // read the header for the block
uci1 12:d472f9811262 373 SnSDUtils::ReadBlockHeader(inf, hcode, hlen);
uci1 12:d472f9811262 374 #ifdef DEBUG
uci1 12:d472f9811262 375 printf("new block: hc=%02x, hl=%u, ftell=%d, fend=%d\r\n",
uci1 12:d472f9811262 376 hcode, hlen, ftell(inf), fend);
uci1 12:d472f9811262 377 #endif
uci1 12:d472f9811262 378 ok &= (ftell(inf)+hlen)<=fend;
uci1 12:d472f9811262 379 if (ok) {
uci1 12:d472f9811262 380 // send the block
uci1 12:d472f9811262 381 // TODO: repack events?
uci1 12:d472f9811262 382 msiz = hlen + SnHeaderFrame::SizeOf();
uci1 12:d472f9811262 383 mlen = SendFileBlock(inf, hcode, hlen, genBuf, timeout_clock);
uci1 12:d472f9811262 384 ok &= msiz==mlen;
uci1 12:d472f9811262 385 if (ok) {
uci1 12:d472f9811262 386 if (hcode==SnHeaderFrame::kEventCode) {
uci1 12:d472f9811262 387 ++evtsSent;
uci1 12:d472f9811262 388 if (nevts>0) {
uci1 12:d472f9811262 389 if (evtsSent>=nevts) {
uci1 12:d472f9811262 390 #ifdef DEBUG
uci1 12:d472f9811262 391 printf("send %u events. stop\r\n",evtsSent);
uci1 12:d472f9811262 392 #endif
uci1 12:d472f9811262 393 break;
uci1 12:d472f9811262 394 }
uci1 12:d472f9811262 395 }
uci1 12:d472f9811262 396 } else if (hcode==SnHeaderFrame::kPowerCode) {
uci1 12:d472f9811262 397 ++powsSent;
uci1 12:d472f9811262 398 }
uci1 12:d472f9811262 399 } else {
uci1 12:d472f9811262 400 #ifdef DEBUG
uci1 12:d472f9811262 401 printf("not ok when sending hcode=%02x\r\n",hcode);
uci1 12:d472f9811262 402 #endif
uci1 12:d472f9811262 403 }
uci1 12:d472f9811262 404 }
uci1 12:d472f9811262 405 }
uci1 12:d472f9811262 406
uci1 12:d472f9811262 407 #ifdef DEBUG
uci1 12:d472f9811262 408 printf("loop done. ok=%d\r\n",(int)ok);
uci1 12:d472f9811262 409 #endif
uci1 12:d472f9811262 410
uci1 12:d472f9811262 411 // send number of events sent
uci1 12:d472f9811262 412 #ifdef DEBUG
uci1 12:d472f9811262 413 printf("sending evtsSent (%u)\r\n",evtsSent);
uci1 12:d472f9811262 414 #endif
uci1 12:d472f9811262 415 b = genBuf;
uci1 12:d472f9811262 416 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileNevtsCode, sizeof(uint32_t));
uci1 12:d472f9811262 417 b = SnBitUtils::WriteTo(b, evtsSent);
uci1 12:d472f9811262 418 msiz = b - genBuf;
uci1 12:d472f9811262 419 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 420 ok &= msiz==mlen;
uci1 12:d472f9811262 421
uci1 12:d472f9811262 422 // send number of power readings sent
uci1 12:d472f9811262 423 #ifdef DEBUG
uci1 12:d472f9811262 424 printf("sending powsSent (%u)\r\n",powsSent);
uci1 12:d472f9811262 425 #endif
uci1 12:d472f9811262 426 b = genBuf;
uci1 12:d472f9811262 427 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileNpwrsCode, sizeof(uint32_t));
uci1 12:d472f9811262 428 b = SnBitUtils::WriteTo(b, powsSent);
uci1 12:d472f9811262 429 msiz = b - genBuf;
uci1 12:d472f9811262 430 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 431 ok &= msiz==mlen;
uci1 12:d472f9811262 432
uci1 12:d472f9811262 433 }
uci1 12:d472f9811262 434
uci1 12:d472f9811262 435
uci1 12:d472f9811262 436 // put file position back
uci1 12:d472f9811262 437 fseek(inf, fpos, SEEK_SET);
uci1 12:d472f9811262 438
uci1 12:d472f9811262 439 #ifdef DEBUG
uci1 12:d472f9811262 440 printf("end contents: ok=%d\r\n",(int)ok);
uci1 12:d472f9811262 441 #endif
uci1 12:d472f9811262 442
uci1 12:d472f9811262 443 return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
uci1 12:d472f9811262 444 }
uci1 12:d472f9811262 445
uci1 12:d472f9811262 446 /*
uci1 8:95a325df1f6b 447 SnCommWin::ECommWinResult SnCommWin::SendFileContents(FILE* inf,
uci1 8:95a325df1f6b 448 const SnConfigFrame& curConf,
uci1 8:95a325df1f6b 449 SnEventFrame& evt,
uci1 8:95a325df1f6b 450 SnPowerFrame& pow,
uci1 8:95a325df1f6b 451 char* const genBuf,
uci1 8:95a325df1f6b 452 uint32_t nevts,
uci1 8:95a325df1f6b 453 const uint32_t timeout_clock,
uci1 8:95a325df1f6b 454 const uint32_t firstEvt) {
uci1 12:d472f9811262 455 printf("comm win send file contents\r\n");
uci1 8:95a325df1f6b 456 // firstEvt==0 ==> start at beginning
uci1 8:95a325df1f6b 457 // nevts==0 ==> all events
uci1 8:95a325df1f6b 458
uci1 8:95a325df1f6b 459 const int fpos = ftell(inf);
uci1 8:95a325df1f6b 460 if (fpos>0) {
uci1 8:95a325df1f6b 461 fseek(inf, 0, SEEK_SET);
uci1 8:95a325df1f6b 462 }
uci1 12:d472f9811262 463 // how many bytes?
uci1 12:d472f9811262 464 fseek(inf, 0, SEEK_END); // go to end
uci1 12:d472f9811262 465 const int fend = ftell(inf);
uci1 12:d472f9811262 466 fseek(inf, 0, SEEK_SET); // go to start
uci1 12:d472f9811262 467 printf("fend=%d\r\n",fend);
uci1 8:95a325df1f6b 468 printf("fpos=%d\r\n",fpos);
uci1 8:95a325df1f6b 469 // get file header
uci1 8:95a325df1f6b 470 uint64_t macadr;
uci1 8:95a325df1f6b 471 uint32_t run;
uci1 8:95a325df1f6b 472 uint16_t seq;
uci1 12:d472f9811262 473 bool ok = (ftell(inf)+SnSDUtils::SizeOfFileHeader(SnSDUtils::kIOvers))<=fend;
uci1 12:d472f9811262 474 if (ok) {
uci1 12:d472f9811262 475 SnSDUtils::ReadFileHeader(inf, macadr, run, seq, &pow);
uci1 12:d472f9811262 476 printf("read file header: run %u, seq %hu\r\n",run,seq);
uci1 12:d472f9811262 477 }
uci1 12:d472f9811262 478
uci1 12:d472f9811262 479 printf(">>> file hdr read ftell(inf)=%d\r\n",ftell(inf));
uci1 8:95a325df1f6b 480
uci1 8:95a325df1f6b 481 // check block
uci1 8:95a325df1f6b 482 uint8_t hcode;
uci1 8:95a325df1f6b 483 uint32_t hlen;
uci1 12:d472f9811262 484 ok &= (ftell(inf)+SnHeaderFrame::SizeOf())<=fend;
uci1 12:d472f9811262 485 if (ok) {
uci1 12:d472f9811262 486 SnSDUtils::ReadBlockHeader(inf, hcode, hlen);
uci1 12:d472f9811262 487 printf("read block hd %02x, len %u\r\n",hcode,hlen);
uci1 12:d472f9811262 488 if (hcode==SnHeaderFrame::kPowerCode) {
uci1 12:d472f9811262 489 ok &= (ftell(inf)+SnPowerFrame::SizeOf(SnPowerFrame::kIOvers))<=fend;
uci1 12:d472f9811262 490 if (ok) {
uci1 12:d472f9811262 491 pow.ReadFrom(inf);
uci1 12:d472f9811262 492 printf("read power: v1=%g, v2=%g\r\n",pow.GetAveV1(), pow.GetAveV2());
uci1 12:d472f9811262 493 // now read the next header
uci1 12:d472f9811262 494 ok &= (ftell(inf)+SnHeaderFrame::SizeOf())<=fend;
uci1 12:d472f9811262 495 if (ok) {
uci1 12:d472f9811262 496 SnSDUtils::ReadBlockHeader(inf, hcode, hlen);
uci1 12:d472f9811262 497 printf("read new header: hc %02x, hlen=%u\r\n",hcode,hlen);
uci1 12:d472f9811262 498 }
uci1 12:d472f9811262 499 }
uci1 12:d472f9811262 500 }
uci1 8:95a325df1f6b 501 }
uci1 8:95a325df1f6b 502
uci1 12:d472f9811262 503 printf(">>> power tried ftell(inf)=%d\r\n",ftell(inf));
uci1 12:d472f9811262 504
uci1 12:d472f9811262 505 printf("hcode=%02x\r\n",hcode);
uci1 12:d472f9811262 506 printf("ok=%d\r\n",(int)ok);
uci1 12:d472f9811262 507 printf("feof=%d\r\n",feof(inf));
uci1 12:d472f9811262 508 printf("ferror=%d\r\n",ferror(inf));
uci1 12:d472f9811262 509 printf("%d+%u <= %d ? %d\r\n",ftell(inf),hlen,fend,
uci1 12:d472f9811262 510 (int)((ftell(inf)+hlen)<=fend));
uci1 12:d472f9811262 511
uci1 8:95a325df1f6b 512 // TODO: check memory for temporary config/event frames?
uci1 8:95a325df1f6b 513 // get config
uci1 8:95a325df1f6b 514 while ((hcode!=SnHeaderFrame::kConfigCode)
uci1 12:d472f9811262 515 && ok
uci1 8:95a325df1f6b 516 && (feof(inf)==0)
uci1 12:d472f9811262 517 && (ferror(inf)==0)
uci1 12:d472f9811262 518 && ((ftell(inf)+hlen) <= fend) ) {
uci1 12:d472f9811262 519 printf("skip: ftell=%d, hlen=%u\r\n",ftell(inf),hlen);
uci1 8:95a325df1f6b 520 fseek(inf, hlen, SEEK_CUR); // skip this block
uci1 12:d472f9811262 521 ok = (ftell(inf)+SnHeaderFrame::SizeOf())<=fend;
uci1 12:d472f9811262 522 if (ok) {
uci1 12:d472f9811262 523 SnSDUtils::ReadBlockHeader(inf, hcode, hlen);
uci1 12:d472f9811262 524 printf("hcs >>> ftell(inf)=%d, hcode=%02x, hlen=%u\r\n",ftell(inf),hcode,hlen);
uci1 12:d472f9811262 525 printf("feof=%d, ferror=%d\r\n",feof(inf),ferror(inf));
uci1 12:d472f9811262 526 }
uci1 8:95a325df1f6b 527 }
uci1 8:95a325df1f6b 528
uci1 12:d472f9811262 529 printf("checking ftell\r\n");
uci1 12:d472f9811262 530 bool gotConf = false;
uci1 12:d472f9811262 531 ok = (ftell(inf)+hlen) <= fend;
uci1 12:d472f9811262 532 printf("making temp config\r\n");
uci1 12:d472f9811262 533 SnConfigFrame conf; // TODO: SOMETIMES STALLS HERE!
uci1 12:d472f9811262 534 printf("trying to read\r\n");
uci1 12:d472f9811262 535 if (ok && (hcode==SnHeaderFrame::kConfigCode)) {
uci1 12:d472f9811262 536 printf("reading config from ftell=%d, hcode=%02x, hlen=%u, ok=%d\r\n",
uci1 12:d472f9811262 537 ftell(inf), hcode, hlen, (int)ok);
uci1 12:d472f9811262 538 conf.ReadFrom(inf);
uci1 12:d472f9811262 539 gotConf = (ftell(inf) <= fend) && (feof(inf)==0) && (ferror(inf)==0);
uci1 12:d472f9811262 540 }
uci1 12:d472f9811262 541 printf(">>> conf. ftell(inf)=%d, gotconf=%d\r\n",ftell(inf),(int)gotConf);
uci1 8:95a325df1f6b 542
uci1 8:95a325df1f6b 543 char* b = genBuf;
uci1 12:d472f9811262 544 int msiz, mlen;
uci1 12:d472f9811262 545 if (ok && gotConf) {
uci1 12:d472f9811262 546 // get event size
uci1 12:d472f9811262 547 uint8_t sLoseLSB=0, sLoseMSB=0;
uci1 12:d472f9811262 548 uint16_t sWvBase=0;
uci1 12:d472f9811262 549 curConf.GetPackParsFor(GetCommType(), sLoseLSB, sLoseMSB, sWvBase);
uci1 12:d472f9811262 550
uci1 12:d472f9811262 551 // size of event in file
uci1 12:d472f9811262 552 const uint32_t esize = SnEventFrame::SizeOf(SnEventFrame::kIOVers,
uci1 12:d472f9811262 553 conf.GetWvLoseLSB(),
uci1 12:d472f9811262 554 conf.GetWvLoseMSB());
uci1 12:d472f9811262 555
uci1 12:d472f9811262 556 printf("esize=%u\r\n",esize);
uci1 12:d472f9811262 557
uci1 12:d472f9811262 558 // number of events / power readings we will send
uci1 12:d472f9811262 559 uint32_t evtsSent=0, powsSent=0;
uci1 8:95a325df1f6b 560 b = genBuf;
uci1 12:d472f9811262 561 // send the file header
uci1 12:d472f9811262 562 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileHeadrCode,
uci1 12:d472f9811262 563 SnSDUtils::SizeOfFileHeader(SnSDUtils::kIOvers));
uci1 12:d472f9811262 564 SnSDUtils::WriteFileHeader(b, macadr, run, seq);
uci1 8:95a325df1f6b 565 msiz = b-genBuf;
uci1 8:95a325df1f6b 566 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 8:95a325df1f6b 567 if (mlen==msiz) {
uci1 12:d472f9811262 568 // send power header
uci1 8:95a325df1f6b 569 b = genBuf;
uci1 12:d472f9811262 570 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kPowerCode,
uci1 12:d472f9811262 571 pow.SizeOf(SnPowerFrame::kIOvers));
uci1 12:d472f9811262 572 pow.WriteTo(b);
uci1 8:95a325df1f6b 573 msiz = b-genBuf;
uci1 8:95a325df1f6b 574 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 575 ++powsSent;
uci1 8:95a325df1f6b 576 if (mlen==msiz) {
uci1 12:d472f9811262 577 // send the config
uci1 12:d472f9811262 578 b = genBuf;
uci1 12:d472f9811262 579 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kConfigCode,
uci1 12:d472f9811262 580 conf.SizeOf(SnConfigFrame::kIOVers));
uci1 12:d472f9811262 581 conf.WriteTo(b);
uci1 12:d472f9811262 582 msiz = b-genBuf;
uci1 12:d472f9811262 583 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 584 if (mlen==msiz) {
uci1 12:d472f9811262 585 ok = true;
uci1 12:d472f9811262 586 }
uci1 8:95a325df1f6b 587 }
uci1 8:95a325df1f6b 588 }
uci1 12:d472f9811262 589
uci1 12:d472f9811262 590 printf("ok=%d, nevts=%u\r\n",(int)ok,nevts);
uci1 8:95a325df1f6b 591
uci1 12:d472f9811262 592 if (ok) {
uci1 12:d472f9811262 593 // size of event sent over afar
uci1 12:d472f9811262 594 const uint32_t ssize = SnEventFrame::SizeOf(SnEventFrame::kIOVers,
uci1 12:d472f9811262 595 sLoseLSB, sLoseMSB);
uci1 12:d472f9811262 596
uci1 12:d472f9811262 597 // loop over blocks. send event & power frames
uci1 12:d472f9811262 598 // until EOF or nevets have been sent
uci1 12:d472f9811262 599 uint8_t hc; uint32_t hl;
uci1 12:d472f9811262 600 while (ok && (feof(inf)==0)
uci1 12:d472f9811262 601 && (ferror(inf)==0)
uci1 12:d472f9811262 602 && (ftell(inf)<fend) ) { // feof doesn't seem to work
uci1 12:d472f9811262 603 printf(">>> ftell(inf)=%d\r\n",ftell(inf));
uci1 12:d472f9811262 604 if ((ftell(inf)+SnHeaderFrame::SizeOf())<=fend) {
uci1 12:d472f9811262 605 SnSDUtils::ReadBlockHeader(inf, hc, hl);
uci1 12:d472f9811262 606 if (hc==SnHeaderFrame::kEventCode) {
uci1 12:d472f9811262 607 if ((ftell(inf)+ssize)<=fend) {
uci1 12:d472f9811262 608 evt.ReadFrom(inf, genBuf,
uci1 12:d472f9811262 609 conf.GetWvLoseLSB(), conf.GetWvLoseMSB(),
uci1 12:d472f9811262 610 conf.GetWvBaseline());
uci1 12:d472f9811262 611 if (evt.GetEvtNum()>=firstEvt) {
uci1 12:d472f9811262 612 ++evtsSent;
uci1 12:d472f9811262 613 printf("sending evt %u\r\n",evtsSent);
uci1 12:d472f9811262 614 // must be after evt.Read, since that uses the buffer
uci1 12:d472f9811262 615 b = genBuf;
uci1 12:d472f9811262 616 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kEventCode, ssize);
uci1 12:d472f9811262 617 evt.WriteTo(b, sLoseLSB, sLoseMSB, sWvBase); // will repack if necessary
uci1 12:d472f9811262 618 msiz = b-genBuf; //SnHeaderFrame::SizeOf()+ssize;
uci1 12:d472f9811262 619 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 620 ok &= mlen==msiz;
uci1 12:d472f9811262 621 }
uci1 12:d472f9811262 622 } else {
uci1 12:d472f9811262 623 printf("event header, but not enough bytes in file\r\n");
uci1 12:d472f9811262 624 ok = false;
uci1 12:d472f9811262 625 }
uci1 12:d472f9811262 626 } else if (hc==SnHeaderFrame::kPowerCode) {
uci1 12:d472f9811262 627 if ((ftell(inf)+SnPowerFrame::SizeOf(SnPowerFrame::kIOvers))<=fend) {
uci1 12:d472f9811262 628 ++powsSent;
uci1 12:d472f9811262 629 pow.ReadFrom(inf);
uci1 12:d472f9811262 630 printf("sending power frame %u, v1=%g, v2=%g, t=%u\r\n",
uci1 12:d472f9811262 631 powsSent, pow.GetAveV1(), pow.GetAveV2(), pow.GetTime());
uci1 12:d472f9811262 632 b = genBuf;
uci1 12:d472f9811262 633 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kPowerCode,
uci1 12:d472f9811262 634 SnPowerFrame::SizeOf(SnPowerFrame::kIOvers));
uci1 12:d472f9811262 635 pow.WriteTo(b);
uci1 12:d472f9811262 636 msiz = b-genBuf;
uci1 12:d472f9811262 637 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 638 ok &= mlen==msiz;
uci1 12:d472f9811262 639 } else {
uci1 12:d472f9811262 640 printf("power header, but not enough bytes in file\r\n");
uci1 12:d472f9811262 641 ok = false;
uci1 12:d472f9811262 642 }
uci1 12:d472f9811262 643 } else {
uci1 12:d472f9811262 644 printf("unhandled block. hc=%hhu, hl=%u\r\n",
uci1 12:d472f9811262 645 hc, hl);
uci1 12:d472f9811262 646 if ((ftell(inf)+hl)<=fend) {
uci1 12:d472f9811262 647 fseek(inf, hl, SEEK_CUR); // skip this block
uci1 12:d472f9811262 648 } else {
uci1 12:d472f9811262 649 printf("not enough bytes in file to skip block\r\n");
uci1 12:d472f9811262 650 ok = false;
uci1 12:d472f9811262 651 }
uci1 8:95a325df1f6b 652 }
uci1 8:95a325df1f6b 653 } else {
uci1 12:d472f9811262 654 printf("not enough bytes in file to read header\r\n");
uci1 12:d472f9811262 655 printf("feof=%d\r\n",feof(inf));
uci1 12:d472f9811262 656 printf("ftell(inf)=%d, hdr size=%u, fend=%u\r\n",
uci1 12:d472f9811262 657 (ftell(inf)), SnHeaderFrame::SizeOf(), fend);
uci1 8:95a325df1f6b 658 ok = false;
uci1 8:95a325df1f6b 659 }
uci1 8:95a325df1f6b 660 }
uci1 12:d472f9811262 661 // send number of events sent
uci1 12:d472f9811262 662 b = genBuf;
uci1 12:d472f9811262 663 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileNevtsCode, sizeof(uint32_t));
uci1 12:d472f9811262 664 b = SnBitUtils::WriteTo(b, evtsSent);
uci1 12:d472f9811262 665 msiz = b - genBuf;
uci1 12:d472f9811262 666 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 667 ok &= msiz==mlen;
uci1 12:d472f9811262 668 // send number of power readings sent
uci1 12:d472f9811262 669 b = genBuf;
uci1 12:d472f9811262 670 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileNpwrsCode, sizeof(uint32_t));
uci1 12:d472f9811262 671 b = SnBitUtils::WriteTo(b, powsSent);
uci1 12:d472f9811262 672 msiz = b - genBuf;
uci1 12:d472f9811262 673 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 12:d472f9811262 674 ok &= msiz==mlen;
uci1 8:95a325df1f6b 675 }
uci1 12:d472f9811262 676 } else {
uci1 12:d472f9811262 677 printf("failed to get config from file\r\n");
uci1 12:d472f9811262 678 // send corrupted file handshake
uci1 8:95a325df1f6b 679 b = genBuf;
uci1 12:d472f9811262 680 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileReadFailCode, 0u);
uci1 12:d472f9811262 681 msiz = b-genBuf;
uci1 8:95a325df1f6b 682 mlen = SendAll(genBuf, msiz, timeout_clock);
uci1 8:95a325df1f6b 683 ok &= msiz==mlen;
uci1 8:95a325df1f6b 684 }
uci1 12:d472f9811262 685
uci1 8:95a325df1f6b 686 // put file position back
uci1 8:95a325df1f6b 687 fseek(inf, fpos, SEEK_SET);
uci1 8:95a325df1f6b 688
uci1 8:95a325df1f6b 689 return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
uci1 8:95a325df1f6b 690 }
uci1 12:d472f9811262 691 */