Flying Sea Glider
most functionality to splashdwon, find neutral and start mission. short timeouts still in code for testing, will adjust to go directly to sit_idle after splashdown
Dependencies: mbed MODSERIAL FATFileSystem
Embed:
(wiki syntax)
Show/hide line numbers
MbedLogger.cpp
00001 #include "MbedLogger.hpp" 00002 #include "StaticDefs.hpp" 00003 #include <stdarg.h> 00004 00005 //Timer t; //used to test time to create packet //timing debug 00006 00007 MbedLogger::MbedLogger(string file_system_input_string) { 00008 _file_system_string = file_system_input_string; // how to make the LOG000.csv a variable string? 00009 _full_file_path_string = _file_system_string + "LOG000.csv"; //use multiple logs in the future? (after file size is too large) 00010 _full_diagfile_path_string = _file_system_string + "DIAG000.txt"; 00011 _file_number = 0; 00012 _file_transmission = true; 00013 _confirmed_packet_number = 0; //must set this to zero 00014 _transmit_counter = 0; 00015 _file_transmission_state = -1; 00016 _total_number_of_packets = 0; 00017 _mbed_transmit_loop = false; 00018 _received_filename = ""; 00019 00020 _log_file_line_counter = 0; //used to set timer in finite state machine based on size of log 00021 00022 //heading string is 254 bytes long, FIXED LENGTH 00023 _heading_string = "StateStr,St#,TimeSec,DepthCmd,DepthFt,PitchCmd,PitchDeg,RudderPWM,RudderCmdDeg,HeadDeg,bceCmd,bce_mm,battCmd,batt_mm,PitchRateDegSec,depth_rate_fps,SystemAmps,SystemVolts,AltChRd,Int_PSI,BCE_p,i,d,BATT_p,i,d,DEPTH_p,i,d,fq,db,PITCH_p,i,d,HEAD_p,i,d,fq,db\n"; 00024 _diag_heading_string = "Diagnostics file header \n"; 00025 00026 _fsm_transmit_complete = false; 00027 00028 _end_transmit_packet = false; 00029 _default_timestamp_time = 1518467832; 00030 00031 _end_sequence_transmission = false; 00032 _time_set =0; 00033 } 00034 00035 //this function has to be called for the time to function correctly 00036 void MbedLogger::setLogTime(long int setting_time) { 00037 00038 if ( setting_time == -1) { set_time(_default_timestamp_time); } 00039 else { set_time(setting_time); _default_timestamp_time = setting_time; } 00040 xbee().printf("\n%s log time set.\n\r", _file_system_string.c_str()); 00041 // set_time(time_stamp); // Set RTC time to Mon, 12 FEB 2018 15:37 00042 _time_set =1; 00043 } 00044 00045 //in the future create the ability to set the start time 00046 time_t MbedLogger::getSystemTime() { 00047 time_t seconds = time(NULL); // Time as seconds since January 1, 1970 00048 00049 return seconds; 00050 } 00051 00052 void MbedLogger::recordData(int current_state) { 00053 int data_log_time = mbedLogger().getSystemTime(); //read the system timer to get unix timestamp 00054 int start_time = 1518467832; 00055 if(_time_set) { start_time = _default_timestamp_time;} 00056 _data_log[0] = depthLoop().getCommand(); //depth command 00057 _data_log[1] = depthLoop().getPosition(); //depth reading (filtered depth) 00058 _data_log[2] = pitchLoop().getCommand(); //pitch command 00059 _data_log[3] = pitchLoop().getPosition(); //pitch reading (filtered pitch) 00060 _data_log[4] = rudder().getSetPosition_pwm(); //rudder command PWM 00061 _data_log[5] = rudder().getSetPosition_deg(); //rudder command DEG 00062 _data_log[6] = headingLoop().getPosition(); //heading reading (filtered heading) 00063 00064 _data_log[7] = bce().getSetPosition_mm(); //BCE command 00065 _data_log[8] = bce().getPosition_mm(); //BCE reading 00066 _data_log[9] = batt().getSetPosition_mm(); //Batt command 00067 _data_log[10] = batt().getPosition_mm(); //Batt reading 00068 _data_log[11] = pitchLoop().getVelocity(); // pitchRate_degs (degrees per second) 00069 _data_log[12] = depthLoop().getVelocity(); // depthRate_fps (feet per second) 00070 00071 _data_log[13] = sensors().getCurrentInput(); // i_in 00072 _data_log[14] = sensors().getVoltageInput(); // v_in 00073 _data_log[15] = sensors().getAltimeterChannelReadings(); // Altimeter Channel Readings 00074 _data_log[16] = sensors().getInternalPressurePSI(); // int_press_PSI 00075 00076 //BCE_p,i,d,freq,deadband 00077 _data_log[17] = bce().getControllerP(); 00078 _data_log[18] = bce().getControllerI(); 00079 _data_log[19] = bce().getControllerD(); 00080 00081 _data_log[20] = batt().getControllerP(); 00082 _data_log[21] = batt().getControllerI(); 00083 _data_log[22] = batt().getControllerD(); 00084 00085 _data_log[23] = depthLoop().getControllerP(); 00086 _data_log[24] = depthLoop().getControllerI(); 00087 _data_log[25] = depthLoop().getControllerD(); 00088 _data_log[26] = depthLoop().getFilterFrequency(); 00089 _data_log[27] = depthLoop().getDeadband(); 00090 00091 _data_log[28] = pitchLoop().getControllerP(); 00092 _data_log[29] = pitchLoop().getControllerI(); 00093 _data_log[30] = pitchLoop().getControllerD(); 00094 00095 _data_log[31] = headingLoop().getControllerP(); 00096 _data_log[32] = headingLoop().getControllerI(); 00097 _data_log[33] = headingLoop().getControllerD(); 00098 _data_log[34] = headingLoop().getFilterFrequency(); 00099 _data_log[35] = headingLoop().getDeadband(); 00100 00101 string string_state; string_state= "UNKNOWN"; //default just in case. 00102 00103 if (current_state == SIT_IDLE) 00104 string_state = "SIT_IDLE"; 00105 else if (current_state == FIND_NEUTRAL) 00106 string_state = "FIND_NEUTRAL"; 00107 else if (current_state == DIVE) 00108 string_state = "DIVE"; 00109 else if (current_state == RISE) 00110 string_state = "RISE"; 00111 else if (current_state == FLOAT_LEVEL) 00112 string_state = "FLOAT_LEVEL"; 00113 else if (current_state == FLOAT_BROADCAST) 00114 string_state = "FLOAT_BROADCAST"; 00115 else if (current_state == EMERGENCY_CLIMB) 00116 string_state = "EMERGENCY_CLIMB"; 00117 else if (current_state == MULTI_DIVE) 00118 string_state = "MULTI_DIVE"; 00119 else if (current_state == MULTI_RISE) 00120 string_state = "MULTI_RISE"; 00121 else if (current_state == KEYBOARD) 00122 string_state = "KEYBOARD"; 00123 else if (current_state == CHECK_TUNING) 00124 string_state = "CHECK_TUNING"; 00125 else if (current_state == POSITION_DIVE) 00126 string_state = "POSITION_DIVE"; 00127 else if (current_state == POSITION_RISE) 00128 string_state = "POSITION_RISE"; 00129 else if (current_state == TX_MBED_LOG) 00130 string_state = "TX_MBED_LOG"; 00131 else if (current_state == RX_SEQUENCE) 00132 string_state = "RECEIVE_SEQUENCE"; 00133 else if (current_state == LEG_POSITION_DIVE) 00134 string_state = "LEG_POS_DIVE"; 00135 else if (current_state == LEG_POSITION_RISE) 00136 string_state = "LEG_POS_RISE"; 00137 else if (current_state == FB_EXIT) 00138 string_state = "FB_EXIT"; 00139 else if (current_state == START_SWIM) 00140 string_state = "START_SWIM"; 00141 else if (current_state == FLYING_IDLE) 00142 string_state = "FLYING_IDLE"; 00143 else if (current_state == ENDLEG_WAIT) 00144 string_state = "ENDLEG_WAIT"; 00145 00146 string blank_space = ""; //to get consistent spacing in the file (had a nonsense char w/o this) 00147 00148 //below this format is used for data transmission, each packet needs to be 254 characters long (not counting newline char) 00149 00150 //verified that this generates the correct line length of 254 using SOLELY an mbed 08/16/2018 00151 fprintf(_fp, "%17s,%.2d,%10d,%5.1f,%5.1f,%6.1f,%6.1f,%4.0f,%4.0f,%6.1f,%5.1f,%6.1f,%5.1f,%6.1f,%6.1f,%6.1f,%6.3f,%6.2f,%5.0f,%6.2f,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f,%6.2f,%5.3f,%5.3f,%4.1f,%4.1f,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f,%5.3f,%4.1f,%4.1f\n", 00152 string_state.c_str(),current_state, 00153 data_log_time-start_time, //note offset relative to start 00154 _data_log[0],_data_log[1],_data_log[2],_data_log[3],_data_log[4],_data_log[5],_data_log[6],_data_log[7],_data_log[8],_data_log[9],_data_log[10],_data_log[11],_data_log[12],_data_log[13],_data_log[14],_data_log[15], 00155 _data_log[16],_data_log[17],_data_log[18],_data_log[19],_data_log[20],_data_log[21],_data_log[22],_data_log[23],_data_log[24],_data_log[25],_data_log[26],_data_log[27],_data_log[28],_data_log[29],_data_log[30], 00156 _data_log[31],_data_log[32],_data_log[33],_data_log[34],_data_log[35]); 00157 00158 //each line in the file is 160 characters long text-wise, check this with a file read 00159 } 00160 00161 void MbedLogger::printMbedDirectory() { 00162 DIR *dir; 00163 struct dirent *dp; //dirent.h is the format of directory entries 00164 int log_found =0,loop=0; 00165 long int temp=0; 00166 00167 //char * char_pointer; 00168 char * numstart; 00169 //char *numstop; 00170 00171 xbee().printf("\n\rPrinting out the directory of device %s\n\r", _file_system_string.c_str()); 00172 00173 if ( NULL == (dir = opendir( _file_system_string.c_str() )) ) { 00174 xbee().printf("MBED directory could not be opened\r\n"); 00175 } 00176 else 00177 { 00178 while ( NULL != (dp = readdir( dir )) ) 00179 { 00180 if(strncmp(dp->d_name,"LOG",3)==0) 00181 { 00182 log_found=1; 00183 /*numstart = dp->d_name; //Look for third character (do safety) 00184 numstop = strchr(dp->d_name,'.'); 00185 if(numstart!=NULL&&numstop!=NULL) 00186 { 00187 temp=numstop-numstart; 00188 } 00189 else 00190 log_found=0; //Something is not right. Ignore 00191 */ 00192 numstart=dp->d_name+3; 00193 temp=strtol(numstart,NULL,10); //add in check to see if this is null (start logs at one) 00194 } 00195 else 00196 log_found=0; 00197 xbee().printf( "%d. %s (log file: %d, %d)\r\n", loop, dp->d_name,log_found,temp); 00198 00199 loop++; 00200 } 00201 } 00202 } 00203 00204 //prints current log file to the screen (terminal) 00205 void MbedLogger::printCurrentLogFile() { 00206 //open the file for reading 00207 // string file_name_string = _file_system_string + "LOG000.csv"; 00208 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00209 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00210 00211 _log_file_line_counter = 0; 00212 00213 _fp = fopen(file_name_string.c_str(), "r"); 00214 00215 char buffer[500]; 00216 00217 //read the file line-by-line and print that to the screen 00218 xbee().printf("\n\rCURRENT MBED LOG FILE /local/Log%03d.csv:\n\n\r",_file_number); 00219 while (!feof(_fp)) { 00220 // read in the line and make sure it was successful 00221 if (fgets(buffer,500,_fp) != NULL) { //stops at new line 00222 xbee().printf("%s\r",buffer); 00223 _log_file_line_counter++; 00224 } 00225 } 00226 00227 //fgets stops when either (n-1) characters are read, the newline character is read, 00228 // or the end-of-file is reached 00229 00230 //close the file 00231 closeLogFile(); 00232 xbee().printf("\n\rLog file closed. Lines in log file: %d.\n\r", _log_file_line_counter); 00233 } 00234 00235 void MbedLogger::blastData() { 00236 xbee().printf("blastData FUNCTION\n\r"); 00237 00238 //OPEN FILE FOR READING 00239 00240 //string file_name_string = _file_system_string + "LOG000.csv"; 00241 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00242 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00243 00244 _fp = fopen(file_name_string.c_str(), "r"); 00245 00246 /******************************/ 00247 while(1) { 00248 wait(0.05); 00249 if (!feof(_fp)) { //check for end of file 00250 //based on the internal packet number of the class //createDataPacket //transmit data packet 00251 transmitPacketNumber(_packet_number); 00252 xbee().printf("\r"); // for proper spacing 00253 00254 _packet_number++; 00255 } 00256 else { 00257 _packet_number = 0; //reset packet number 00258 break; 00259 } 00260 } 00261 /******************************/ 00262 00263 //CLOSE THE FILE 00264 closeLogFile(); 00265 xbee().printf("\n\rblastData: Log file closed. %d.\n\r"); 00266 } 00267 00268 void MbedLogger::createDataPacket() { 00269 // packet is 7565 0001 FFFF EEEE CC DATA DATA DATA ... CRC1 CRC2 00270 00271 //CLEAR: Removes all elements from the vector (which are destroyed), leaving the container with a size of 0. 00272 _data_packet.clear(); 00273 00274 //DATA PACKET HEADER 00275 _data_packet.push_back(117); //0x75 00276 _data_packet.push_back(101); //0x65 00277 00278 _data_packet.push_back(_packet_number/256); //current packet number in 0x#### form 00279 _data_packet.push_back(_packet_number%256); //current packet number in 0x#### form 00280 00281 _data_packet.push_back(_total_number_of_packets/256); //total number of packets, 0x#### form 00282 _data_packet.push_back(_total_number_of_packets%256); //total number of packets, 0x#### form 00283 00284 _data_packet.push_back(_current_line_length); 00285 00286 //xbee().printf("DEBUG: Current line buffer: %s\n\r", _line_buffer); //debug 00287 00288 //DATA FROM LINE READ (read string character by chracter) 00289 for (int i = 0; i < _current_line_length; i++) { 00290 _data_packet.push_back(_line_buffer[i]); 00291 } 00292 00293 //CRC CALCULATIONS BELOW 00294 //character version of calculation screws up on null character 0x00, scrapped and using vector of integers 00295 00296 int crc_one = calcCrcOne(); 00297 int crc_two = calcCrcTwo(); 00298 00299 //place the crc bytes into the data packet that is transmitted 00300 _data_packet.push_back(crc_one); 00301 _data_packet.push_back(crc_two); 00302 } 00303 00304 //new 6/27/2018 00305 void MbedLogger::createDataPacket(char line_buffer_sent[], int line_length_sent) { 00306 // packet is 7565 0001 FFFF EEEE CC DATA DATA DATA ... CRC1 CRC2 00307 00308 //CLEAR: Removes all elements from the vector (which are destroyed), leaving the container with a size of 0. 00309 _data_packet.clear(); 00310 00311 //DATA PACKET HEADER 00312 _data_packet.push_back(117); //0x75 00313 _data_packet.push_back(101); //0x65 00314 00315 _data_packet.push_back(_packet_number/256); //current packet number in 0x#### form 00316 _data_packet.push_back(_packet_number%256); //current packet number in 0x#### form 00317 00318 _data_packet.push_back(_total_number_of_packets/256); //total number of packets, 0x#### form 00319 _data_packet.push_back(_total_number_of_packets%256); //total number of packets, 0x#### form 00320 00321 _data_packet.push_back(line_length_sent); 00322 00323 //xbee().printf("DEBUG: Current line buffer: %s\n\r", _line_buffer); //debug 00324 00325 //DATA FROM LINE READ (read string character by chracter) 00326 for (int i = 0; i < line_length_sent; i++) { 00327 _data_packet.push_back(line_buffer_sent[i]); 00328 } 00329 00330 //CRC CALCULATIONS BELOW 00331 //character version of calculation screws up on null character 0x00, scrapped and using vector of integers 00332 00333 int crc_one = calcCrcOne(); 00334 int crc_two = calcCrcTwo(); 00335 00336 //place the crc bytes into the data packet that is transmitted 00337 _data_packet.push_back(crc_one); 00338 _data_packet.push_back(crc_two); 00339 00340 //xbee().printf("debug createDataPacket(char line_buffer_sent[], int line_length_sent)\n\r"); 00341 } 00342 00343 //should i save it as a string and transmit the string? next iteration maybe 00344 00345 void MbedLogger::transmitDataPacket() { 00346 //WRITE the data (in bytes) to the serial port 00347 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++) { 00348 xbee().putc(*_it); //send integers over serial port one byte at a time 00349 } 00350 } 00351 00352 // test to see if transmitDataPacket is working slower than you think. 00353 00354 // REACH ONE CHAR AT A TIME (EACH ITERATION OF STATE MACHINE...) 00355 00356 00357 void MbedLogger::continuouslyTransmitDataNoTimer() { 00358 // string file_name_string = _file_system_string + "LOG000.csv"; 00359 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00360 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00361 00362 _fp = fopen(file_name_string.c_str(), "r"); 00363 00364 static int packet_num = 0; 00365 00366 while(!feof(_fp)) { 00367 00368 _packet_number = packet_num; 00369 00370 readPacketInSeries(); //not using this but for testing purposes... 00371 00372 // // createDataPacket requires _packet_number, _total_number_of_packets, _current_line_length (data packet size) 00373 // // uses char _line_buffer[256] variable to hold characters read from the file 00374 // // packs this into a vector for transmission 00375 00376 createDataPacket(); 00377 00378 transmitDataPacket(); 00379 00380 packet_num++; 00381 00382 led3() = !led3(); 00383 00384 //check for incoming request 00385 } 00386 00387 closeLogFile(); //close log file if open 00388 led4() = !led4(); 00389 } 00390 00391 void MbedLogger::fsmTransmitData() { //using the finite state machine 00392 if ( !feof(_fp) and (!_fsm_transmit_complete) ) { //check for end of file 00393 //based on the internal packet number of the class //createDataPacket //transmit data packet 00394 transmitPacketNumber(_packet_number); 00395 00396 xbee().printf("\r"); // for proper spacing 00397 00398 _packet_number++; 00399 00400 led2() = !led2(); 00401 } 00402 else { 00403 _packet_number = 0; //reset packet number 00404 00405 _fsm_transmit_complete = true; 00406 00407 led3() = !led3(); 00408 } 00409 } 00410 00411 //transmitting log file with fixed length of characters to receiver program 00412 void MbedLogger::transmitPacketNumber(int line_number) { 00413 int line_size = 254; //length of lines in the log file, EVERY LINE MUST BE THE SAME LENGTH 00414 00415 fseek(_fp,(line_size+1)*line_number,SEEK_SET); //fseek must use the +1 to get the newline character 00416 00417 //write over the internal _line_buffer //start from the beginning and go to this position 00418 fread(_line_buffer, 1, line_size, _fp); //read the line that is exactly 160 characters long 00419 00420 //xbee().printf("Debug (transmitPacketNumber): line_buffer <<%s>> (line size: %d)\n\r", line_buffer,line_size); 00421 00422 // createDataPacket requires _packet_number, _total_number_of_packets, _current_line_length (data packet size) 00423 // uses char _line_buffer[256] variable to hold characters read from the file 00424 // packs this into a vector for transmission 00425 00426 //change the internal member variable for packet number, reorg this later 00427 _packet_number = line_number; 00428 00429 createDataPacket(_line_buffer, line_size); //create the data packet from the _line_buffer (char array) 00430 00431 transmitDataPacket(); //transmit the assembled packet 00432 } 00433 00434 00435 //receive correct data packet from python, immediately send a transmit packet from the MBED 00436 void MbedLogger::transmitOnePacket() { 00437 xbee().printf("transmitOnePacket\n"); 00438 00439 static int transmit_state = HEADER_117; //state in switch statement 00440 //int incoming_byte = -1; //reset each time a character is read 00441 int requested_packet_number = -1; //reset each time a character is read 00442 static int input_packet[4]; //changed from char in previous iteration 03/28/2018 00443 static int transmit_crc_one = 0; //hold crc values until they're reset with calculations 00444 static int transmit_crc_two = 0; 00445 00446 int incoming_byte[6]; 00447 00448 static int bytes_received = 0; 00449 00450 int req_packet_number = -1; 00451 00452 while (1) { 00453 incoming_byte[bytes_received] = xbee().getc(); 00454 xbee().printf("<%d> ", incoming_byte[bytes_received]); 00455 00456 bytes_received++; 00457 00458 if (bytes_received > 5) { 00459 00460 req_packet_number = incoming_byte[2] * 256 + incoming_byte[3]; 00461 00462 xbee().printf("req_packet_number = %d\n\r", req_packet_number); 00463 00464 bytes_received = 0; 00465 break; 00466 } 00467 } 00468 00469 setTransmitPacketNumber(0); 00470 00471 //open the file 00472 // string file_name_string = _file_system_string + "LOG000.csv"; 00473 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00474 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00475 _fp = fopen(file_name_string.c_str(), "r"); 00476 00477 //receive correct checksum, immediately send this packet 00478 transmitPacketNumber(req_packet_number); 00479 00480 //fclose(_fp); 00481 closeLogFile(); 00482 } 00483 00484 void MbedLogger::transmitMultiplePackets() { 00485 xbee().printf("transmitMultiplePackets\n"); 00486 00487 //static int transmit_state = HEADER_117; //state in switch statement 00488 //int incoming_byte = -1; //reset each time a character is read 00489 //int requested_packet_number = -1; //reset each time a character is read 00490 static int input_packet; //changed from char in previous iteration 03/28/2018 00491 static int transmit_crc_one = 0; //hold crc values until they're reset with calculations 00492 static int transmit_crc_two = 0; 00493 00494 int current_byte = -1; 00495 00496 static int bytes_received = 0; 00497 00498 int req_packet_number = -1; 00499 00500 //GET TOTAL NUMBER OF PACKETS! 00501 getNumberOfPacketsInCurrentLog(); 00502 //GET TOTAL NUMBER OF PACKETS! 00503 00504 //open the file 00505 // string file_name_string = _file_system_string + "LOG000.csv"; 00506 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00507 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00508 _fp = fopen(file_name_string.c_str(), "r"); 00509 00510 //DEFAULT STATE 00511 static int current_state = HEADER_117; 00512 00513 bool active_loop = true; 00514 00515 while (active_loop) { 00516 //INCOMING BYTE 00517 current_byte = xbee().getc(); 00518 00519 //provide the next byte / state 00520 00521 switch (current_state) { 00522 case HEADER_117: 00523 //xbee().printf("HEADING 117\n\r"); 00524 if (current_byte == 0x75) { 00525 current_state = HEADER_101; 00526 } 00527 00528 00529 else if (current_byte == 0x10) { 00530 current_state = END_TX_1; 00531 } 00532 break; 00533 case HEADER_101: 00534 //xbee().printf("HEADING 101\n\r"); 00535 if (current_byte == 0x65) { 00536 current_state = PACKET_NO_1; 00537 } 00538 break; 00539 case PACKET_NO_1: 00540 //xbee().printf("PACKET_NO_1\n\r"); 00541 input_packet = current_byte * 256; 00542 00543 current_state = PACKET_NO_2; 00544 //xbee().printf("PACKET # 1 current byte %d\n\r", current_byte); 00545 break; 00546 00547 case PACKET_NO_2: 00548 //xbee().printf("PACKET_NO_2\n\r"); 00549 input_packet = input_packet + current_byte; 00550 00551 current_state = PACKET_CRC_ONE; 00552 //xbee().printf("PACKET # 2 current byte %d (req packet num: %d)\n\r", current_byte, input_packet); 00553 break; 00554 00555 case PACKET_CRC_ONE: 00556 //xbee().printf("PACKET_CRC_ONE\n\r"); 00557 current_state = PACKET_CRC_TWO; 00558 break; 00559 00560 case PACKET_CRC_TWO: 00561 //xbee().printf("PACKET_CRC_TWO\n\r"); 00562 current_state = HEADER_117; 00563 transmitPacketNumber(input_packet); 00564 break; 00565 00566 case END_TX_1: 00567 //xbee().printf("END_TX_1\n\r"); 00568 current_state = END_TX_2; 00569 break; 00570 case END_TX_2: 00571 //xbee().printf("END_TX_2\n\r"); 00572 current_state = HEADER_117; 00573 active_loop = false; 00574 break; 00575 00576 default: 00577 //reset state 00578 //xbee().printf("DEFAULT. HEADER_117\n\r"); 00579 current_state = HEADER_117; //reset here 00580 break; 00581 00582 } 00583 } 00584 00585 //CLOSE THE FILE 00586 closeLogFile(); 00587 xbee().printf("08/05/2018 CLOSE THE LOG FILE\n\r"); 00588 00589 //RESET THE STATE 00590 //current_state = HEADER_117; 00591 } 00592 00593 void MbedLogger::checkForPythonTransmitRequest() { 00594 //xbee().printf("checkForPythonTransmitRequest\n"); 00595 00596 if ( xbee().readable() ) { 00597 00598 //PC READABLE DOES NOT WORK HERE?! 00599 00600 led2() = !led2(); 00601 led3() = !led3(); 00602 00603 xbee().printf("########################\n"); 00604 //xbee().printf("%d", xbee().getc()); 00605 } 00606 00607 // static int transmit_state = HEADER_117; //state in switch statement 00608 // //int incoming_byte = -1; //reset each time a character is read 00609 // int requested_packet_number = -1; //reset each time a character is read 00610 // static int input_packet[4]; //changed from char in previous iteration 03/28/2018 00611 // static int transmit_crc_one = 0; //hold crc values until they're reset with calculations 00612 // static int transmit_crc_two = 0; 00613 // 00614 // static int incoming_byte[6]; 00615 // 00616 // static int bytes_received = 0; 00617 // 00618 // int req_packet_number = -1; 00619 // 00620 // if (xbee().readable()) { 00621 // incoming_byte[bytes_received] = xbee().getc(); 00622 // xbee().printf("<%d> ", incoming_byte[bytes_received]); 00623 // 00624 // bytes_received++; 00625 // 00626 // if (bytes_received > 5) { 00627 // 00628 // req_packet_number = incoming_byte[2] * 256 + incoming_byte[3]; 00629 // 00630 // xbee().printf("req_packet_number = %d\n\r", req_packet_number); 00631 // 00632 // //reset 00633 // bytes_received = 0; 00634 // } 00635 // } 00636 // 00637 // //setTransmitPacketNumber(0); 00638 // 00639 // /* OPEN THE FILE */ 00640 // string file_name_string = _file_system_string + "LOG000.csv"; 00641 //_fp = fopen(file_name_string.c_str(), "r"); 00642 00643 /* RECEIVE CORRECT CHECKSUM, SEND PACKET */ 00644 //transmitPacketNumber(req_packet_number); 00645 00646 //fclose(_fp); 00647 00648 // switch(transmit_state) { 00649 // case HEADER_117: 00650 // led3() = !led3(); 00651 // 00652 // //continue processing 00653 // if (incoming_byte == 117){ //"u" 00654 // transmit_state = HEADER_101; 00655 // } 00656 // //did not receive byte 1 00657 // else { 00658 // transmit_state = HEADER_117; //go back to checking the first packet 00659 // } 00660 // break; 00661 // 00662 // case HEADER_101: 00663 // if(incoming_byte == 101) { //"e" 00664 // transmit_state = TRANSMIT_PACKET_1; 00665 // //xbee().printf(" U E \n\r"); 00666 // } 00667 // else { 00668 // transmit_state = HEADER_117; 00669 // } 00670 // break; 00671 // 00672 // case TRANSMIT_PACKET_1: 00673 // if (incoming_byte >= 0) { 00674 // input_packet[0] = 117; 00675 // input_packet[1] = 101; 00676 // input_packet[2] = incoming_byte; 00677 // 00678 // transmit_state = TRANSMIT_PACKET_2; 00679 // //_reply_byte3 = incoming_byte; 00680 // 00681 // led1() = !led1(); 00682 // //xbee().printf(" T P \n\r"); 00683 // //xbee().printf("DEBUG: Transmit Packet %d\n\r", incoming_byte); 00684 // } 00685 // break; 00686 // 00687 // case TRANSMIT_PACKET_2: 00688 // 00689 // if (incoming_byte >= 0) { 00690 // input_packet[3] = incoming_byte; 00691 // //_reply_byte4 = incoming_byte; 00692 // } 00693 // transmit_state = PACKET_CRC_ONE; 00694 // 00695 // break; 00696 // 00697 // case (PACKET_CRC_ONE): 00698 // transmit_crc_one = calcCrcOneArray(input_packet, 4); //calc CRC 1 from the input packet (size 4) 00699 // 00700 // if (incoming_byte == transmit_crc_one) { 00701 // transmit_state = PACKET_CRC_TWO; 00702 // } 00703 // 00704 // else 00705 // transmit_state = HEADER_117; 00706 // //or state remains the same? 00707 // 00708 // break; 00709 // 00710 // case (PACKET_CRC_TWO): 00711 // transmit_state = HEADER_117; 00712 // transmit_crc_two = calcCrcTwoArray(input_packet, 4); //calc CRC 2 from the input packet (size 4) 00713 // 00714 // //check if CRC TWO is correct (then send full packet) 00715 // if (incoming_byte == transmit_crc_two) { 00716 // requested_packet_number = input_packet[2] * 256 + input_packet[3]; //compute the numbers 0 through 65535 with the two bytes 00717 // 00718 // //receive correct checksum, immediately send this packet 00719 // transmitPacketNumber(requested_packet_number); 00720 // 00721 // //fseek(_fp, 0, SEEK_END); //reset _fp (this was causing errors with the other function) 00722 // led3() = !led3(); 00723 // 00724 // } //end of checksum (incoming_byte) if statement 00725 // 00726 // break; 00727 // } //switch statement complete 00728 // } //while statement complete 00729 } 00730 00731 int MbedLogger::readTransmitPacket() { 00732 _file_transmission = true; 00733 _file_transmission_state = 0; 00734 00735 //first check if you're receiving data, then read four bytes 00736 00737 int transmit_state = 0; //for state machine 00738 00739 int incoming_byte = -1; 00740 00741 int requested_packet_number = -1; 00742 00743 static int inside_while_loop = 1; 00744 00745 while (inside_while_loop) { 00746 if (xbee().readable()) { //don't rely on pc readable being open all the time 00747 00748 incoming_byte = xbee().getc(); 00749 00750 switch(transmit_state) { 00751 00752 case (HEADER_117): 00753 //continue processing 00754 if (incoming_byte == 117){ 00755 transmit_state = HEADER_101; 00756 } 00757 //end transmission 00758 else if (incoming_byte == 16) { 00759 transmit_state = END_TRANSMISSION; 00760 } 00761 else { 00762 transmit_state = HEADER_117; 00763 } 00764 break; 00765 00766 case (HEADER_101): 00767 if(incoming_byte == 101) { 00768 transmit_state = TRANSMIT_PACKET_1; 00769 } 00770 break; 00771 00772 case (TRANSMIT_PACKET_1): 00773 if (incoming_byte >= 0) { 00774 transmit_state = TRANSMIT_PACKET_2; 00775 _reply_byte3 = incoming_byte; 00776 } 00777 break; 00778 00779 case (TRANSMIT_PACKET_2): 00780 if (incoming_byte >= 0) { 00781 _reply_byte4 = incoming_byte; 00782 } 00783 00784 requested_packet_number = _reply_byte3 * 256 + _reply_byte4; //compute the numbers 0 through 65535 with the two bytes 00785 00786 if (requested_packet_number != _previous_reply_byte) { //CHANGE THE NAME TO SOMETHING NOT BYTE! 00787 //MUST SET THE PACKET NUMBER 00788 _packet_number = requested_packet_number; 00789 00790 readPacketInSeries(); 00791 createDataPacket(); 00792 _previous_reply_byte = requested_packet_number; //RECORD THIS BYTE to prevent new packets being created 00793 } 00794 00795 //continuously transmit current packet until it tells you to do the next packet (response from Python program) 00796 transmitDataPacket(); 00797 00798 //TRANSMIT_PACKET_2 00799 inside_while_loop = 0; //exit the while loop with this 00800 xbee().printf("(TRANSMIT_PACKET_2)reached inside_while_loop = 0\n\r"); //DEBUG 00801 break; 00802 } //end of switch statement 00803 } //end of while loop 00804 00805 // else { 00806 // //xbee().printf("pc not readable \n\r"); 00807 // } 00808 // 00809 } 00810 00811 //once you're outside of the while loop 00812 inside_while_loop = true; //for next iteration 00813 00814 xbee().printf("DEBUG: (readTransmitPacket) Outside of while loop\n\r"); 00815 return false; 00816 } 00817 00818 bool MbedLogger::endTransmitPacket() { 00819 00820 int incoming_byte; 00821 00822 while (xbee().readable()) { 00823 incoming_byte = xbee().getc(); //get first byte 00824 00825 if (incoming_byte == 16) { 00826 incoming_byte = xbee().getc(); //get second byte 00827 return true; 00828 } 00829 //quick and dirty 00830 00831 } 00832 00833 return false; 00834 } 00835 00836 void MbedLogger::reOpenLineReader() { 00837 //open a new one 00838 // string file_name_string = _file_system_string + "LOG000.csv"; 00839 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00840 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00841 00842 _fp = fopen(file_name_string.c_str(), "r"); //open the log file to read 00843 00844 //check if this actually worked... 00845 if (!_fp) { 00846 xbee().printf("ERROR: Log file could not be opened\n\r"); 00847 } 00848 else { 00849 xbee().printf("Current Log file (%s) was opened.\n\r", configFileIO().logFilesStruct.logFileName); 00850 } 00851 } 00852 00853 bool MbedLogger::openLineReader() { 00854 // string file_name_string = _file_system_string + "LOG000.csv"; 00855 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00856 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00857 00858 00859 _fp = fopen(file_name_string.c_str(), "r"); //open the log file to read 00860 00861 //check if this actually worked... 00862 if (!_fp) { 00863 //xbee().printf("ERROR: Log file could not be opened\n\r"); 00864 return false; 00865 } 00866 else { 00867 //xbee().printf("Current Log file (LOG000.csv) was opened.\n\r"); 00868 return true; 00869 } 00870 } 00871 00872 //VERIFIED THIS IS WORKING 00873 void MbedLogger::readPacketInSeries(){ 00874 memset(&_line_buffer[0], 0, sizeof(_line_buffer)); //clear buffer each time, start at the address, fill with zeroes, go to the end of the char array 00875 00876 //read the current line in the file 00877 fgets(_line_buffer, 256, _fp); //reads the line of characters until you reach a newline character 00878 00879 //RECORD THE STRING LENGTH 00880 _current_line_length = strlen(_line_buffer); 00881 } 00882 00883 int MbedLogger::getNumberOfPacketsInCurrentLog() { 00884 //takes less than a second to complete, verified 7/24/2018 00885 00886 //open the file 00887 // string file_name_string = _file_system_string + "LOG000.csv"; 00888 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00889 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00890 00891 _fp = fopen(file_name_string.c_str(), "r"); 00892 00893 fseek(_fp, 0L, SEEK_END); 00894 00895 size_t size = ftell(_fp); 00896 00897 //move the FILE pointer back to the start 00898 fseek(_fp, 0, SEEK_SET); // SEEK_SET is the beginning of file 00899 00900 _total_number_of_packets = size/254; 00901 00902 //CLOSE THE FILE 00903 closeLogFile(); 00904 00905 return _total_number_of_packets; 00906 } 00907 00908 void MbedLogger::endTransmissionCloseFile() { 00909 // if the file pointer is null, the file was not opened in the first place 00910 if (!_fp) { 00911 xbee().printf("\n endTransmissionCloseFile: FILE WAS NOT OPENED!\n\r"); 00912 } 00913 else { 00914 xbee().printf("\n endTransmissionCloseFile: FILE FOUND AND CLOSED!\n\r"); 00915 closeLogFile(); 00916 } 00917 00918 _file_transmission = false; 00919 } 00920 00921 void MbedLogger::openWriteFile() { 00922 xbee().printf("Opening file for reception.\n\r"); 00923 00924 // string file_name_string = _file_system_string + "LOG000.csv"; 00925 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 00926 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 00927 00928 00929 _fp = fopen(file_name_string.c_str(), "w"); 00930 } 00931 00932 00933 //weird bug noticed on 5/25/2018 where if you're not sending data the function is not completing 00934 00935 00936 00937 00938 // function checks for incoming data (receiver function) from a Python program that transmits a file 00939 // current limit is a file that has 255 lines of data 00940 bool MbedLogger::checkForIncomingData() { 00941 int receive_packet_number; 00942 int receive_total_number_packets; 00943 int receive_packet_size; 00944 00945 bool data_transmission_complete = false; 00946 00947 int incoming_byte; 00948 00949 char char_buffer[256] = {}; //create empty buffer 00950 00951 //starting state 00952 int process_state = HEADER_117; 00953 00954 //variables for processing data below 00955 int checksum_one = -1; 00956 int checksum_two = -1; 00957 00958 int i = 5; 00959 int serial_timeout = 0; 00960 00961 while (xbee().readable() && !data_transmission_complete) { 00962 incoming_byte = xbee().getc(); //getc returns an unsigned char cast to an int 00963 //xbee().printf("DEBUG: State 0\n\r"); 00964 00965 switch(process_state) { 00966 case HEADER_117: 00967 //continue processing 00968 if (incoming_byte == 117){ 00969 process_state = HEADER_101; 00970 //xbee().printf("DEBUG: Case 117\n\r"); 00971 } 00972 //end transmission 00973 else if (incoming_byte == 16) { 00974 process_state = END_TRANSMISSION; 00975 //xbee().printf("DEBUG: State 16 (END_TRANSMISSION)\n\r"); 00976 } 00977 else { 00978 process_state = HEADER_117; // ??? 00979 //xbee().printf("DEBUG: State Header 117\n\r"); 00980 } 00981 break; 00982 00983 case HEADER_101: 00984 if(incoming_byte == 101) { 00985 process_state = PACKET_NUM; 00986 //xbee().printf("DEBUG: Case 101\n\r"); 00987 } 00988 break; 00989 00990 case PACKET_NUM: 00991 receive_packet_number = incoming_byte; 00992 process_state = TOTAL_NUM_PACKETS; 00993 //xbee().printf("DEBUG: Case PACKET_NUM\n\r"); 00994 break; 00995 00996 case TOTAL_NUM_PACKETS: 00997 receive_total_number_packets = incoming_byte; 00998 process_state = PACKET_SIZE; 00999 //xbee().printf("DEBUG: Case TOTAL_NUM_PACKETS\n\r"); 01000 break; 01001 01002 case PACKET_SIZE: 01003 receive_packet_size = incoming_byte; 01004 //xbee().printf("DEBUG: Case PACKET_SIZE\n\r"); 01005 01006 //write the header stuff to it 01007 char_buffer[0] = 117; 01008 char_buffer[1] = 101; 01009 char_buffer[2] = receive_packet_number; 01010 char_buffer[3] = receive_total_number_packets; 01011 char_buffer[4] = receive_packet_size; 01012 01013 // tests confirmed that packet number is zero, number of packets is 12, packet size is 12 01014 //xbee().printf("char_buffer 2/3/4: %d %d %d\n\r", receive_packet_number,receive_total_number_packets,receive_packet_size); 01015 01016 //process packet data, future version will append for larger data sizes, 0xFFFF 01017 01018 // IF YOU GET AN INTERRUPTED DATA STREAM YOU NEED TO BREAK OUT OF THE LOOP 01019 i = 5; 01020 serial_timeout = 0; 01021 01022 while (true) { 01023 if (xbee().readable()) { 01024 char_buffer[i] = xbee().getc(); //read all of the data packets 01025 i++; 01026 01027 serial_timeout = 0; //reset the timeout 01028 } 01029 else { 01030 serial_timeout++; 01031 } 01032 01033 // When full data packet is received... 01034 if (i >= receive_packet_size+5) { //cannot do this properly with a for loop 01035 //get checksum bytes 01036 checksum_one = xbee().getc(); 01037 checksum_two = xbee().getc(); 01038 01039 //calculate the CRC from the header and data bytes using _data_packet (vector) 01040 //found out calculating crc with string was dropping empty or null spaces 01041 _data_packet.clear(); //clear it just in case 01042 01043 for (int a = 0; a < receive_packet_size+5; a++) { 01044 _data_packet.push_back(char_buffer[a]); //push the character array into the buffer 01045 } 01046 01047 //calculate the CRC using the vector (strings will cut off null characters) 01048 int calc_crc_one = calcCrcOne(); 01049 int calc_crc_two = calcCrcTwo(); 01050 01051 //xbee().printf("DEBUG: calc crc 1: %d, crc 2: %d\n\r", calc_crc_one, calc_crc_two); 01052 01053 // first confirm that the checksum is correct 01054 if ((calc_crc_one == checksum_one) and (calc_crc_two == checksum_two)) { 01055 01056 //xbee().printf("DEBUG: checksums are good!\n\r"); 01057 01058 //xbee().printf("receive_packet_number %d and _confirmed_packet_number %d\n\r", receive_packet_number, _confirmed_packet_number); //debug 01059 01060 // // CHECKSUM CORRECT & get the filename from the first packet (check that you receive first packet) 01061 // if (receive_packet_number == 0) { 01062 // char temp_char[receive_packet_size+1]; //temp array for memcpy 01063 // memset(&temp_char[0], 0, sizeof(temp_char)); //clear full array (or get random characters) 01064 // strncpy(temp_char, char_buffer + 5 /* Offset */, receive_packet_size*sizeof(char) /* Length */); //memcpy introduced random characters 01065 // 01066 // //xbee().printf("SEQUENCE: <<%s>>\n\r", temp_char]) // ERASE 01067 // 01068 // //have to terminate the string with '\0' 01069 // temp_char[receive_packet_size] = '\0'; 01070 // 01071 // //xbee().printf("\n\rDEBUG: ------ Filename? <<%s>>\n\r", temp_char); 01072 // //_received_filename = temp_char; 01073 // 01074 // //xbee().printf("\n\rDEBUG: _received_filename <<%s>>\n\r", _received_filename); 01075 // 01076 // //open a file for writing 01077 // //openReceiveFile(_received_filename); 01078 // 01079 // //send a reply to Python transmit program 01080 // sendReply(); 01081 // 01082 // led3() = 1; 01083 // 01084 // // even if correct CRC, counter prevents the program from writing the same packet twice 01085 // _confirmed_packet_number++; 01086 // } 01087 01088 // check if the packet that you're receiving (receive_packet_number) has been received already... 01089 01090 //CHECKSUM CORRECT & packet numbers that are 1 through N packets 01091 if (receive_packet_number == _confirmed_packet_number){ 01092 //save the data (char buffer) to the file if both checksums work... 01093 01094 // when a packet is received (successfully) send a reply 01095 //sendReply(); 01096 01097 // write correct data to file 01098 fprintf(_fp, "%s", char_buffer+5); 01099 01100 // even if correct CRC, counter prevents the program from writing the same packet twice 01101 _confirmed_packet_number++; 01102 } 01103 01104 //clear the variables 01105 checksum_one = -1; 01106 checksum_two = -1; 01107 } 01108 01109 process_state = HEADER_117; 01110 01111 break; 01112 } 01113 01114 // //counter breaks out of the loop if no data received 01115 // if (serial_timeout >= 10000) { 01116 // //xbee().printf("break serial_timeout %d\n\r", serial_timeout); 01117 // break; 01118 // } 01119 } 01120 break; 01121 01122 case END_TRANSMISSION: 01123 if (xbee().getc() == 16) { 01124 //xbee().printf("DEBUG: END_TRANSMISSION REACHED: 1. \n\r"); 01125 01126 if (xbee().getc() == 16) { 01127 //xbee().printf("DEBUG: END_TRANSMISSION REACHED: 2. \n\r"); 01128 01129 _end_sequence_transmission = true; 01130 //endReceiveData(); 01131 } 01132 } 01133 01134 //xbee().printf("DEBUG: END_TRANSMISSION REACHED: 5. \n\r"); 01135 01136 //process_state = HEADER_117; //don't do this unless the check is wrong 01137 //xbee().printf("END_TRANSMISSION process_state is %d\n\r", process_state); //should be 5 (debug) 02/06/2018 01138 data_transmission_complete = true; 01139 break; 01140 }//END OF SWITCH 01141 01142 if (data_transmission_complete) { 01143 //xbee().printf("DEBUG: checkForIncomingData data_transmission_complete \n\r"); 01144 break; //out of while loop 01145 } 01146 } // while loop 01147 01148 led3() = !led3(); 01149 01150 if (data_transmission_complete) 01151 return false; //tell state machine class that this is done (not transmitting, false) 01152 else { 01153 return true; 01154 } 01155 } 01156 01157 int MbedLogger::sendReply() { 01158 //being explicit in what's being transmitted 01159 01160 //change this method to be more explicit later 01161 01162 //integer vector _data_packet is used here, cleared fist just in case 01163 01164 _data_packet.clear(); //same data packet for transmission 01165 _data_packet.push_back(117); 01166 _data_packet.push_back(101); 01167 01168 //_confirmed_packet_number comes from the packet number that is sent from the Python program 01169 _data_packet.push_back(_confirmed_packet_number / 256); //packet number only changed when confirmed 01170 _data_packet.push_back(_confirmed_packet_number % 256); //split into first and second byte 01171 01172 //compute checksums 01173 01174 int receiver_crc_one = calcCrcOne(); 01175 int receiver_crc_two = calcCrcTwo(); 01176 01177 _data_packet.push_back(receiver_crc_one); 01178 _data_packet.push_back(receiver_crc_two); 01179 01180 //transmit this packet 01181 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++) { 01182 xbee().putc(*_it); //send integers over serial port one byte at a time 01183 } 01184 01185 //change process methodology later... 01186 01187 return _confirmed_packet_number; 01188 } 01189 01190 void MbedLogger::endReceiveData() { //DLE character * 4 ==> 10 10 10 10 01191 closeLogFile(); //close the file here 01192 xbee().printf("endReceiveData closed the file and ended transmission\n\r"); 01193 } 01194 01195 //calculate the crc with an integer array 01196 int MbedLogger::calcCrcOneArray(int *input_array, int array_length) { 01197 //can't initialize the table in the constructor in c++ 01198 int crc_table [256] = {0, 49345, 49537, 320, 49921, 960, 640, 49729, 50689, 1728, 1920, 51009, 1280, 50625, 50305, 1088, 52225, 3264, 3456, 52545, 3840, 53185, 52865, 3648, 2560, 51905, 52097, 2880, 51457, 2496, 2176, 51265, 55297, 6336, 6528, 55617, 6912, 56257, 55937, 6720, 7680, 57025, 57217, 8000, 56577, 7616, 7296, 56385, 5120, 54465, 54657, 5440, 55041, 6080, 5760, 54849, 53761, 4800, 4992, 54081, 4352, 53697, 53377, 4160, 61441, 12480, 12672, 61761, 13056, 62401, 62081, 12864, 13824, 63169, 63361, 14144, 62721, 13760, 13440, 62529, 15360, 64705, 64897, 15680, 65281, 16320, 16000, 65089, 64001, 15040, 15232, 64321, 14592, 63937, 63617, 14400, 10240, 59585, 59777, 10560, 60161, 11200, 10880, 59969, 60929, 11968, 12160, 61249, 11520, 60865, 60545, 11328, 58369, 9408, 9600, 58689, 9984, 59329, 59009, 9792, 8704, 58049, 58241, 9024, 57601, 8640, 8320, 57409, 40961, 24768, 24960, 41281, 25344, 41921, 41601, 25152, 26112, 42689, 42881, 26432, 42241, 26048, 25728, 42049, 27648, 44225, 44417, 27968, 44801, 28608, 28288, 44609, 43521, 27328, 27520, 43841, 26880, 43457, 43137, 26688, 30720, 47297, 47489, 31040, 47873, 31680, 31360, 47681, 48641, 32448, 32640, 48961, 32000, 48577, 48257, 31808, 46081, 29888, 30080, 46401, 30464, 47041, 46721, 30272, 29184, 45761, 45953, 29504, 45313, 29120, 28800, 45121, 20480, 37057, 37249, 20800, 37633, 21440, 21120, 37441, 38401, 22208, 22400, 38721, 21760, 38337, 38017, 21568, 39937, 23744, 23936, 40257, 24320, 40897, 40577, 24128, 23040, 39617, 39809, 23360, 39169, 22976, 22656, 38977, 34817, 18624, 18816, 35137, 19200, 35777, 35457, 19008, 19968, 36545, 36737, 20288, 36097, 19904, 19584, 35905, 17408, 33985, 34177, 17728, 34561, 18368, 18048, 34369, 33281, 17088, 17280, 33601, 16640, 33217, 32897, 16448}; 01199 int crc = 0; 01200 for (int z = 0; z < array_length; z++) { 01201 crc = (crc_table[(input_array[z] ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF; 01202 } 01203 return crc / 256; //second-to-last byte 01204 } 01205 01206 int MbedLogger::calcCrcTwoArray(int *input_array, int array_length) { 01207 //can't initialize the table in the constructor in c++ 01208 int crc_table [256] = {0, 49345, 49537, 320, 49921, 960, 640, 49729, 50689, 1728, 1920, 51009, 1280, 50625, 50305, 1088, 52225, 3264, 3456, 52545, 3840, 53185, 52865, 3648, 2560, 51905, 52097, 2880, 51457, 2496, 2176, 51265, 55297, 6336, 6528, 55617, 6912, 56257, 55937, 6720, 7680, 57025, 57217, 8000, 56577, 7616, 7296, 56385, 5120, 54465, 54657, 5440, 55041, 6080, 5760, 54849, 53761, 4800, 4992, 54081, 4352, 53697, 53377, 4160, 61441, 12480, 12672, 61761, 13056, 62401, 62081, 12864, 13824, 63169, 63361, 14144, 62721, 13760, 13440, 62529, 15360, 64705, 64897, 15680, 65281, 16320, 16000, 65089, 64001, 15040, 15232, 64321, 14592, 63937, 63617, 14400, 10240, 59585, 59777, 10560, 60161, 11200, 10880, 59969, 60929, 11968, 12160, 61249, 11520, 60865, 60545, 11328, 58369, 9408, 9600, 58689, 9984, 59329, 59009, 9792, 8704, 58049, 58241, 9024, 57601, 8640, 8320, 57409, 40961, 24768, 24960, 41281, 25344, 41921, 41601, 25152, 26112, 42689, 42881, 26432, 42241, 26048, 25728, 42049, 27648, 44225, 44417, 27968, 44801, 28608, 28288, 44609, 43521, 27328, 27520, 43841, 26880, 43457, 43137, 26688, 30720, 47297, 47489, 31040, 47873, 31680, 31360, 47681, 48641, 32448, 32640, 48961, 32000, 48577, 48257, 31808, 46081, 29888, 30080, 46401, 30464, 47041, 46721, 30272, 29184, 45761, 45953, 29504, 45313, 29120, 28800, 45121, 20480, 37057, 37249, 20800, 37633, 21440, 21120, 37441, 38401, 22208, 22400, 38721, 21760, 38337, 38017, 21568, 39937, 23744, 23936, 40257, 24320, 40897, 40577, 24128, 23040, 39617, 39809, 23360, 39169, 22976, 22656, 38977, 34817, 18624, 18816, 35137, 19200, 35777, 35457, 19008, 19968, 36545, 36737, 20288, 36097, 19904, 19584, 35905, 17408, 33985, 34177, 17728, 34561, 18368, 18048, 34369, 33281, 17088, 17280, 33601, 16640, 33217, 32897, 16448}; 01209 int crc = 0; 01210 for (int z = 0; z < array_length; z++) { 01211 crc = (crc_table[(input_array[z] ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF; 01212 } 01213 return crc % 256; //second-to-last byte 01214 } 01215 01216 int MbedLogger::calcCrcOne() { 01217 //can't initialize the table in the constructor in c++ 01218 int crc_table [256] = {0, 49345, 49537, 320, 49921, 960, 640, 49729, 50689, 1728, 1920, 51009, 1280, 50625, 50305, 1088, 52225, 3264, 3456, 52545, 3840, 53185, 52865, 3648, 2560, 51905, 52097, 2880, 51457, 2496, 2176, 51265, 55297, 6336, 6528, 55617, 6912, 56257, 55937, 6720, 7680, 57025, 57217, 8000, 56577, 7616, 7296, 56385, 5120, 54465, 54657, 5440, 55041, 6080, 5760, 54849, 53761, 4800, 4992, 54081, 4352, 53697, 53377, 4160, 61441, 12480, 12672, 61761, 13056, 62401, 62081, 12864, 13824, 63169, 63361, 14144, 62721, 13760, 13440, 62529, 15360, 64705, 64897, 15680, 65281, 16320, 16000, 65089, 64001, 15040, 15232, 64321, 14592, 63937, 63617, 14400, 10240, 59585, 59777, 10560, 60161, 11200, 10880, 59969, 60929, 11968, 12160, 61249, 11520, 60865, 60545, 11328, 58369, 9408, 9600, 58689, 9984, 59329, 59009, 9792, 8704, 58049, 58241, 9024, 57601, 8640, 8320, 57409, 40961, 24768, 24960, 41281, 25344, 41921, 41601, 25152, 26112, 42689, 42881, 26432, 42241, 26048, 25728, 42049, 27648, 44225, 44417, 27968, 44801, 28608, 28288, 44609, 43521, 27328, 27520, 43841, 26880, 43457, 43137, 26688, 30720, 47297, 47489, 31040, 47873, 31680, 31360, 47681, 48641, 32448, 32640, 48961, 32000, 48577, 48257, 31808, 46081, 29888, 30080, 46401, 30464, 47041, 46721, 30272, 29184, 45761, 45953, 29504, 45313, 29120, 28800, 45121, 20480, 37057, 37249, 20800, 37633, 21440, 21120, 37441, 38401, 22208, 22400, 38721, 21760, 38337, 38017, 21568, 39937, 23744, 23936, 40257, 24320, 40897, 40577, 24128, 23040, 39617, 39809, 23360, 39169, 22976, 22656, 38977, 34817, 18624, 18816, 35137, 19200, 35777, 35457, 19008, 19968, 36545, 36737, 20288, 36097, 19904, 19584, 35905, 17408, 33985, 34177, 17728, 34561, 18368, 18048, 34369, 33281, 17088, 17280, 33601, 16640, 33217, 32897, 16448}; 01219 01220 int crc = 0; 01221 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++) 01222 crc = (crc_table[(*_it ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF; 01223 01224 return crc / 256; //second-to-last byte 01225 } 01226 01227 int MbedLogger::calcCrcTwo() { 01228 int crc_table [256] = {0, 49345, 49537, 320, 49921, 960, 640, 49729, 50689, 1728, 1920, 51009, 1280, 50625, 50305, 1088, 52225, 3264, 3456, 52545, 3840, 53185, 52865, 3648, 2560, 51905, 52097, 2880, 51457, 2496, 2176, 51265, 55297, 6336, 6528, 55617, 6912, 56257, 55937, 6720, 7680, 57025, 57217, 8000, 56577, 7616, 7296, 56385, 5120, 54465, 54657, 5440, 55041, 6080, 5760, 54849, 53761, 4800, 4992, 54081, 4352, 53697, 53377, 4160, 61441, 12480, 12672, 61761, 13056, 62401, 62081, 12864, 13824, 63169, 63361, 14144, 62721, 13760, 13440, 62529, 15360, 64705, 64897, 15680, 65281, 16320, 16000, 65089, 64001, 15040, 15232, 64321, 14592, 63937, 63617, 14400, 10240, 59585, 59777, 10560, 60161, 11200, 10880, 59969, 60929, 11968, 12160, 61249, 11520, 60865, 60545, 11328, 58369, 9408, 9600, 58689, 9984, 59329, 59009, 9792, 8704, 58049, 58241, 9024, 57601, 8640, 8320, 57409, 40961, 24768, 24960, 41281, 25344, 41921, 41601, 25152, 26112, 42689, 42881, 26432, 42241, 26048, 25728, 42049, 27648, 44225, 44417, 27968, 44801, 28608, 28288, 44609, 43521, 27328, 27520, 43841, 26880, 43457, 43137, 26688, 30720, 47297, 47489, 31040, 47873, 31680, 31360, 47681, 48641, 32448, 32640, 48961, 32000, 48577, 48257, 31808, 46081, 29888, 30080, 46401, 30464, 47041, 46721, 30272, 29184, 45761, 45953, 29504, 45313, 29120, 28800, 45121, 20480, 37057, 37249, 20800, 37633, 21440, 21120, 37441, 38401, 22208, 22400, 38721, 21760, 38337, 38017, 21568, 39937, 23744, 23936, 40257, 24320, 40897, 40577, 24128, 23040, 39617, 39809, 23360, 39169, 22976, 22656, 38977, 34817, 18624, 18816, 35137, 19200, 35777, 35457, 19008, 19968, 36545, 36737, 20288, 36097, 19904, 19584, 35905, 17408, 33985, 34177, 17728, 34561, 18368, 18048, 34369, 33281, 17088, 17280, 33601, 16640, 33217, 32897, 16448}; 01229 01230 int crc = 0; 01231 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++) 01232 crc = (crc_table[(*_it ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF; 01233 01234 //xbee().printf("DEBUG: calcCrcTwo string length: %d crc: %d\n\r", input_array.length(), crc % 256); 01235 01236 return crc % 256; //last byte 01237 } 01238 01239 void MbedLogger::resetReplyPacket() { 01240 _confirmed_packet_number = 0; 01241 } 01242 01243 void MbedLogger::openNewMissionFile() { 01244 xbee().printf("Opening Mission file (sequence.txt) for reception.\n\r"); 01245 string filename_string = _file_system_string + "sequence.txt"; 01246 01247 xbee().printf("openNewMissionFile: %s\n\r", filename_string.c_str()); 01248 01249 _fp = fopen(filename_string.c_str(), "w"); 01250 } 01251 01252 void MbedLogger::openReceiveFile(string filename) { 01253 string filename_string = _file_system_string + filename; //example "sequence.txt" 01254 01255 _fp = fopen(filename_string.c_str(), "w"); //open a file for writing 01256 } 01257 01258 void MbedLogger::setDataCounter(int input_counter) { 01259 _transmit_counter = input_counter; 01260 } 01261 01262 void MbedLogger::closeIncompleteFile() { 01263 fprintf(_fp, "TRANSMISSION INTERRUPTED!"); //write this warning to the file 01264 closeLogFile(); //close file 01265 } 01266 01267 void MbedLogger::appendLogFile(int current_state, int option) { 01268 //option one means write to file 01269 01270 if (option == 1) { 01271 if (!_fp) { //if not present 01272 _fp = fopen(_full_file_path_string.c_str(), "a"); 01273 } 01274 01275 //record data using the recordData function (takes in the state integer) 01276 recordData(current_state); 01277 } 01278 01279 else { 01280 closeLogFile(); 01281 } 01282 } 01283 void MbedLogger::appendDiagFile(char *printf_string, int flushclose) { 01284 // 01285 01286 int start_time = 1518467832; 01287 if(_time_set) { start_time = _default_timestamp_time;} 01288 //in the future create the ability to set the start time 01289 01290 int time_now = mbedLogger().getSystemTime(); 01291 if (!_fp2) { //if not present 01292 _fp2 = fopen(_full_diagfile_path_string.c_str(), "a"); 01293 } 01294 int del_time = time_now - start_time; 01295 //record data using the recordData function (takes in the state integer) 01296 fprintf(_fp2, "time=%d seconds ", del_time); 01297 fprintf(_fp2, printf_string); 01298 if(flushclose == 1) { fflush(_fp2); } 01299 if(flushclose == 0) {fclose(_fp2); _fp2 = NULL; } 01300 } 01301 01302 // initialize and close the file 01303 // log file freezes at 0x0000006c 01304 void MbedLogger::initializeLogFile() { 01305 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 01306 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 01307 _full_file_path_string = file_name_string; 01308 char buf[256]; 01309 xbee().printf("%s file system init\n\r", _file_system_string.c_str()); 01310 sprintf(buf, "%s mbedlogger():initializelogfile: file system init\n\r", _file_system_string.c_str()); 01311 appendDiagFile(buf,1); 01312 //try to open this file... 01313 _fp = fopen(file_name_string.c_str(), "r"); 01314 01315 //if the file is empty, create this. 01316 if (!_fp) { 01317 _fp = fopen(file_name_string.c_str(), "w"); //write,print,close 01318 //fprintf(_fp,"state_string,state_ID,timer,depth_cmd,depth_ft,pitch_cmd,pitch_deg,bce_cmd,bce_mm,batt_cmd,batt_mm,pitchRate_degs,depthRate_fps\nempty log file!\n"); 01319 fprintf(_fp,_heading_string.c_str()); 01320 closeLogFile(); 01321 } 01322 else 01323 closeLogFile(); //close the opened read file 01324 } 01325 void MbedLogger::initializeDiagFile(int print_diag) { 01326 //string file_name_string = _file_system_string + "DIAG000.txt"; // how to pass in log file name as a string? 01327 string file_name_string = _file_system_string + configFileIO().logFilesStruct.diagFileName; // "DIAG000.txt"; 01328 _full_diagfile_path_string = file_name_string; 01329 char buf[256]; 01330 xbee().printf("%s file system init\n\r", _file_system_string.c_str()); 01331 sprintf(buf, "mbedlogger():Initializediagfile input variable diagfilename: %s file system init\n\r", file_name_string.c_str()); 01332 if(print_diag == 1) {appendDiagFile(buf,3);} //configFileIO().logFilesStruct.diagFileName 01333 //try to open this file... 01334 if( _fp2 == NULL) { _fp2 = fopen(file_name_string.c_str(), "r"); } 01335 01336 //if the file is empty, create this. 01337 if (!_fp2) { 01338 _fp2 = fopen(file_name_string.c_str(), "w"); //write,print,close 01339 //fprintf(_fp,"state_string,state_ID,timer,depth_cmd,depth_ft,pitch_cmd,pitch_deg,bce_cmd,bce_mm,batt_cmd,batt_mm,pitchRate_degs,depthRate_fps\nempty log file!\n"); 01340 fprintf(_fp2,_diag_heading_string.c_str()); 01341 closeDiagFile(); 01342 } 01343 else 01344 closeDiagFile(); //close the opened read file 01345 } 01346 01347 int MbedLogger::fileTransmitState() { 01348 return _file_transmission_state; 01349 } 01350 01351 int MbedLogger::calcCrcOneString (string input_string) { 01352 int crc_table [256] = {0, 49345, 49537, 320, 49921, 960, 640, 49729, 50689, 1728, 1920, 51009, 1280, 50625, 50305, 1088, 52225, 3264, 3456, 52545, 3840, 53185, 52865, 3648, 2560, 51905, 52097, 2880, 51457, 2496, 2176, 51265, 55297, 6336, 6528, 55617, 6912, 56257, 55937, 6720, 7680, 57025, 57217, 8000, 56577, 7616, 7296, 56385, 5120, 54465, 54657, 5440, 55041, 6080, 5760, 54849, 53761, 4800, 4992, 54081, 4352, 53697, 53377, 4160, 61441, 12480, 12672, 61761, 13056, 62401, 62081, 12864, 13824, 63169, 63361, 14144, 62721, 13760, 13440, 62529, 15360, 64705, 64897, 15680, 65281, 16320, 16000, 65089, 64001, 15040, 15232, 64321, 14592, 63937, 63617, 14400, 10240, 59585, 59777, 10560, 60161, 11200, 10880, 59969, 60929, 11968, 12160, 61249, 11520, 60865, 60545, 11328, 58369, 9408, 9600, 58689, 9984, 59329, 59009, 9792, 8704, 58049, 58241, 9024, 57601, 8640, 8320, 57409, 40961, 24768, 24960, 41281, 25344, 41921, 41601, 25152, 26112, 42689, 42881, 26432, 42241, 26048, 25728, 42049, 27648, 44225, 44417, 27968, 44801, 28608, 28288, 44609, 43521, 27328, 27520, 43841, 26880, 43457, 43137, 26688, 30720, 47297, 47489, 31040, 47873, 31680, 31360, 47681, 48641, 32448, 32640, 48961, 32000, 48577, 48257, 31808, 46081, 29888, 30080, 46401, 30464, 47041, 46721, 30272, 29184, 45761, 45953, 29504, 45313, 29120, 28800, 45121, 20480, 37057, 37249, 20800, 37633, 21440, 21120, 37441, 38401, 22208, 22400, 38721, 21760, 38337, 38017, 21568, 39937, 23744, 23936, 40257, 24320, 40897, 40577, 24128, 23040, 39617, 39809, 23360, 39169, 22976, 22656, 38977, 34817, 18624, 18816, 35137, 19200, 35777, 35457, 19008, 19968, 36545, 36737, 20288, 36097, 19904, 19584, 35905, 17408, 33985, 34177, 17728, 34561, 18368, 18048, 34369, 33281, 17088, 17280, 33601, 16640, 33217, 32897, 16448}; 01353 01354 int crc = 0; 01355 for (unsigned int i = 0; i < input_string.length(); i++) { 01356 //convert each character to an integer 01357 int character_to_integer = input_string[i]; //correct 01358 01359 crc = (crc_table[(character_to_integer ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF; 01360 } 01361 01362 //xbee().printf("DEBUG: calcCrcOne string length: %d crc: %d\n\r", input_string.length(), crc/256); 01363 01364 return crc / 256; //second-to-last byte 01365 } 01366 01367 int MbedLogger::calcCrcTwoString (string input_string) { 01368 int crc_table [256] = {0, 49345, 49537, 320, 49921, 960, 640, 49729, 50689, 1728, 1920, 51009, 1280, 50625, 50305, 1088, 52225, 3264, 3456, 52545, 3840, 53185, 52865, 3648, 2560, 51905, 52097, 2880, 51457, 2496, 2176, 51265, 55297, 6336, 6528, 55617, 6912, 56257, 55937, 6720, 7680, 57025, 57217, 8000, 56577, 7616, 7296, 56385, 5120, 54465, 54657, 5440, 55041, 6080, 5760, 54849, 53761, 4800, 4992, 54081, 4352, 53697, 53377, 4160, 61441, 12480, 12672, 61761, 13056, 62401, 62081, 12864, 13824, 63169, 63361, 14144, 62721, 13760, 13440, 62529, 15360, 64705, 64897, 15680, 65281, 16320, 16000, 65089, 64001, 15040, 15232, 64321, 14592, 63937, 63617, 14400, 10240, 59585, 59777, 10560, 60161, 11200, 10880, 59969, 60929, 11968, 12160, 61249, 11520, 60865, 60545, 11328, 58369, 9408, 9600, 58689, 9984, 59329, 59009, 9792, 8704, 58049, 58241, 9024, 57601, 8640, 8320, 57409, 40961, 24768, 24960, 41281, 25344, 41921, 41601, 25152, 26112, 42689, 42881, 26432, 42241, 26048, 25728, 42049, 27648, 44225, 44417, 27968, 44801, 28608, 28288, 44609, 43521, 27328, 27520, 43841, 26880, 43457, 43137, 26688, 30720, 47297, 47489, 31040, 47873, 31680, 31360, 47681, 48641, 32448, 32640, 48961, 32000, 48577, 48257, 31808, 46081, 29888, 30080, 46401, 30464, 47041, 46721, 30272, 29184, 45761, 45953, 29504, 45313, 29120, 28800, 45121, 20480, 37057, 37249, 20800, 37633, 21440, 21120, 37441, 38401, 22208, 22400, 38721, 21760, 38337, 38017, 21568, 39937, 23744, 23936, 40257, 24320, 40897, 40577, 24128, 23040, 39617, 39809, 23360, 39169, 22976, 22656, 38977, 34817, 18624, 18816, 35137, 19200, 35777, 35457, 19008, 19968, 36545, 36737, 20288, 36097, 19904, 19584, 35905, 17408, 33985, 34177, 17728, 34561, 18368, 18048, 34369, 33281, 17088, 17280, 33601, 16640, 33217, 32897, 16448}; 01369 01370 int crc = 0; 01371 for (unsigned int i = 0; i < input_string.length(); i++) { 01372 //convert each character to an integer 01373 int character_to_integer = input_string[i]; //correct 01374 01375 crc = (crc_table[(character_to_integer ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF; 01376 } 01377 01378 //xbee().printf("DEBUG: calcCrcTwo string length: %d crc: %d\n\r", input_string.length(), crc % 256); 01379 01380 return crc % 256; //last byte 01381 } 01382 01383 void MbedLogger::createEmptyLog() { 01384 // string file_name_string = _file_system_string + "LOG000.csv"; 01385 string file_name_string = _file_system_string + configFileIO().logFilesStruct.logFileName; // "DIAG000.txt"; 01386 //string file_name_string = _file_system_string + "LOG000.csv"; // how to pass in log file name as a string? 01387 string empty_log = "EMPTY LOG"; 01388 01389 _fp = fopen(file_name_string.c_str(), "w"); 01390 01391 fprintf(_fp, "%.25s\n",empty_log.c_str()); //just write this string to the log (processing needs a file size that is not zero) 01392 closeLogFile(); 01393 } 01394 01395 int MbedLogger::getFileSize(string filename) { 01396 // fixed the const char * errror: 01397 // https://stackoverflow.com/questions/347949/how-to-convert-a-stdstring-to-const-char-or-char 01398 const char * char_filename = filename.c_str(); // Returns a pointer to an array that contains a null-terminated sequence of characters (i.e., a C-string) representing the current value of the string object. 01399 //http://www.cplusplus.com/reference/string/string/c_str/ 01400 01401 _fp = fopen(filename.c_str(), "rb"); //open the file for reading as a binary file 01402 01403 fseek(_fp, 0, SEEK_END); //SEEK_END is a constant in cstdio (end of the file) 01404 unsigned int file_size = ftell(_fp); //For binary streams, this is the number of bytes from the beginning of the file. 01405 fseek(_fp, 0, SEEK_SET); //SEEK_SET is hte beginning of the file, not sure this is necessary 01406 01407 xbee().printf("%s file size is %d bytes.\n\r", filename.c_str(), file_size); 01408 01409 closeLogFile(); //can probably just close the file pointer and not worry about position 01410 01411 return file_size; 01412 } 01413 01414 int MbedLogger::debugFileState() { 01415 xbee().printf("What is _fp right now? %p\n\r", _fp); //pointer notation 01416 01417 if (_fp) 01418 return 1; //file pointer does exist 01419 else 01420 return 0; //file pointer does not exist 01421 } 01422 01423 void MbedLogger::specifyFileForTransmit(string input_string) { 01424 xbee().printf("specifyFileForTransmit\n\r"); 01425 01426 string file_string = _file_system_string + input_string; 01427 01428 xbee().printf("file_string is <%s>\n\r", file_string.c_str()); 01429 01430 //open this file to read 01431 _fp = fopen(file_string.c_str(), "r"); 01432 01433 //transmit that file 01434 //transmitDataWithTicker(); //replaced ticker 01435 01436 _file_transmission = true; 01437 } 01438 01439 void MbedLogger::transmitFileFromDirectory( int file_number ) { 01440 file_number = file_number + 1; //to get the correct number 01441 01442 DIR *dir; 01443 struct dirent *dp; //dirent.h is the format of directory entries 01444 int log_found =0, loop=1; //start file numbers at 1 01445 long int temp=0; 01446 01447 // char * char_pointer; 01448 // char * numstart, *numstop; 01449 01450 if ( NULL == (dir = opendir( _file_system_string.c_str() )) ) { 01451 xbee().printf("MBED directory could not be opened\r\n"); 01452 } 01453 else 01454 { 01455 while ( NULL != (dp = readdir( dir )) ) 01456 { 01457 xbee().printf( "%d. %s (log file: %d, %d)\r\n", loop, dp->d_name,log_found,temp); 01458 01459 //process current file if it matches the file number 01460 if (file_number == loop) { 01461 char * current_file_name = dp->d_name; //pointer to this char array 01462 01463 specifyFileForTransmit(current_file_name); 01464 01465 break; 01466 } 01467 01468 loop++; 01469 } 01470 } 01471 } 01472 01473 void MbedLogger::accessMbedDirectory() { 01474 printMbedDirectory(); 01475 01476 xbee().printf("Type in the number of the file you want to transmit.\n\r"); 01477 01478 char message[42]; 01479 01480 xbee().scanf("%41s", message); 01481 01482 xbee().printf("Input received!\n\r"); 01483 01484 //check if char array is an integer 01485 char* conversion_pointer; 01486 long converted = strtol(message, &conversion_pointer, 10); 01487 01488 if (*conversion_pointer) { 01489 //conversion failed because the input was not a number 01490 xbee().printf("NOT A VALID FILE NUMBER!\n\r"); 01491 } 01492 else { 01493 //conversion worked! 01494 xbee().printf("You chose file number: %d\n\r", converted); 01495 01496 // transmit the file 01497 transmitFileFromDirectory(converted); 01498 } 01499 } 01500 01501 void MbedLogger::closeLogFile() { 01502 led4() = 1; 01503 01504 if (_fp == NULL){ 01505 xbee().printf("MbedLogger: (%s) LOG FILE WAS ALREADY CLOSED!\n\r", _file_system_string.c_str()); 01506 } 01507 01508 else { 01509 xbee().printf("MbedLogger: (%s) CLOSING LOG FILE!\n\r", _file_system_string.c_str()); 01510 01511 //close file 01512 fclose(_fp); 01513 01514 _fp = NULL; //set pointer to zero 01515 } 01516 } 01517 void MbedLogger::closeDiagFile() { // closes he present diag file on _fp2 01518 led4() = 1; 01519 01520 if (_fp2 == NULL){ 01521 xbee().printf("MbedLogger: (%s) DIAG FILE WAS ALREADY CLOSED!\n\r", _full_diagfile_path_string.c_str()); 01522 } 01523 01524 else { 01525 xbee().printf("MbedLogger: (%s) CLOSING LOG FILE!\n\r", _full_diagfile_path_string.c_str()); 01526 01527 //close file 01528 fclose(_fp2); 01529 01530 _fp2 = NULL; //set pointer to zero 01531 } 01532 } 01533 01534 void MbedLogger::activateReceivePacket() { 01535 _mbed_receive_loop = true; 01536 } 01537 01538 void MbedLogger::receiveSequenceFile() { 01539 //restart each time 01540 _end_sequence_transmission = false; 01541 01542 openNewMissionFile(); 01543 01544 //zero will be reserved for the file name, future 01545 _confirmed_packet_number = 1; //in sendReply() function that transmits a reply for incoming data 01546 01547 // int current_packet_number = 1; 01548 // int last_packet_number = -1; 01549 // int break_transmission = 0; 01550 01551 int counter = 0; 01552 01553 while(1) { 01554 wait(0.25); //runs at 4 Hz 01555 01556 checkForIncomingData(); 01557 01558 //xbee().printf("\n\rDEBUG: _confirmed_packet_number%d\n\r", _confirmed_packet_number); 01559 01560 counter++; 01561 01562 sendReply(); //bad name, should call it send request or something 01563 01564 if (_end_sequence_transmission) 01565 break; 01566 } 01567 01568 closeLogFile(); 01569 } 01570 01571 void MbedLogger::receiveMissionDataWithFSM() { 01572 checkForIncomingData(); 01573 01574 // Example: send reply 75 65 00 00 01575 // Example: send reply 75 65 00 01 01576 } 01577 01578 void MbedLogger::receiveMissionDataWithTicker() { 01579 openNewMissionFile(); //sequence.txt file opened 01580 01581 _mbed_receive_ticker.attach(callback(this, &MbedLogger::activateReceivePacket), 0.5); 01582 01583 xbee().printf("\n\r02/09/2018 MbedLogger receiveMissionData Beginning to receive sequence data...\n\r"); 01584 01585 resetReplyPacket(); //reset the reply packet 01586 01587 //idea for stopping this if data not being received 01588 int current_packet_number = 0; 01589 int last_packet_number = -1; 01590 int break_transmission = 0; 01591 01592 while(1) { 01593 //runs at 10 hz 01594 if (_mbed_receive_loop) { 01595 if (!checkForIncomingData()) { // run this until it finishes 01596 //when you complete data reception, this will become false 01597 xbee().printf("\n\rMbedLogger: Data RECEPTION complete.\n\r"); 01598 _mbed_receive_ticker.detach(); 01599 break; 01600 } 01601 else { 01602 01603 // SEND REPLY 75 65 00 00 01604 // SEND REPLY 75 65 00 01 01605 01606 //check if you keep getting the same thing 01607 current_packet_number = sendReply(); 01608 01609 //xbee().printf("DEBUG: current packet number %d (last packet number %d) \n\r", current_packet_number, last_packet_number); //debug 01610 01611 //let this count up a few times before it exits 01612 if (current_packet_number == last_packet_number) { 01613 break_transmission++; 01614 01615 //break transmission after 50 failed attempts (was 100) 01616 if (break_transmission >= 50) { 01617 closeIncompleteFile(); //close the file 01618 _mbed_receive_ticker.detach(); 01619 xbee().printf("MbedLogger: TRANSMISSION INTERRUPTED!\n\r"); 01620 break; 01621 } 01622 } 01623 else 01624 last_packet_number = current_packet_number; 01625 } 01626 _mbed_receive_loop = false; // wait until the loop rate timer fires again 01627 } 01628 } 01629 } 01630 01631 //only do this for the MBED because of the limited file size 01632 //write one line to the file (open to write, this will erase all other data) and close it. 01633 void MbedLogger::eraseFile() { 01634 _fp = fopen(_full_file_path_string.c_str(), "w"); // LOG000.csv 01635 01636 fprintf(_fp,_heading_string.c_str()); 01637 01638 closeLogFile(); 01639 } 01640 01641 void MbedLogger::intCreateDataPacket(int data_buffer[],int payload_length) { 01642 // packet is 7565 0001 FFFF EEEE CC DATA DATA DATA ... CRC1 CRC2 01643 01644 //check here https://www.rapidtables.com/convert/number/hex-to-decimal.html?x=01c0 01645 // ieee 754: http://www6.uniovi.es/~antonio/uned/ieee754/IEEE-754hex32.html 01646 01647 //CLEAR: Removes all elements from the vector (which are destroyed), leaving the container with a size of 0. 01648 _data_packet.clear(); 01649 01650 //DATA PACKET HEADER 01651 _data_packet.push_back(117); //0x75 01652 _data_packet.push_back(101); //0x65 01653 01654 _data_packet.push_back(_packet_number/256); //current packet number in 0x#### form 01655 _data_packet.push_back(_packet_number%256); //current packet number in 0x#### form 01656 01657 _data_packet.push_back(_total_number_of_packets/256); //total number of packets, 0x#### form 01658 _data_packet.push_back(_total_number_of_packets%256); //total number of packets, 0x#### form 01659 01660 _data_packet.push_back(_current_line_length); 01661 01662 //DATA FROM INTEGER ARRAY (read the array) 01663 for (int i = 0; i < payload_length; i++) { 01664 _data_packet.push_back(data_buffer[i]); 01665 } 01666 01667 //CRC CALCULATIONS BELOW, character version of calculation screws up on null character 0x00, scrapped and using vector of integers 01668 int crc_one = calcCrcOne(); 01669 int crc_two = calcCrcTwo(); 01670 01671 //place the crc bytes into the data packet that is transmitted 01672 _data_packet.push_back(crc_one); 01673 _data_packet.push_back(crc_two); 01674 } 01675 01676 void MbedLogger::setTransmitPacketNumber(int packet_number) { 01677 _transmit_packet_num = packet_number; 01678 01679 //also needed to reset a boolean flag on the transmit 01680 _fsm_transmit_complete = false; 01681 01682 _end_transmit_packet = false; 01683 } 01684 01685 int MbedLogger::currentPacketNumber() { 01686 return _packet_number; 01687 }
Generated on Thu Jul 14 2022 10:54:35 by
1.7.2