Jordan Hanson / Mbed 2 deprecated AutonomousDAQ

Arianna autonomous DAQ firmware

Dependencies:   mbed SDFileSystemFilinfo AriSnProtocol NetServicesMin AriSnComm MODSERIAL PowerControlClkPatch DS1820OW

SnCommWin.cpp@56:0bba0ef15697, 2014-10-30 (annotated)

Committer:
uci1
Date:
Thu Oct 30 06:42:17 2014 +0000
Revision:
56:0bba0ef15697
Parent:
54:ea1234a44fe8
Child:
63:4820a4460f00
update ext libs, add tempr, allow SST/ATWD, improve handshaking, run/seq list, req seq range, allow SBD only in low pwr, all pins start off, can collect data to ram w/o SD card, add parameters to status update

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 41:d6f5e2f09e07 8 #include "SnSignalStrengthFrame.h"
uci1 2:e67f7c158087 9 #include "SnSDUtils.h"
uci1 16:744ce85aede2 10 #include "SnConstants.h"
uci1 21:ce51bb0ba4a5 11 #include "SnCRCUtils.h"
uci1 37:ff95e7070f26 12 #include "SnCommPeripheral.h"
uci1 21:ce51bb0ba4a5 13
uci1 21:ce51bb0ba4a5 14 #include <algorithm>
uci1 21:ce51bb0ba4a5 15 #include <ctype.h>
uci1 21:ce51bb0ba4a5 16 extern "C" void mbed_reset();
uci1 16:744ce85aede2 17
uci1 37:ff95e7070f26 18 //#define DEBUG
uci1 16:744ce85aede2 19
uci1 27:efc4d654b139 20 const char* SnCommWin::kLocalDir = "/local";
uci1 27:efc4d654b139 21 const char* SnCommWin::kDelAllConfCodeStr = "fj2io32FIJ(#jd;;.O@++/]ewavk2[49ojv";
uci1 27:efc4d654b139 22 const uint8_t SnCommWin::kDelAllConfCodeLen = 35; // length of the above string
uci1 25:57b2627fe756 23
uci1 37:ff95e7070f26 24 SnCommWin::SnCommWin(SnCommPeripheral* p) :
uci1 56:0bba0ef15697 25 fSendingInHandshake(false), fComm(p) {
uci1 37:ff95e7070f26 26 if (p==0) {
uci1 37:ff95e7070f26 27 error("SnCommWin - must have peripheral! Received 0.\r\n");
uci1 37:ff95e7070f26 28 }
uci1 37:ff95e7070f26 29 }
uci1 37:ff95e7070f26 30
uci1 37:ff95e7070f26 31 SnCommWin::~SnCommWin() {
uci1 37:ff95e7070f26 32 delete fComm;
uci1 37:ff95e7070f26 33 }
uci1 37:ff95e7070f26 34
uci1 40:1324da35afd4 35 bool SnCommWin::TrySetSysTimeUnix(const uint32_t timeout,
uci1 40:1324da35afd4 36 uint32_t& prvTime,
uci1 40:1324da35afd4 37 uint32_t& setTime) {
uci1 40:1324da35afd4 38 return (fComm!=0) ? (fComm->TrySetSysTimeUnix(timeout,prvTime,setTime))
uci1 40:1324da35afd4 39 : false;
uci1 37:ff95e7070f26 40 }
uci1 37:ff95e7070f26 41
uci1 37:ff95e7070f26 42 bool SnCommWin::Connect(const uint32_t timeout) {
uci1 37:ff95e7070f26 43 return (fComm!=0) ? (fComm->Connect(timeout)) : false;
uci1 37:ff95e7070f26 44 }
uci1 37:ff95e7070f26 45
uci1 37:ff95e7070f26 46 bool SnCommWin::CloseConn(const uint32_t timeout) {
uci1 37:ff95e7070f26 47 return (fComm!=0) ? (fComm->CloseConn(timeout)) : false;
uci1 12:d472f9811262 48 }
uci1 12:d472f9811262 49
uci1 40:1324da35afd4 50 bool SnCommWin::PowerDown(const uint32_t timeout) {
uci1 40:1324da35afd4 51 return (fComm!=0) ? (fComm->PowerDown(timeout)) : false;
uci1 40:1324da35afd4 52 }
uci1 40:1324da35afd4 53
uci1 2:e67f7c158087 54 SnCommWin::ECommWinResult SnCommWin::SendData(SnConfigFrame& conf,
uci1 2:e67f7c158087 55 SnEventFrame& evt,
uci1 8:95a325df1f6b 56 SnPowerFrame& pow,
uci1 2:e67f7c158087 57 char* const genBuf,
uci1 3:24c5f0f50bf1 58 const uint32_t bsize,
uci1 40:1324da35afd4 59 const uint32_t timeout) {
uci1 12:d472f9811262 60 #ifdef DEBUG
uci1 3:24c5f0f50bf1 61 printf("SnCommWin::SendData\r\n");
uci1 12:d472f9811262 62 #endif
uci1 2:e67f7c158087 63 ECommWinResult res = kUndefFail;
uci1 15:f2569d8e4176 64 if ( (GetCommType() != SnConfigFrame::kIrid) ||
uci1 15:f2569d8e4176 65 (conf.IsForcingSBDdata()) ) {
uci1 15:f2569d8e4176 66 // only send large amounts if we're not communicating by Iridum,
uci1 15:f2569d8e4176 67 // or if we are being forced to send the data over SBD
uci1 15:f2569d8e4176 68 if (conf.IsSendingAllFiles()) {
uci1 12:d472f9811262 69 #ifdef DEBUG
uci1 15:f2569d8e4176 70 printf("sending all files\r\n");
uci1 12:d472f9811262 71 #endif
uci1 15:f2569d8e4176 72 res = SnSDUtils::SendAllFiles(this, timeout,
uci1 40:1324da35afd4 73 genBuf, bsize, conf, evt, pow);
uci1 40:1324da35afd4 74 // handshakes handled after each file, in SendDataFromFile
uci1 15:f2569d8e4176 75 } else {
uci1 15:f2569d8e4176 76 if (conf.GetCommSendData()==0) {
uci1 12:d472f9811262 77 #ifdef DEBUG
uci1 15:f2569d8e4176 78 printf("no data to send\r\n");
uci1 12:d472f9811262 79 #endif
uci1 15:f2569d8e4176 80 res = kOkNoMsg;
uci1 56:0bba0ef15697 81 } else if (conf.IsSendingFilesRunSeqList()) {
uci1 56:0bba0ef15697 82 #ifdef DEBUG
uci1 56:0bba0ef15697 83 printf ("calling SendFilesInRunSeqList\r\n");
uci1 56:0bba0ef15697 84 #endif
uci1 56:0bba0ef15697 85 res = SnSDUtils::SendFilesInRunSeqList(
uci1 56:0bba0ef15697 86 this, timeout,
uci1 56:0bba0ef15697 87 genBuf, bsize, conf, evt, pow);
uci1 56:0bba0ef15697 88 #ifdef DEBUG
uci1 56:0bba0ef15697 89 printf ("res = %d after SendFilesInRunSeqList\r\n",
uci1 56:0bba0ef15697 90 static_cast<int>(res));
uci1 56:0bba0ef15697 91 #endif
uci1 15:f2569d8e4176 92 } else {
uci1 56:0bba0ef15697 93 // send most recent file or a few events from that file
uci1 15:f2569d8e4176 94 const uint32_t nev = (conf.GetCommSendData()>0) ?
uci1 15:f2569d8e4176 95 conf.GetCommSendData() // send N events
uci1 15:f2569d8e4176 96 : 0u; // send all events in last file
uci1 12:d472f9811262 97 #ifdef DEBUG
uci1 40:1324da35afd4 98 printf("calling SendDataFromFile. f=%s, nev=%u\r\n",
uci1 40:1324da35afd4 99 SnSDUtils::GetCurFileName(), nev);
uci1 12:d472f9811262 100 #endif
uci1 40:1324da35afd4 101 uint8_t hndcode(0);
uci1 40:1324da35afd4 102 uint32_t hndlen(0);
uci1 40:1324da35afd4 103 res = SendDataFromFile(SnSDUtils::GetCurFile(), SnSDUtils::GetCurFileName(),
uci1 40:1324da35afd4 104 conf, evt, pow, genBuf, bsize, nev, timeout,
uci1 40:1324da35afd4 105 &hndcode, &hndlen);
uci1 40:1324da35afd4 106 // handshake handled in SendData
uci1 12:d472f9811262 107 #ifdef DEBUG
uci1 15:f2569d8e4176 108 printf("after send data cur file, res=%d\r\n",(int)res);
uci1 12:d472f9811262 109 #endif
uci1 15:f2569d8e4176 110 }
uci1 2:e67f7c158087 111 }
uci1 15:f2569d8e4176 112 } else {
uci1 15:f2569d8e4176 113 return kOkNoMsg;
uci1 2:e67f7c158087 114 }
uci1 2:e67f7c158087 115 return res;
uci1 2:e67f7c158087 116 }
uci1 2:e67f7c158087 117
uci1 40:1324da35afd4 118 SnCommWin::ECommWinResult SnCommWin::SendDataFromFile(FILE* inf, const char* infn,
uci1 2:e67f7c158087 119 const SnConfigFrame& curConf,
uci1 2:e67f7c158087 120 SnEventFrame& evt,
uci1 8:95a325df1f6b 121 SnPowerFrame& pow,
uci1 2:e67f7c158087 122 char* const genBuf,
uci1 6:6f002d202f59 123 const uint32_t bsize,
uci1 2:e67f7c158087 124 const uint32_t nevts,
uci1 40:1324da35afd4 125 const uint32_t timeout,
uci1 40:1324da35afd4 126 uint8_t* hndcode,
uci1 40:1324da35afd4 127 uint32_t* hndlen) {
uci1 2:e67f7c158087 128 // nevts==0 ==> send all events
uci1 21:ce51bb0ba4a5 129 // handshakeTimeout is never a clock time -- always a delta(t)
uci1 2:e67f7c158087 130
uci1 12:d472f9811262 131 #ifdef DEBUG
uci1 40:1324da35afd4 132 printf("SnCommWin::SendDataFromFile file (%p), fn=%s\r\n",inf,infn);
uci1 12:d472f9811262 133 #endif
uci1 2:e67f7c158087 134 ECommWinResult res = kUndefFail;
uci1 12:d472f9811262 135 bool didDel = false;
uci1 40:1324da35afd4 136
uci1 40:1324da35afd4 137 // allow up to the full window if we're not obeying timeout
uci1 40:1324da35afd4 138 const uint32_t timeout_clock = curConf.IsObeyingTimeout() ?
uci1 40:1324da35afd4 139 timeout :
uci1 40:1324da35afd4 140 curConf.GetTimeoutTime(time(0),
uci1 40:1324da35afd4 141 curConf.GetCommWinDuration());
uci1 40:1324da35afd4 142
uci1 40:1324da35afd4 143
uci1 2:e67f7c158087 144 if (inf!=0) {
uci1 12:d472f9811262 145 #ifdef DEBUG
uci1 12:d472f9811262 146 printf("sending file name %s\r\n",infn);
uci1 12:d472f9811262 147 #endif
uci1 40:1324da35afd4 148
uci1 6:6f002d202f59 149 // send the file name
uci1 40:1324da35afd4 150 int32_t btogo(0), ttogo(0);
uci1 40:1324da35afd4 151 int32_t bsent = SendFilename(infn, genBuf, btogo, timeout_clock);
uci1 40:1324da35afd4 152 if (genBuf!=0) {
uci1 12:d472f9811262 153 #ifdef DEBUG
uci1 40:1324da35afd4 154 printf("calling send file contents\r\n");
uci1 12:d472f9811262 155 #endif
uci1 16:744ce85aede2 156
uci1 40:1324da35afd4 157 // send the contents
uci1 40:1324da35afd4 158 bsent += SendFileContents(inf, curConf, evt, pow, genBuf,
uci1 40:1324da35afd4 159 nevts, ttogo, timeout_clock);
uci1 40:1324da35afd4 160 btogo += ttogo;
uci1 40:1324da35afd4 161 bsent += fComm->FinishSending(timeout_clock);
uci1 40:1324da35afd4 162 res = (bsent==btogo) ? SnCommWin::kOkMsgSent
uci1 40:1324da35afd4 163 : SnCommWin::kFailPartSent;
uci1 12:d472f9811262 164 #ifdef DEBUG
uci1 40:1324da35afd4 165 printf("res=%d (fails=%d)\r\n",(int)res,(int)kAllFails);
uci1 12:d472f9811262 166 #endif
uci1 40:1324da35afd4 167 if (res>kAllFails) {
uci1 12:d472f9811262 168 #ifdef DEBUG
uci1 40:1324da35afd4 169 printf("calling wait handshake\r\n");
uci1 12:d472f9811262 170 #endif
uci1 40:1324da35afd4 171 // wait for handshake
uci1 40:1324da35afd4 172 uint8_t hndshk(0); uint32_t hndshkLen(0);
uci1 40:1324da35afd4 173 res = WaitHandshake(curConf, timeout_clock, genBuf, bsize, hndshk,
uci1 40:1324da35afd4 174 &hndshkLen);
uci1 40:1324da35afd4 175 if (hndcode!=0) {
uci1 40:1324da35afd4 176 *hndcode = hndshk;
uci1 40:1324da35afd4 177 }
uci1 40:1324da35afd4 178 if (hndlen!=0) {
uci1 40:1324da35afd4 179 *hndlen = hndshkLen;
uci1 40:1324da35afd4 180 }
uci1 26:b3180073c8ec 181 #ifdef DEBUG
uci1 40:1324da35afd4 182 printf("res=%d, nevts=%u, isdel=%d, inf=%p, curfile=%p, hndshk=%02x\r\n",
uci1 40:1324da35afd4 183 res, nevts, curConf.IsDeletingFiles(), inf,
uci1 40:1324da35afd4 184 SnSDUtils::GetCurFile(), hndshk);
uci1 21:ce51bb0ba4a5 185 #endif
uci1 40:1324da35afd4 186 if (SnCommWin::kOkWithMsg==res) {
uci1 56:0bba0ef15697 187 res = HandleHandshake(
uci1 56:0bba0ef15697 188 //SnSDUtils::GetCurFile(), SnSDUtils::GetCurFileName(),
uci1 56:0bba0ef15697 189 inf, infn,
uci1 40:1324da35afd4 190 curConf, evt, pow, genBuf, bsize, timeout_clock,
uci1 40:1324da35afd4 191 hndshk, hndshkLen, &nevts);
uci1 40:1324da35afd4 192 didDel = (SnCommWin::kOkWthMsgDidDel==res);
uci1 40:1324da35afd4 193 }
uci1 2:e67f7c158087 194 }
uci1 40:1324da35afd4 195 } // if genBuf!=0
uci1 12:d472f9811262 196 } else {
uci1 12:d472f9811262 197 #ifdef DEBUG
uci1 12:d472f9811262 198 printf("inf=0!\r\n");
uci1 12:d472f9811262 199 #endif
uci1 56:0bba0ef15697 200 res = kOkNoMsg;
uci1 12:d472f9811262 201 }
uci1 12:d472f9811262 202 if ( (inf!=SnSDUtils::GetCurFile()) && (didDel==false) ) {
uci1 12:d472f9811262 203 SnSDUtils::CloseOutputFile(inf);
uci1 2:e67f7c158087 204 }
uci1 37:ff95e7070f26 205 if ( fComm->IsTimedOut(timeout_clock) ) {
uci1 25:57b2627fe756 206 if ( kFailTimeout < res ) {
uci1 25:57b2627fe756 207 res = kFailTimeout;
uci1 25:57b2627fe756 208 }
uci1 25:57b2627fe756 209 }
uci1 2:e67f7c158087 210 return res;
uci1 2:e67f7c158087 211 }
uci1 8:95a325df1f6b 212
uci1 40:1324da35afd4 213 SnCommWin::ECommWinResult SnCommWin::HandleHandshake(FILE* inf, const char* infn,
uci1 40:1324da35afd4 214 const SnConfigFrame& curConf,
uci1 40:1324da35afd4 215 SnEventFrame& evt,
uci1 40:1324da35afd4 216 SnPowerFrame& pow,
uci1 40:1324da35afd4 217 char* const genBuf,
uci1 40:1324da35afd4 218 const uint32_t bsize,
uci1 40:1324da35afd4 219 const uint32_t handshakeTimeout,
uci1 40:1324da35afd4 220 const uint8_t hndshk,
uci1 40:1324da35afd4 221 const uint32_t hndlen,
uci1 40:1324da35afd4 222 const uint32_t* nevts) {
uci1 40:1324da35afd4 223
uci1 40:1324da35afd4 224 SnCommWin::ECommWinResult res = SnCommWin::kUnexpectedRec;
uci1 40:1324da35afd4 225
uci1 40:1324da35afd4 226 if ( (hndshk==SnHeaderFrame::kHnShNoReplyCode)
uci1 40:1324da35afd4 227 || (hndshk==SnHeaderFrame::kHnShOkPartlCode) ) {
uci1 40:1324da35afd4 228 // nothing to do
uci1 40:1324da35afd4 229 res = SnCommWin::kOkWithMsg;
uci1 40:1324da35afd4 230 } else if (hndshk==SnHeaderFrame::kHnShFailNonCode) {
uci1 40:1324da35afd4 231 res = SnCommWin::kFailNoneSent;
uci1 40:1324da35afd4 232 } else if (hndshk==SnHeaderFrame::kHnShFailPrtCode) {
uci1 40:1324da35afd4 233 res = SnCommWin::kFailPartSent;
uci1 40:1324da35afd4 234 } else if (hndshk==SnHeaderFrame::kHnShOkComplCode) {
uci1 40:1324da35afd4 235 // file received
uci1 56:0bba0ef15697 236 #ifdef DEBUG
uci1 56:0bba0ef15697 237 printf("HnShOkCompl: isdel=%d, isCurFil=%d (%p,%p), nevts_ptr=%p\r\n",
uci1 56:0bba0ef15697 238 (int)(curConf.IsDeletingFiles()),
uci1 56:0bba0ef15697 239 (int)(inf==SnSDUtils::GetCurFile()),
uci1 56:0bba0ef15697 240 (void*)inf, (void*)(SnSDUtils::GetCurFile()),
uci1 56:0bba0ef15697 241 (void*)(nevts));
uci1 56:0bba0ef15697 242 if (nevts!=0) {
uci1 56:0bba0ef15697 243 printf("*nevts=%u\r\n",*nevts);
uci1 56:0bba0ef15697 244 }
uci1 56:0bba0ef15697 245 #endif
uci1 40:1324da35afd4 246 if ( (curConf.IsDeletingFiles())
uci1 40:1324da35afd4 247 && (inf!=SnSDUtils::GetCurFile())
uci1 40:1324da35afd4 248 && ((nevts!=0) && (*nevts==0)) ) { // whole file was received
uci1 40:1324da35afd4 249 // delete this file
uci1 40:1324da35afd4 250 #ifdef DEBUG
uci1 40:1324da35afd4 251 printf("deleting file %p, %s\r\n",inf,infn);
uci1 40:1324da35afd4 252 #endif
uci1 40:1324da35afd4 253 SnSDUtilsWhisperer::DeleteFile(inf, infn);
uci1 40:1324da35afd4 254 res = SnCommWin::kOkWthMsgDidDel;
uci1 40:1324da35afd4 255 } else {
uci1 40:1324da35afd4 256 res = SnCommWin::kOkWithMsg;
uci1 40:1324da35afd4 257 }
uci1 40:1324da35afd4 258 } else if ( hndshk==SnHeaderFrame::kHnShOkStopCode ) {
uci1 40:1324da35afd4 259 res = SnCommWin::kOkStopComm;
uci1 40:1324da35afd4 260 } else if ( (hndshk==SnHeaderFrame::kHnShOkDelAlCode) ||
uci1 40:1324da35afd4 261 (hndshk==SnHeaderFrame::kHnShOkDelRnCode) ) {
uci1 40:1324da35afd4 262 if ( GetDeleteAllConfirmCode(curConf,
uci1 40:1324da35afd4 263 kDelAllConfCodeLen,
uci1 40:1324da35afd4 264 handshakeTimeout,
uci1 40:1324da35afd4 265 genBuf, bsize) ) {
uci1 40:1324da35afd4 266 if (hndshk==SnHeaderFrame::kHnShOkDelAlCode) {
uci1 40:1324da35afd4 267 #ifdef DEBUG
uci1 40:1324da35afd4 268 printf("delete all\r\n");
uci1 40:1324da35afd4 269 #endif
uci1 40:1324da35afd4 270 SnSDUtilsWhisperer::DeleteAllFiles();
uci1 40:1324da35afd4 271 } else if (hndshk==SnHeaderFrame::kHnShOkDelRnCode) {
uci1 40:1324da35afd4 272 #ifdef DEBUG
uci1 40:1324da35afd4 273 printf("delete run %u\r\n",hndlen);
uci1 40:1324da35afd4 274 #endif
uci1 40:1324da35afd4 275 SnSDUtilsWhisperer::DeleteFilesOfRun(hndlen);
uci1 40:1324da35afd4 276 }
uci1 40:1324da35afd4 277 res = SnCommWin::kOkStopComm;
uci1 40:1324da35afd4 278 }
uci1 56:0bba0ef15697 279 } else if ( hndshk==SnHeaderFrame::kHnShOkClRSLCode ) {
uci1 56:0bba0ef15697 280 #ifdef DEBUG
uci1 56:0bba0ef15697 281 printf("clear run seq list requested\r\n");
uci1 56:0bba0ef15697 282 #endif
uci1 56:0bba0ef15697 283 SnSDUtils::ClearRunSeqList();
uci1 40:1324da35afd4 284 } else if ( hndshk==SnHeaderFrame::kHnShOkReqRnCode ) {
uci1 40:1324da35afd4 285 #ifdef DEBUG
uci1 40:1324da35afd4 286 printf("run %u requested\r\n",hndlen);
uci1 40:1324da35afd4 287 #endif
uci1 56:0bba0ef15697 288 if (fSendingInHandshake==false) {
uci1 56:0bba0ef15697 289 // prevent another SendAllOfRun handshake request until we're done
uci1 56:0bba0ef15697 290 // (allowing it could lead to a stack overflow)
uci1 56:0bba0ef15697 291 fSendingInHandshake = true;
uci1 56:0bba0ef15697 292 SnSDUtils::SendAllOfRun(this, handshakeTimeout,
uci1 56:0bba0ef15697 293 genBuf, bsize, curConf, evt, pow,
uci1 56:0bba0ef15697 294 hndlen);
uci1 56:0bba0ef15697 295 fSendingInHandshake = false;
uci1 56:0bba0ef15697 296 res = SnCommWin::kOkStopComm;
uci1 56:0bba0ef15697 297 }
uci1 56:0bba0ef15697 298 } else if ( hndshk==SnHeaderFrame::kHnShOkRqPtRnCode ) {
uci1 56:0bba0ef15697 299 #ifdef DEBUG
uci1 56:0bba0ef15697 300 printf("part of run %u requested\r\n",hndlen);
uci1 56:0bba0ef15697 301 #endif
uci1 56:0bba0ef15697 302 // need the seq limits -- another handshake message
uci1 56:0bba0ef15697 303 SendHndshkReq(genBuf, handshakeTimeout);
uci1 56:0bba0ef15697 304 uint8_t shndshk(0); uint32_t shndshkLen(0);
uci1 56:0bba0ef15697 305 res = WaitHandshake(curConf, handshakeTimeout, genBuf, bsize, shndshk,
uci1 56:0bba0ef15697 306 &shndshkLen);
uci1 56:0bba0ef15697 307 if (SnCommWin::kOkWithMsg==res) {
uci1 56:0bba0ef15697 308 if ( shndshk==SnHeaderFrame::kHnShOkRqPtSqCode ) {
uci1 56:0bba0ef15697 309 // ok got the min/max seq's as expected
uci1 56:0bba0ef15697 310 const uint16_t minseq = GetMinSeqFrom(shndshkLen);
uci1 56:0bba0ef15697 311 const uint16_t maxseq = GetMaxSeqFrom(shndshkLen);
uci1 56:0bba0ef15697 312 #ifdef DEBUG
uci1 56:0bba0ef15697 313 printf("[minseq=%hu, maxseq=%hu]\r\n",minseq,maxseq);
uci1 56:0bba0ef15697 314 #endif
uci1 56:0bba0ef15697 315 if (fSendingInHandshake==false) {
uci1 56:0bba0ef15697 316 // prevent another SendAllOfRun handshake request
uci1 56:0bba0ef15697 317 // until we're done
uci1 56:0bba0ef15697 318 // (allowing it could lead to a stack overflow)
uci1 56:0bba0ef15697 319 fSendingInHandshake = true;
uci1 56:0bba0ef15697 320 SnSDUtils::SendPartOfRun(this, handshakeTimeout,
uci1 56:0bba0ef15697 321 genBuf, bsize, curConf, evt, pow,
uci1 56:0bba0ef15697 322 hndlen, // the run num
uci1 56:0bba0ef15697 323 minseq, maxseq);
uci1 56:0bba0ef15697 324 fSendingInHandshake = false;
uci1 56:0bba0ef15697 325 }
uci1 56:0bba0ef15697 326 }
uci1 56:0bba0ef15697 327 }
uci1 40:1324da35afd4 328 res = SnCommWin::kOkStopComm;
uci1 40:1324da35afd4 329 }
uci1 40:1324da35afd4 330
uci1 40:1324da35afd4 331 return res;
uci1 40:1324da35afd4 332 }
uci1 40:1324da35afd4 333
uci1 40:1324da35afd4 334
uci1 27:efc4d654b139 335 bool SnCommWin::GetDeleteAllConfirmCode(const SnConfigFrame& conf,
uci1 27:efc4d654b139 336 const uint32_t length,
uci1 27:efc4d654b139 337 const uint32_t timeout,
uci1 27:efc4d654b139 338 char* const buf,
uci1 27:efc4d654b139 339 const uint32_t bsize) {
uci1 27:efc4d654b139 340 bool ret = false;
uci1 27:efc4d654b139 341 #ifdef DEBUG
uci1 40:1324da35afd4 342 printf("GetDeleteAllConfirmCode, timeout=%u\r\n",timeout);
uci1 27:efc4d654b139 343 #endif
uci1 27:efc4d654b139 344 // better pull all the bytes no matter the buffer size
uci1 27:efc4d654b139 345 const uint32_t ll = (bsize<length) ? bsize : length;
uci1 27:efc4d654b139 346 int mlen = 0;
uci1 27:efc4d654b139 347 while ( mlen<length ) {
uci1 40:1324da35afd4 348 mlen += fComm->ReceiveAll(buf, ll, timeout);
uci1 40:1324da35afd4 349 if (fComm->IsTimedOut(timeout)) {
uci1 27:efc4d654b139 350 break;
uci1 27:efc4d654b139 351 }
uci1 27:efc4d654b139 352 }
uci1 27:efc4d654b139 353 if (mlen==length) {
uci1 27:efc4d654b139 354 const char* b = buf;
uci1 27:efc4d654b139 355 const char* c = kDelAllConfCodeStr;
uci1 27:efc4d654b139 356 bool match = true;
uci1 27:efc4d654b139 357 for (uint8_t i=0; (i<kDelAllConfCodeLen) && match; ++i, ++b, ++c) {
uci1 27:efc4d654b139 358 match = ((*b)==(*c));
uci1 27:efc4d654b139 359 }
uci1 27:efc4d654b139 360 ret = match;
uci1 27:efc4d654b139 361 }
uci1 27:efc4d654b139 362 return ret;
uci1 27:efc4d654b139 363 }
uci1 27:efc4d654b139 364
uci1 21:ce51bb0ba4a5 365 SnCommWin::ECommWinResult SnCommWin::WaitHandshake(const SnConfigFrame& conf,
uci1 21:ce51bb0ba4a5 366 const uint32_t timeout,
uci1 8:95a325df1f6b 367 char* const buf,
uci1 8:95a325df1f6b 368 const uint32_t bsize,
uci1 27:efc4d654b139 369 uint8_t& hndShkCode,
uci1 27:efc4d654b139 370 uint32_t* hndShkLen) {
uci1 12:d472f9811262 371 #ifdef DEBUG
uci1 40:1324da35afd4 372 printf("WaitHandshake, timeout=%u\r\n",timeout);
uci1 12:d472f9811262 373 #endif
uci1 8:95a325df1f6b 374
uci1 40:1324da35afd4 375 const int mlen = fComm->ReceiveAll(buf, SnHeaderFrame::SizeOf(), timeout);
uci1 8:95a325df1f6b 376 if (mlen>0 && static_cast<uint32_t>(mlen) == SnHeaderFrame::SizeOf()) {
uci1 8:95a325df1f6b 377 uint32_t msgLen=0;
uci1 8:95a325df1f6b 378 const char* b = buf;
uci1 8:95a325df1f6b 379 SnHeaderFrame::ReadFrom(b, hndShkCode, msgLen);
uci1 12:d472f9811262 380 #ifdef DEBUG
uci1 12:d472f9811262 381 printf("got handshake code=%02x, len=%u\r\n",hndShkCode,msgLen);
uci1 12:d472f9811262 382 #endif
uci1 8:95a325df1f6b 383 if ((hndShkCode & SnHeaderFrame::kHndShkBits)!=0) {
uci1 27:efc4d654b139 384 if (hndShkLen!=0) {
uci1 27:efc4d654b139 385 *hndShkLen = msgLen;
uci1 27:efc4d654b139 386 }
uci1 8:95a325df1f6b 387 return SnCommWin::kOkWithMsg;
uci1 8:95a325df1f6b 388 } else {
uci1 8:95a325df1f6b 389 // TODO: somehow handle unexpected message?
uci1 8:95a325df1f6b 390 return SnCommWin::kUnexpectedRec;
uci1 8:95a325df1f6b 391 }
uci1 8:95a325df1f6b 392 }
uci1 8:95a325df1f6b 393 return SnCommWin::kOkNoMsg;
uci1 8:95a325df1f6b 394 }
uci1 8:95a325df1f6b 395
uci1 21:ce51bb0ba4a5 396 SnCommWin::ECommWinResult SnCommWin::GetFilename(const uint32_t timeout,
uci1 21:ce51bb0ba4a5 397 char* const buf,
uci1 21:ce51bb0ba4a5 398 const uint32_t namelen) {
uci1 21:ce51bb0ba4a5 399 // called by GetConfig upon receipt of a kMbedFilenameCode
uci1 21:ce51bb0ba4a5 400
uci1 21:ce51bb0ba4a5 401 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 402 printf("GetMbedFile, to=%u\r\n",timeout);
uci1 21:ce51bb0ba4a5 403 #endif
uci1 37:ff95e7070f26 404 const int mlen = fComm->ReceiveAll(buf, namelen, timeout);
uci1 21:ce51bb0ba4a5 405 if (mlen>0 && static_cast<uint32_t>(mlen) == namelen) {
uci1 21:ce51bb0ba4a5 406 return SnCommWin::kOkWithMsg;
uci1 21:ce51bb0ba4a5 407 }
uci1 21:ce51bb0ba4a5 408 return SnCommWin::kUnexpectedRec;
uci1 21:ce51bb0ba4a5 409 }
uci1 21:ce51bb0ba4a5 410
uci1 21:ce51bb0ba4a5 411 SnCommWin::ECommWinResult SnCommWin::GetLocalFile(std::string fname,
uci1 21:ce51bb0ba4a5 412 char* const buf,
uci1 21:ce51bb0ba4a5 413 const uint32_t bsize,
uci1 21:ce51bb0ba4a5 414 const uint32_t timeout) {
uci1 21:ce51bb0ba4a5 415 // get a file and save it locally with the specified name
uci1 21:ce51bb0ba4a5 416
uci1 21:ce51bb0ba4a5 417 // get the header for the file
uci1 21:ce51bb0ba4a5 418 uint8_t mcode=0; uint32_t mlen=0;
uci1 21:ce51bb0ba4a5 419 SnCommWin::ECommWinResult res =
uci1 21:ce51bb0ba4a5 420 GetHeader(timeout, buf, bsize, mcode, mlen);
uci1 54:ea1234a44fe8 421 #ifdef DEBUG
uci1 54:ea1234a44fe8 422 printf("Got header code %x, len %u\r\n",mcode,mlen);
uci1 54:ea1234a44fe8 423 #endif
uci1 54:ea1234a44fe8 424
uci1 21:ce51bb0ba4a5 425 if ( (res>=kOkWithMsg) && (mcode==SnHeaderFrame::kMbedFileCode) ) {
uci1 21:ce51bb0ba4a5 426 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 427 printf("Got mbed file header. File length = %u\r\n",mlen);
uci1 21:ce51bb0ba4a5 428 #endif
uci1 21:ce51bb0ba4a5 429 // got the header.. make the file..
uci1 21:ce51bb0ba4a5 430 // make the file name ALLCAPS, since LocalFileSystem will do it anyway
uci1 37:ff95e7070f26 431 SnCommPeripheral::CapitalizeInPlace(fname.begin(), fname.end());
uci1 21:ce51bb0ba4a5 432 // now ensure the file name is 8.3 only -- for LocalFileSystem
uci1 21:ce51bb0ba4a5 433 const size_t ldlen = strlen(kLocalDir);
uci1 21:ce51bb0ba4a5 434 // 12 = 8.3 filename format, 1 for / and 1 for \0
uci1 21:ce51bb0ba4a5 435 const uint32_t fbs = ldlen+1+12+1;
uci1 21:ce51bb0ba4a5 436 char fnb[fbs];
uci1 36:87865913ae6f 437 memset(fnb, 0, sizeof(char)*fbs);
uci1 40:1324da35afd4 438 // find the extension
uci1 40:1324da35afd4 439 const size_t xdot = fname.rfind('.');
uci1 40:1324da35afd4 440 if (xdot!=string::npos && (fname.size()==(4+xdot))) {
uci1 40:1324da35afd4 441 const size_t fnpl = (xdot>8) ? 8 : xdot;
uci1 40:1324da35afd4 442 char* fb = fnb;
uci1 40:1324da35afd4 443 memcpy(fb, kLocalDir, ldlen); fb+=ldlen; // /local
uci1 40:1324da35afd4 444 *fb = '/'; ++fb; // /
uci1 40:1324da35afd4 445 strncpy(fb, fname.c_str(), fnpl); fb+=fnpl; // FILENAME
uci1 40:1324da35afd4 446 *fb = '.'; ++fb; // .
uci1 40:1324da35afd4 447 strncpy(fb, fname.c_str()+xdot+1, 3); // EXT
uci1 40:1324da35afd4 448 // all that just for the file name!
uci1 40:1324da35afd4 449 FILE* lf = fopen(fnb,"wb");
uci1 21:ce51bb0ba4a5 450 #ifdef DEBUG
uci1 40:1324da35afd4 451 printf("tried to open file [%s]. lf=%p\r\n",fnb,(void*)lf);
uci1 21:ce51bb0ba4a5 452 #endif
uci1 40:1324da35afd4 453 // get all the data and dump it into the file
uci1 40:1324da35afd4 454 int b = 0, toget = 0;
uci1 40:1324da35afd4 455 while ( mlen>b ) {
uci1 40:1324da35afd4 456 if (fComm->IsTimedOut(timeout)) {
uci1 36:87865913ae6f 457 #ifdef DEBUG
uci1 40:1324da35afd4 458 printf("timeout while getting file\r\n");
uci1 36:87865913ae6f 459 #endif
uci1 40:1324da35afd4 460 res = kFailTimeout;
uci1 21:ce51bb0ba4a5 461 break;
uci1 21:ce51bb0ba4a5 462 }
uci1 40:1324da35afd4 463 toget = mlen - b;
uci1 40:1324da35afd4 464 if (toget>bsize) {
uci1 40:1324da35afd4 465 toget = bsize;
uci1 40:1324da35afd4 466 }
uci1 40:1324da35afd4 467 const int got = fComm->ReceiveAll(buf, toget, timeout);
uci1 40:1324da35afd4 468 if (lf!=NULL) {
uci1 36:87865913ae6f 469 #ifdef DEBUG
uci1 40:1324da35afd4 470 printf("writing %d bytes to file\r\n", got);
uci1 36:87865913ae6f 471 #endif
uci1 40:1324da35afd4 472 SnBitUtils::WriteTo(lf, buf, got);
uci1 40:1324da35afd4 473 }
uci1 40:1324da35afd4 474 b += got;
uci1 40:1324da35afd4 475 } // file data receive loop
uci1 40:1324da35afd4 476 uint32_t crc=0;
uci1 40:1324da35afd4 477 if (lf!=NULL) {
uci1 40:1324da35afd4 478 // calculate the crc from what's actually in the file
uci1 40:1324da35afd4 479 fclose(lf); // to flush it
uci1 36:87865913ae6f 480 #ifdef DEBUG
uci1 40:1324da35afd4 481 printf("fopen: %s\r\n",fnb);
uci1 36:87865913ae6f 482 #endif
uci1 40:1324da35afd4 483 lf = fopen(fnb,"rb");
uci1 40:1324da35afd4 484 fseek(lf, 0, SEEK_END);
uci1 40:1324da35afd4 485 int32_t fend = ftell(lf);
uci1 40:1324da35afd4 486 fseek(lf, 0, SEEK_SET);
uci1 40:1324da35afd4 487 char c;
uci1 40:1324da35afd4 488 for (int32_t i=0; i<fend; ++i) {
uci1 40:1324da35afd4 489 SnBitUtils::ReadFrom(lf, c);
uci1 40:1324da35afd4 490 if (feof(lf)==0 && ferror(lf)==0) {
uci1 40:1324da35afd4 491 crc = SnCRCUtils::update_crc32_xfer(crc, c);
uci1 40:1324da35afd4 492 } else {
uci1 40:1324da35afd4 493 break;
uci1 40:1324da35afd4 494 }
uci1 21:ce51bb0ba4a5 495 }
uci1 40:1324da35afd4 496 fclose(lf);
uci1 40:1324da35afd4 497 #ifdef DEBUG
uci1 40:1324da35afd4 498 printf("closed file. crc = %u\r\n", crc);
uci1 40:1324da35afd4 499 #endif
uci1 40:1324da35afd4 500 } // if output file not 0
uci1 40:1324da35afd4 501 #ifdef DEBUG
uci1 40:1324da35afd4 502 printf("mlen=%u, b=%d, eq=%s\r\n",mlen,b,
uci1 40:1324da35afd4 503 (mlen==b)?"true":"false");
uci1 40:1324da35afd4 504 #endif
uci1 40:1324da35afd4 505 if ( mlen!=b ) {
uci1 40:1324da35afd4 506 if (res > kUnexpectedRec) {
uci1 40:1324da35afd4 507 res = kUnexpectedRec;
uci1 40:1324da35afd4 508 } // otherwise it's already worse
uci1 40:1324da35afd4 509 } else {
uci1 40:1324da35afd4 510 // check that the file is ok
uci1 40:1324da35afd4 511 // get the checksum
uci1 40:1324da35afd4 512 res = GetHeader(timeout, buf, bsize, mcode, mlen);
uci1 40:1324da35afd4 513 if ( (res>=kOkWithMsg) && (mcode==SnHeaderFrame::kMbedFileChksCode) ) {
uci1 40:1324da35afd4 514 #ifdef DEBUG
uci1 40:1324da35afd4 515 printf("received chksum=%u, crc=%u, eq=%s\r\n",
uci1 40:1324da35afd4 516 mlen,crc,(crc==mlen)?"true":"false");
uci1 40:1324da35afd4 517 #endif
uci1 40:1324da35afd4 518 if (crc != mlen) {
uci1 36:87865913ae6f 519 #ifdef DEBUG
uci1 40:1324da35afd4 520 printf("checksums differ! unexpected.\r\n");
uci1 40:1324da35afd4 521 #endif
uci1 40:1324da35afd4 522 res = kUnexpectedRec; // important!
uci1 40:1324da35afd4 523 }
uci1 40:1324da35afd4 524 }
uci1 40:1324da35afd4 525 } // end get remote file checksum
uci1 40:1324da35afd4 526
uci1 40:1324da35afd4 527 if (lf!=NULL) {
uci1 40:1324da35afd4 528 if ( res<kOkWithMsg ) {
uci1 40:1324da35afd4 529 // timeout, bad checksum, something else bad?
uci1 40:1324da35afd4 530 #ifdef DEBUG
uci1 40:1324da35afd4 531 printf("removing %s\r\n",fnb);
uci1 36:87865913ae6f 532 #endif
uci1 40:1324da35afd4 533 remove(fnb); // delete the file
uci1 40:1324da35afd4 534 } else {
uci1 40:1324da35afd4 535 // if we got a new program, remove the old ones.
uci1 40:1324da35afd4 536 // (schedule myself for immediate de-resolution)
uci1 40:1324da35afd4 537 //
uci1 40:1324da35afd4 538 // first just count how many we would save
uci1 40:1324da35afd4 539 const uint16_t nSavedBins = LoopLocalDirBinFiles(false, fname);
uci1 36:87865913ae6f 540 #ifdef DEBUG
uci1 40:1324da35afd4 541 printf("nSavedBins=%hu",nSavedBins);
uci1 36:87865913ae6f 542 #endif
uci1 40:1324da35afd4 543 if (nSavedBins==1) {
uci1 40:1324da35afd4 544 // ok. new program will be the only one. remove the others
uci1 40:1324da35afd4 545 // hope the new program works!
uci1 40:1324da35afd4 546 LoopLocalDirBinFiles(true, fname);
uci1 36:87865913ae6f 547
uci1 36:87865913ae6f 548 #ifdef DEBUG
uci1 40:1324da35afd4 549 printf("rebooting\r\n");
uci1 36:87865913ae6f 550 #endif
uci1 40:1324da35afd4 551 // goodbye cruel world, it's over. walk on by...
uci1 40:1324da35afd4 552 mbed_reset();
uci1 40:1324da35afd4 553 }
uci1 40:1324da35afd4 554 } // end check new program block
uci1 40:1324da35afd4 555 } // if output file not 0
uci1 40:1324da35afd4 556 } else {
uci1 40:1324da35afd4 557 // filename mangled. either doesn't contain a '.'
uci1 40:1324da35afd4 558 // or the extension is longer than 3 letters
uci1 54:ea1234a44fe8 559 #ifdef DEBUG
uci1 54:ea1234a44fe8 560 printf("filname mangled. (%s) size=%u, xdot=%u",
uci1 54:ea1234a44fe8 561 fname.c_str(), fname.size(), xdot);
uci1 54:ea1234a44fe8 562 #endif
uci1 40:1324da35afd4 563 res = SnCommWin::kUnexpectedRec;
uci1 21:ce51bb0ba4a5 564 }
uci1 40:1324da35afd4 565 } // if header ok
uci1 54:ea1234a44fe8 566
uci1 21:ce51bb0ba4a5 567 return res;
uci1 21:ce51bb0ba4a5 568 }
uci1 21:ce51bb0ba4a5 569
uci1 21:ce51bb0ba4a5 570 int16_t SnCommWin::LoopLocalDirBinFiles(const bool doRemove,
uci1 21:ce51bb0ba4a5 571 const std::string& fname) {
uci1 21:ce51bb0ba4a5 572 // loop over the local directory, count the BIN files that match 'fname'
uci1 21:ce51bb0ba4a5 573 //
uci1 21:ce51bb0ba4a5 574 // fname is assumed to be all caps already!
uci1 21:ce51bb0ba4a5 575 //
uci1 21:ce51bb0ba4a5 576 // if doRemove==true, will actually delete non-matching files
uci1 21:ce51bb0ba4a5 577 //
uci1 21:ce51bb0ba4a5 578 // return number of non-matching files
uci1 21:ce51bb0ba4a5 579 uint16_t nSavedBins = 0;
uci1 21:ce51bb0ba4a5 580 DIR* d( opendir(kLocalDir) );
uci1 21:ce51bb0ba4a5 581 struct dirent* dent;
uci1 21:ce51bb0ba4a5 582 if ( d!=NULL ) {
uci1 21:ce51bb0ba4a5 583 while ( (dent = readdir(d))!=NULL ) {
uci1 21:ce51bb0ba4a5 584 const size_t flen = strlen(dent->d_name);
uci1 21:ce51bb0ba4a5 585 const char* dext = dent->d_name + flen - 4;
uci1 21:ce51bb0ba4a5 586 if ( strncmp(dext,".BIN",4)==0 || strncmp(dext,".bin",4)==0 ) {
uci1 21:ce51bb0ba4a5 587 // ends with .BIN
uci1 21:ce51bb0ba4a5 588 if (strncmp(dent->d_name, fname.c_str(), fname.size())!=0) {
uci1 21:ce51bb0ba4a5 589 // some other mbed program than our new one
uci1 21:ce51bb0ba4a5 590 std::string dfn(kLocalDir);
uci1 21:ce51bb0ba4a5 591 dfn += "/";
uci1 21:ce51bb0ba4a5 592 dfn += dent->d_name;
uci1 21:ce51bb0ba4a5 593 if (doRemove) {
uci1 21:ce51bb0ba4a5 594 remove(dfn.c_str());
uci1 21:ce51bb0ba4a5 595 }
uci1 21:ce51bb0ba4a5 596 } else {
uci1 21:ce51bb0ba4a5 597 ++nSavedBins;
uci1 21:ce51bb0ba4a5 598 }
uci1 21:ce51bb0ba4a5 599 } // else not an mbed program
uci1 21:ce51bb0ba4a5 600 }
uci1 21:ce51bb0ba4a5 601 closedir(d);
uci1 21:ce51bb0ba4a5 602 }
uci1 21:ce51bb0ba4a5 603 return nSavedBins;
uci1 21:ce51bb0ba4a5 604 }
uci1 21:ce51bb0ba4a5 605
uci1 21:ce51bb0ba4a5 606 SnCommWin::ECommWinResult SnCommWin::GetHeader(const uint32_t timeOut,
uci1 21:ce51bb0ba4a5 607 char* const buf,
uci1 21:ce51bb0ba4a5 608 const uint32_t bsize,
uci1 21:ce51bb0ba4a5 609 uint8_t& mcode,
uci1 21:ce51bb0ba4a5 610 uint32_t& mlen) {
uci1 21:ce51bb0ba4a5 611 SnCommWin::ECommWinResult res = SnCommWin::kUndefFail;
uci1 21:ce51bb0ba4a5 612 if (bsize>=SnHeaderFrame::kMaxSizeOf) {
uci1 21:ce51bb0ba4a5 613 // get header
uci1 37:ff95e7070f26 614 const int hlen = fComm->ReceiveAll(buf, SnHeaderFrame::SizeOf(), timeOut);
uci1 21:ce51bb0ba4a5 615 if (hlen>0 && static_cast<uint32_t>(hlen)==SnHeaderFrame::SizeOf()) {
uci1 21:ce51bb0ba4a5 616 mcode=0;
uci1 21:ce51bb0ba4a5 617 mlen=0;
uci1 21:ce51bb0ba4a5 618 const char* b = buf;
uci1 21:ce51bb0ba4a5 619 SnHeaderFrame::ReadFrom(b, mcode, mlen);
uci1 21:ce51bb0ba4a5 620 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 621 printf("mcode=%02x, mlen=%u\r\n", mcode, mlen);
uci1 21:ce51bb0ba4a5 622 #endif
uci1 21:ce51bb0ba4a5 623 res = SnCommWin::kOkWithMsg;
uci1 21:ce51bb0ba4a5 624 }
uci1 21:ce51bb0ba4a5 625 }
uci1 21:ce51bb0ba4a5 626 return res;
uci1 21:ce51bb0ba4a5 627 }
uci1 21:ce51bb0ba4a5 628
uci1 8:95a325df1f6b 629 SnCommWin::ECommWinResult SnCommWin::GetConfig(SnConfigFrame& conf,
uci1 8:95a325df1f6b 630 const uint32_t timeOut,
uci1 8:95a325df1f6b 631 char* const confBuf,
uci1 8:95a325df1f6b 632 const uint32_t bsize) {
uci1 8:95a325df1f6b 633 // confBuf assumed to alread be of allocated size
uci1 8:95a325df1f6b 634
uci1 12:d472f9811262 635 #ifdef DEBUG
uci1 8:95a325df1f6b 636 printf("GetConfig, to=%u\r\n",timeOut);
uci1 12:d472f9811262 637 #endif
uci1 8:95a325df1f6b 638
uci1 8:95a325df1f6b 639 SnCommWin::ECommWinResult res = SnCommWin::kUndefFail;
uci1 21:ce51bb0ba4a5 640 if (bsize>=SnConfigFrame::kMaxSizeOf) {
uci1 8:95a325df1f6b 641 // get header
uci1 21:ce51bb0ba4a5 642 uint8_t mcode=0; uint32_t mlen=0;
uci1 21:ce51bb0ba4a5 643 res = GetHeader(timeOut, confBuf, bsize, mcode, mlen);
uci1 21:ce51bb0ba4a5 644 if (res>=SnCommWin::kOkWithMsg) {
uci1 12:d472f9811262 645 if (mcode==SnHeaderFrame::kNoConfigCode) {
uci1 12:d472f9811262 646 // no config to get
uci1 16:744ce85aede2 647 res = SnCommWin::kOkWthMsgNoConf;
uci1 21:ce51bb0ba4a5 648 } else if (mcode==SnHeaderFrame::kMbedFilenameCode) {
uci1 21:ce51bb0ba4a5 649 res = GetFilename(timeOut, confBuf, mlen);
uci1 21:ce51bb0ba4a5 650 if (res>kAllFails) {
uci1 54:ea1234a44fe8 651 std::string fnameb(confBuf, mlen); // the filename
uci1 54:ea1234a44fe8 652 std::string fname(fnameb.c_str()); // mlen may include the \0 which would be counted in size()
uci1 21:ce51bb0ba4a5 653 #ifdef DEBUG
uci1 54:ea1234a44fe8 654 printf("got filename = [%s] (%u)\r\n", fname.c_str(), fname.size());
uci1 21:ce51bb0ba4a5 655 #endif
uci1 21:ce51bb0ba4a5 656 res = GetLocalFile(fname, confBuf, bsize, timeOut);
uci1 21:ce51bb0ba4a5 657 }
uci1 12:d472f9811262 658 } else if (mcode!=SnHeaderFrame::kConfigCode) {
uci1 8:95a325df1f6b 659 res = SnCommWin::kUnexpectedRec;
uci1 8:95a325df1f6b 660 } else {
uci1 8:95a325df1f6b 661 // get config
uci1 37:ff95e7070f26 662 const int clen = fComm->ReceiveAll(confBuf, mlen, timeOut);
uci1 8:95a325df1f6b 663 if (clen>0 && static_cast<uint32_t>(clen)==mlen) {
uci1 40:1324da35afd4 664 const uint8_t Rv = SnConfigFrame::PeekIOversion(confBuf);
uci1 40:1324da35afd4 665 if (SnConfigFrame::IsIOversionOk(Rv)) {
uci1 40:1324da35afd4 666 const char* b = confBuf;
uci1 40:1324da35afd4 667 conf.ReadFrom(b);
uci1 40:1324da35afd4 668 res = SnCommWin::kOkWithMsg;
uci1 40:1324da35afd4 669 } else {
uci1 40:1324da35afd4 670 res = SnCommWin::kUnexpectedRec;
uci1 40:1324da35afd4 671 char s[256];
uci1 40:1324da35afd4 672 sprintf(s,"Cannot accept config version [%hhu]. "
uci1 40:1324da35afd4 673 "Expect [%hhu].",Rv,SnConfigFrame::kIOVers);
uci1 40:1324da35afd4 674 SendString(s, timeOut);
uci1 40:1324da35afd4 675 }
uci1 8:95a325df1f6b 676 } else {
uci1 8:95a325df1f6b 677 res = SnCommWin::kUnexpectedRec;
uci1 8:95a325df1f6b 678 }
uci1 8:95a325df1f6b 679 }
uci1 8:95a325df1f6b 680 } else {
uci1 21:ce51bb0ba4a5 681 // not a problem if we get nothing (or no config)
uci1 16:744ce85aede2 682 res = SnCommWin::kOkNoMsg;
uci1 8:95a325df1f6b 683 }
uci1 8:95a325df1f6b 684 }
uci1 8:95a325df1f6b 685 return res;
uci1 8:95a325df1f6b 686 }
uci1 8:95a325df1f6b 687
uci1 40:1324da35afd4 688 int32_t SnCommWin::SendHndshkReq(char* const genBuf,
uci1 40:1324da35afd4 689 const uint32_t timeout_clock) {
uci1 40:1324da35afd4 690 // send a request demanding a handshake
uci1 40:1324da35afd4 691 // as we will be waiting for a response after this,
uci1 40:1324da35afd4 692 // FinishSending is also called
uci1 40:1324da35afd4 693 char* b = genBuf;
uci1 40:1324da35afd4 694 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kHnShDemandCode, 0);
uci1 40:1324da35afd4 695 const uint32_t bytesToBeSent = b-genBuf;
uci1 40:1324da35afd4 696 const int32_t mlen = fComm->SendAll(genBuf, bytesToBeSent, timeout_clock);
uci1 40:1324da35afd4 697 const int32_t flen = fComm->FinishSending(timeout_clock);
uci1 40:1324da35afd4 698 #ifdef DEBUG
uci1 40:1324da35afd4 699 printf("SendHndshkReq: time = %u, timeout = %u, mlen=%d, flen=%d\r\n",
uci1 40:1324da35afd4 700 time(0), timeout_clock, mlen, flen);
uci1 40:1324da35afd4 701 #endif
uci1 40:1324da35afd4 702 return mlen+flen;
uci1 40:1324da35afd4 703 }
uci1 40:1324da35afd4 704
uci1 41:d6f5e2f09e07 705 SnCommWin::ECommWinResult SnCommWin::SendSignalStrength(char* const genBuf,
uci1 41:d6f5e2f09e07 706 SnSignalStrengthFrame& sigstr,
uci1 41:d6f5e2f09e07 707 const uint32_t timeout_clock) {
uci1 41:d6f5e2f09e07 708 // try to get the signal strength and send it if possible
uci1 41:d6f5e2f09e07 709 float ss;
uci1 41:d6f5e2f09e07 710 if ( fComm->CheckSignalStrength(timeout_clock, ss) ) {
uci1 41:d6f5e2f09e07 711 char* b = genBuf;
uci1 41:d6f5e2f09e07 712 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kSignalStrCode, sigstr.SizeOf());
uci1 41:d6f5e2f09e07 713 sigstr.SetSigStr(ss, time(0));
uci1 41:d6f5e2f09e07 714 sigstr.SetCommType( static_cast<uint8_t>(GetCommType()) );
uci1 41:d6f5e2f09e07 715 sigstr.WriteTo(b);
uci1 41:d6f5e2f09e07 716 const uint32_t bytesToBeSent = b - genBuf;
uci1 41:d6f5e2f09e07 717 const int32_t mlen = fComm->SendAll(genBuf, bytesToBeSent, timeout_clock);
uci1 41:d6f5e2f09e07 718 const int32_t flen = fComm->FinishSending(timeout_clock);
uci1 41:d6f5e2f09e07 719 if (bytesToBeSent==(mlen+flen)) {
uci1 41:d6f5e2f09e07 720 return SnCommWin::kOkMsgSent;
uci1 41:d6f5e2f09e07 721 } else {
uci1 41:d6f5e2f09e07 722 return SnCommWin::kFailPartSent;
uci1 41:d6f5e2f09e07 723 }
uci1 41:d6f5e2f09e07 724 }
uci1 41:d6f5e2f09e07 725 return SnCommWin::kFailNoneSent;
uci1 41:d6f5e2f09e07 726 }
uci1 41:d6f5e2f09e07 727
uci1 8:95a325df1f6b 728 SnCommWin::ECommWinResult SnCommWin::SendStatus(const SnConfigFrame& conf,
uci1 8:95a325df1f6b 729 const SnEventFrame& evt,
uci1 8:95a325df1f6b 730 const SnPowerFrame& pow,
uci1 10:3c93db1cfb12 731 const uint16_t seq,
uci1 10:3c93db1cfb12 732 const float thmrate,
uci1 10:3c93db1cfb12 733 const float evtrate,
uci1 56:0bba0ef15697 734 const uint32_t powerOnTime,
uci1 56:0bba0ef15697 735 const SnTempFrame& temper,
uci1 8:95a325df1f6b 736 char* const genBuf,
uci1 8:95a325df1f6b 737 const uint32_t timeout_clock) {
uci1 8:95a325df1f6b 738 // TODO: check if connected?
uci1 12:d472f9811262 739 #ifdef DEBUG
uci1 12:d472f9811262 740 printf("########### Send Status\r\n");
uci1 12:d472f9811262 741 #endif
uci1 21:ce51bb0ba4a5 742 uint8_t loseLSB=0, loseMSB=0;
uci1 21:ce51bb0ba4a5 743 uint16_t wvBase=0;
uci1 21:ce51bb0ba4a5 744 conf.GetPackParsFor(GetCommType(), loseLSB, loseMSB, wvBase);
uci1 8:95a325df1f6b 745 const uint32_t ssize = SnStatusFrame::SizeOf(SnStatusFrame::kIOVers, conf);
uci1 8:95a325df1f6b 746 char* b = genBuf;
uci1 8:95a325df1f6b 747 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kStatusCode, ssize);
uci1 56:0bba0ef15697 748 SnStatusFrame::WriteTo(b, conf, evt, genBuf, seq, thmrate, evtrate,
uci1 56:0bba0ef15697 749 powerOnTime, temper,
uci1 21:ce51bb0ba4a5 750 loseLSB, loseMSB, wvBase);
uci1 10:3c93db1cfb12 751 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kPowerCode,
uci1 10:3c93db1cfb12 752 pow.SizeOf(SnPowerFrame::kIOvers));
uci1 10:3c93db1cfb12 753 pow.WriteTo(b);
uci1 40:1324da35afd4 754 int32_t msiz = b-genBuf;
uci1 18:55f1581f2ee4 755 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 756 printf("calling SendAll (status)\r\n");
uci1 18:55f1581f2ee4 757 #endif
uci1 40:1324da35afd4 758 int32_t mlen = fComm->SendAll(genBuf, msiz, timeout_clock);
uci1 41:d6f5e2f09e07 759 #ifdef DEBUG
uci1 41:d6f5e2f09e07 760 printf("SendAll returned %d\r\n",mlen);
uci1 41:d6f5e2f09e07 761 #endif
uci1 40:1324da35afd4 762 mlen += fComm->FinishSending(timeout_clock);
uci1 8:95a325df1f6b 763 #ifdef DEBUG
uci1 41:d6f5e2f09e07 764 printf("mlen=%d after FinishSending. msiz=%d\r\n",mlen,msiz);
uci1 8:95a325df1f6b 765 printf("status frame:\r\n");
uci1 15:f2569d8e4176 766 for (uint32_t i=0; i<msiz; i++) {
uci1 8:95a325df1f6b 767 printf("%02X ",genBuf[i]);
uci1 8:95a325df1f6b 768 }
uci1 8:95a325df1f6b 769 printf("\r\n");
uci1 8:95a325df1f6b 770 #endif
uci1 8:95a325df1f6b 771 if (mlen==msiz) {
uci1 12:d472f9811262 772 #ifdef DEBUG
uci1 10:3c93db1cfb12 773 printf("status+power sent\r\n");
uci1 12:d472f9811262 774 #endif
uci1 21:ce51bb0ba4a5 775 // event compression parameters must be the same
uci1 21:ce51bb0ba4a5 776 // as those sent in the status update
uci1 8:95a325df1f6b 777 b = genBuf;
uci1 10:3c93db1cfb12 778 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kEventCode,
uci1 21:ce51bb0ba4a5 779 evt.SizeOf(SnEventFrame::kIOVers, loseLSB, loseMSB));
uci1 21:ce51bb0ba4a5 780 b = evt.WriteTo(b, loseLSB, loseMSB, wvBase);
uci1 21:ce51bb0ba4a5 781 msiz = b-genBuf;
uci1 16:744ce85aede2 782 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 783 printf("calling SendAll (event) %d:\r\n",msiz);
uci1 21:ce51bb0ba4a5 784 for (uint32_t i=0; i<msiz; i++) {
uci1 21:ce51bb0ba4a5 785 printf("%02X ",genBuf[i]);
uci1 21:ce51bb0ba4a5 786 }
uci1 21:ce51bb0ba4a5 787 printf("\r\n");
uci1 21:ce51bb0ba4a5 788 #endif
uci1 37:ff95e7070f26 789 mlen = fComm->SendAll(genBuf, msiz, timeout_clock);
uci1 40:1324da35afd4 790 mlen += fComm->FinishSending(timeout_clock);
uci1 21:ce51bb0ba4a5 791 if (mlen==msiz) {
uci1 21:ce51bb0ba4a5 792 return SnCommWin::kOkMsgSent;
uci1 21:ce51bb0ba4a5 793 }
uci1 8:95a325df1f6b 794 }
uci1 8:95a325df1f6b 795 return SnCommWin::kFailPartSent;
uci1 8:95a325df1f6b 796 }
uci1 8:95a325df1f6b 797
uci1 27:efc4d654b139 798
uci1 23:ccf39298f205 799 SnCommWin::ECommWinResult SnCommWin::SendString(const char* str,
uci1 23:ccf39298f205 800 const uint32_t timeout) {
uci1 23:ccf39298f205 801 #ifdef DEBUG
uci1 23:ccf39298f205 802 printf("SnCommWin::SendString %s\r\n",str);
uci1 23:ccf39298f205 803 #endif
uci1 37:ff95e7070f26 804 const bool ok = fComm->SendString(str, timeout);
uci1 37:ff95e7070f26 805 return (ok) ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
uci1 23:ccf39298f205 806 }
uci1 23:ccf39298f205 807
uci1 40:1324da35afd4 808 int32_t SnCommWin::SendFilename(const char* inf,
uci1 40:1324da35afd4 809 char* const genBuf,
uci1 40:1324da35afd4 810 int32_t& bytesToBeSent,
uci1 40:1324da35afd4 811 const uint32_t timeout_clock) {
uci1 12:d472f9811262 812 #ifdef DEBUG
uci1 12:d472f9811262 813 printf("SnCommWin::SendFilename %s\r\n",inf);
uci1 12:d472f9811262 814 #endif
uci1 16:744ce85aede2 815
uci1 12:d472f9811262 816 // remove the directory
uci1 12:d472f9811262 817 const char* fn = strrchr(inf, '/');
uci1 12:d472f9811262 818 if (fn==0) {
uci1 12:d472f9811262 819 // no directory
uci1 12:d472f9811262 820 fn = inf;
uci1 12:d472f9811262 821 } else if (fn!=inf) {
uci1 12:d472f9811262 822 ++fn; // move past the '/' if it was found
uci1 12:d472f9811262 823 }
uci1 12:d472f9811262 824 #ifdef DEBUG
uci1 12:d472f9811262 825 printf("send %s\r\n",fn);
uci1 12:d472f9811262 826 #endif
uci1 8:95a325df1f6b 827 const size_t flen = strlen(fn);
uci1 8:95a325df1f6b 828 char* b = genBuf;
uci1 8:95a325df1f6b 829 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFilenameCode, flen);
uci1 12:d472f9811262 830 b = SnBitUtils::WriteTo(b, fn, flen);
uci1 40:1324da35afd4 831 bytesToBeSent = b-genBuf;
uci1 40:1324da35afd4 832 const int32_t mlen = fComm->SendAll(genBuf, bytesToBeSent, timeout_clock);
uci1 12:d472f9811262 833 #ifdef DEBUG
uci1 12:d472f9811262 834 printf("time = %u, timeout = %u\r\n",time(0), timeout_clock);
uci1 12:d472f9811262 835 #endif
uci1 40:1324da35afd4 836 return mlen;
uci1 8:95a325df1f6b 837 }
uci1 8:95a325df1f6b 838
uci1 40:1324da35afd4 839 int32_t SnCommWin::SendFileBlock(FILE* inf,
uci1 40:1324da35afd4 840 const uint8_t blockHeaderCode,
uci1 40:1324da35afd4 841 const uint32_t blockSize,
uci1 40:1324da35afd4 842 char* const genBuf,
uci1 40:1324da35afd4 843 int32_t& bytesToSend,
uci1 40:1324da35afd4 844 const uint32_t timeout) {
uci1 12:d472f9811262 845 // sends the block from the file. does not check if the file has sufficient bytes
uci1 12:d472f9811262 846 // this should be done before calling this function
uci1 12:d472f9811262 847 // (where the number of bytes in the file can be cached)
uci1 40:1324da35afd4 848 //
uci1 40:1324da35afd4 849 // bytesToSend will be set to the total bytes that should be delivered eventually
uci1 40:1324da35afd4 850 // the number of bytes actually shipped out by SendAll is returned
uci1 12:d472f9811262 851 char* b = genBuf;
uci1 12:d472f9811262 852 SnHeaderFrame::WriteTo(b, blockHeaderCode, blockSize);
uci1 12:d472f9811262 853 SnBitUtils::ReadFrom(inf, b, blockSize);
uci1 12:d472f9811262 854 #ifdef DEBUG
uci1 12:d472f9811262 855 printf("Sending block hc %02x, len=%u\r\n",blockHeaderCode,blockSize+SnHeaderFrame::SizeOf());
uci1 12:d472f9811262 856 #endif
uci1 40:1324da35afd4 857 bytesToSend = blockSize+SnHeaderFrame::SizeOf();
uci1 40:1324da35afd4 858 return fComm->SendAll(genBuf, bytesToSend, timeout);
uci1 12:d472f9811262 859 }
uci1 12:d472f9811262 860
uci1 40:1324da35afd4 861 int32_t SnCommWin::SendFileContents(FILE* inf,
uci1 40:1324da35afd4 862 const SnConfigFrame& curConf,
uci1 40:1324da35afd4 863 SnEventFrame& evt,
uci1 40:1324da35afd4 864 SnPowerFrame& pow,
uci1 40:1324da35afd4 865 char* const genBuf,
uci1 40:1324da35afd4 866 uint32_t nevts,
uci1 40:1324da35afd4 867 int32_t& bytesToBeSent,
uci1 40:1324da35afd4 868 const uint32_t timeout_clock) {
uci1 12:d472f9811262 869 // firstEvt==0 ==> start at beginning
uci1 12:d472f9811262 870 // nevts==0 ==> all events
uci1 40:1324da35afd4 871 //
uci1 40:1324da35afd4 872 // bytesToSend will be set to the total bytes that should be delivered eventually
uci1 40:1324da35afd4 873 // the number of bytes actually shipped out by SendAll is returned
uci1 12:d472f9811262 874
uci1 12:d472f9811262 875 #ifdef DEBUG
uci1 12:d472f9811262 876 printf("SendFileContents (byte streaming)\r\n");
uci1 12:d472f9811262 877 #endif
uci1 12:d472f9811262 878
uci1 12:d472f9811262 879 // store position in file so we can go back to it afterwards
uci1 12:d472f9811262 880 // this is probably not necessary, because if this file is open
uci1 12:d472f9811262 881 // in write-only mode, we're screwed..
uci1 12:d472f9811262 882 const int fpos = ftell(inf);
uci1 12:d472f9811262 883 if (fpos>0) {
uci1 12:d472f9811262 884 fseek(inf, 0, SEEK_SET);
uci1 12:d472f9811262 885 }
uci1 12:d472f9811262 886 // how many bytes?
uci1 12:d472f9811262 887 fseek(inf, 0, SEEK_END); // go to end
uci1 12:d472f9811262 888 const int fend = ftell(inf);
uci1 12:d472f9811262 889 fseek(inf, 0, SEEK_SET); // go to start
uci1 12:d472f9811262 890 #ifdef DEBUG
uci1 12:d472f9811262 891 printf("fend=%d\r\n",fend);
uci1 12:d472f9811262 892 printf("fpos=%d\r\n",fpos);
uci1 12:d472f9811262 893 #endif
uci1 12:d472f9811262 894
uci1 12:d472f9811262 895 // variables used when sending data
uci1 12:d472f9811262 896 char* b = genBuf;
uci1 40:1324da35afd4 897 int32_t msiz(0), mlen(0), mtogo(0), tsent(0);
uci1 21:ce51bb0ba4a5 898 // count number of events / power readings sent
uci1 40:1324da35afd4 899 uint32_t evtsSent=0, powsSent=0, crc=0;
uci1 12:d472f9811262 900
uci1 12:d472f9811262 901 // first is the file header, which has no SnHeaderFrame
uci1 12:d472f9811262 902 msiz = SnSDUtils::SizeOfFileHeader(SnSDUtils::kIOvers);
uci1 12:d472f9811262 903 bool ok = (ftell(inf)+msiz)<=fend;
uci1 12:d472f9811262 904 if (ok) {
uci1 12:d472f9811262 905 mlen = SendFileBlock(inf, SnHeaderFrame::kFileHeadrCode,
uci1 40:1324da35afd4 906 msiz, genBuf, mtogo, timeout_clock);
uci1 40:1324da35afd4 907 //ok &= (msiz+SnHeaderFrame::SizeOf())==mlen;
uci1 40:1324da35afd4 908 bytesToBeSent += mtogo;
uci1 40:1324da35afd4 909 tsent += mlen;
uci1 12:d472f9811262 910 #ifdef DEBUG
uci1 12:d472f9811262 911 printf("sent file header. ok=%d\r\n",(int)ok);
uci1 12:d472f9811262 912 #endif
uci1 40:1324da35afd4 913 // calc crc w/o the header block of the file header, as
uci1 40:1324da35afd4 914 // this does not get stored in the file
uci1 40:1324da35afd4 915 crc = SnCRCUtils::GetUpdatedCRC32for(crc, genBuf+SnHeaderFrame::SizeOf(),
uci1 40:1324da35afd4 916 mtogo-SnHeaderFrame::SizeOf());
uci1 40:1324da35afd4 917
uci1 12:d472f9811262 918 // the header info for each block
uci1 40:1324da35afd4 919 uint8_t hcode(0);
uci1 40:1324da35afd4 920 uint32_t hlen(0);
uci1 12:d472f9811262 921
uci1 12:d472f9811262 922 // now just loop through file and send each block
uci1 18:55f1581f2ee4 923 bool fok = true;
uci1 18:55f1581f2ee4 924 while ( fok
uci1 12:d472f9811262 925 && (feof(inf)==0)
uci1 12:d472f9811262 926 && (ferror(inf)==0)
uci1 12:d472f9811262 927 && ((ftell(inf)+SnHeaderFrame::SizeOf())<=fend) ) {
uci1 12:d472f9811262 928 // read the header for the block
uci1 12:d472f9811262 929 SnSDUtils::ReadBlockHeader(inf, hcode, hlen);
uci1 18:55f1581f2ee4 930 fok &= (ftell(inf)+hlen)<=fend;
uci1 12:d472f9811262 931 #ifdef DEBUG
uci1 18:55f1581f2ee4 932 printf("new block: hc=%02x, hl=%u, ftell=%d, fend=%d, "
uci1 18:55f1581f2ee4 933 "ok=%d, fok=%d\r\n",
uci1 18:55f1581f2ee4 934 hcode, hlen, ftell(inf), fend, (int)ok, (int)fok);
uci1 12:d472f9811262 935 #endif
uci1 40:1324da35afd4 936 if (fok) {
uci1 12:d472f9811262 937 // send the block
uci1 12:d472f9811262 938 // TODO: repack events?
uci1 40:1324da35afd4 939 mlen = SendFileBlock(inf, hcode, hlen, genBuf,
uci1 40:1324da35afd4 940 mtogo, timeout_clock);
uci1 40:1324da35afd4 941 bytesToBeSent += mtogo;
uci1 40:1324da35afd4 942 tsent += mlen;
uci1 40:1324da35afd4 943 crc = SnCRCUtils::GetUpdatedCRC32for(crc, genBuf, mtogo);
uci1 40:1324da35afd4 944
uci1 40:1324da35afd4 945 if (hcode==SnHeaderFrame::kEventCode) {
uci1 40:1324da35afd4 946 ++evtsSent;
uci1 40:1324da35afd4 947 if (nevts>0) {
uci1 40:1324da35afd4 948 if (evtsSent>=nevts) {
uci1 12:d472f9811262 949 #ifdef DEBUG
uci1 56:0bba0ef15697 950 printf("sent %u events. stop\r\n",evtsSent);
uci1 12:d472f9811262 951 #endif
uci1 40:1324da35afd4 952 break;
uci1 12:d472f9811262 953 }
uci1 12:d472f9811262 954 }
uci1 40:1324da35afd4 955 } else if (hcode==SnHeaderFrame::kPowerCode) {
uci1 40:1324da35afd4 956 ++powsSent;
uci1 40:1324da35afd4 957 }
uci1 40:1324da35afd4 958 } // otherwise file size not sufficient for this block
uci1 21:ce51bb0ba4a5 959 } // loop over file contents
uci1 21:ce51bb0ba4a5 960 } else {
uci1 21:ce51bb0ba4a5 961 // otherwise file size not sufficient for file header
uci1 21:ce51bb0ba4a5 962 // so it's either 0 or corrupted.
uci1 21:ce51bb0ba4a5 963 // proceed as normal even tho no contents were sent.
uci1 21:ce51bb0ba4a5 964 // if we're deleting files, this one will be deleted.
uci1 21:ce51bb0ba4a5 965 ok = true;
uci1 21:ce51bb0ba4a5 966 }
uci1 12:d472f9811262 967 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 968 printf("loop done. ok=%d\r\n",(int)ok);
uci1 12:d472f9811262 969 #endif
uci1 40:1324da35afd4 970
uci1 40:1324da35afd4 971 // send the crc
uci1 40:1324da35afd4 972 #ifdef DEBUG
uci1 40:1324da35afd4 973 printf("sending crc (%u)\r\n",crc);
uci1 40:1324da35afd4 974 #endif
uci1 40:1324da35afd4 975 b = genBuf;
uci1 40:1324da35afd4 976 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kMbedFileChksCode, sizeof(uint32_t));
uci1 40:1324da35afd4 977 b = SnBitUtils::WriteTo(b, crc);
uci1 40:1324da35afd4 978 msiz = b - genBuf;
uci1 40:1324da35afd4 979 mlen = fComm->SendAll(genBuf, msiz, timeout_clock);
uci1 40:1324da35afd4 980 bytesToBeSent += msiz;
uci1 40:1324da35afd4 981 tsent += mlen;
uci1 40:1324da35afd4 982
uci1 40:1324da35afd4 983 #ifdef DEBUG
uci1 40:1324da35afd4 984 printf("(msiz=%d, mlen=%d)\r\n", msiz, mlen);
uci1 40:1324da35afd4 985 #endif
uci1 40:1324da35afd4 986
uci1 21:ce51bb0ba4a5 987
uci1 21:ce51bb0ba4a5 988 // send number of events sent
uci1 12:d472f9811262 989 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 990 printf("sending evtsSent (%u)\r\n",evtsSent);
uci1 12:d472f9811262 991 #endif
uci1 21:ce51bb0ba4a5 992 b = genBuf;
uci1 21:ce51bb0ba4a5 993 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileNevtsCode, sizeof(uint32_t));
uci1 21:ce51bb0ba4a5 994 b = SnBitUtils::WriteTo(b, evtsSent);
uci1 21:ce51bb0ba4a5 995 msiz = b - genBuf;
uci1 37:ff95e7070f26 996 mlen = fComm->SendAll(genBuf, msiz, timeout_clock);
uci1 40:1324da35afd4 997 bytesToBeSent += msiz;
uci1 40:1324da35afd4 998 tsent += mlen;
uci1 40:1324da35afd4 999
uci1 18:55f1581f2ee4 1000 #ifdef DEBUG
uci1 40:1324da35afd4 1001 printf("(msiz=%d, mlen=%d)\r\n", msiz, mlen);
uci1 18:55f1581f2ee4 1002 #endif
uci1 21:ce51bb0ba4a5 1003
uci1 21:ce51bb0ba4a5 1004 // send number of power readings sent
uci1 12:d472f9811262 1005 #ifdef DEBUG
uci1 21:ce51bb0ba4a5 1006 printf("sending powsSent (%u)\r\n",powsSent);
uci1 12:d472f9811262 1007 #endif
uci1 21:ce51bb0ba4a5 1008 b = genBuf;
uci1 21:ce51bb0ba4a5 1009 SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFileNpwrsCode, sizeof(uint32_t));
uci1 21:ce51bb0ba4a5 1010 b = SnBitUtils::WriteTo(b, powsSent);
uci1 21:ce51bb0ba4a5 1011 msiz = b - genBuf;
uci1 37:ff95e7070f26 1012 mlen = fComm->SendAll(genBuf, msiz, timeout_clock);
uci1 40:1324da35afd4 1013 bytesToBeSent += msiz;
uci1 40:1324da35afd4 1014 tsent += mlen;
uci1 21:ce51bb0ba4a5 1015
uci1 18:55f1581f2ee4 1016 #ifdef DEBUG
uci1 40:1324da35afd4 1017 printf("(msiz=%d, mlen=%d)\r\n", msiz, mlen);
uci1 18:55f1581f2ee4 1018 #endif
uci1 12:d472f9811262 1019
uci1 12:d472f9811262 1020 // put file position back
uci1 12:d472f9811262 1021 fseek(inf, fpos, SEEK_SET);
uci1 12:d472f9811262 1022
uci1 12:d472f9811262 1023 #ifdef DEBUG
uci1 12:d472f9811262 1024 printf("end contents: ok=%d\r\n",(int)ok);
uci1 12:d472f9811262 1025 #endif
uci1 12:d472f9811262 1026
uci1 40:1324da35afd4 1027 return tsent;
uci1 8:95a325df1f6b 1028
uci1 40:1324da35afd4 1029 //return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
uci1 8:95a325df1f6b 1030 }