Flying Sea Glider / Mbed 2 deprecated 2019_19feb19_jcw_noSD

modifications to run via legfile.txt and then exit, manage logfile versions, diagnostics file

Dependencies:   mbed MODSERIAL FATFileSystem

MbedLogger/MbedLogger.cpp@62:d502889e74f1, 2018-06-18 (annotated)

Committer:
tnhnrl
Date:
Mon Jun 18 14:45:37 2018 +0000
Revision:
62:d502889e74f1
Child:
63:6cb0405fc6e6
in process of making an exit command on timeout from data transmission

Who changed what in which revision?

UserRevisionLine numberNew contents of line
tnhnrl 62:d502889e74f1 1 #include "MbedLogger.hpp"
tnhnrl 62:d502889e74f1 2 #include "StaticDefs.hpp"
tnhnrl 62:d502889e74f1 3
tnhnrl 62:d502889e74f1 4 //Timer t; //used to test time to create packet //timing debug
tnhnrl 62:d502889e74f1 5
tnhnrl 62:d502889e74f1 6 MbedLogger::MbedLogger(string file_system_input_string) {
tnhnrl 62:d502889e74f1 7 _file_system_string = file_system_input_string;
tnhnrl 62:d502889e74f1 8 _full_file_path_string = _file_system_string + "LOG000.csv"; //use multiple logs in the future? (after file size is too large)
tnhnrl 62:d502889e74f1 9 _file_number = 0;
tnhnrl 62:d502889e74f1 10 _file_transmission = true;
tnhnrl 62:d502889e74f1 11 _confirmed_packet_number = 0; //must set this to zero
tnhnrl 62:d502889e74f1 12 _transmit_counter = 0;
tnhnrl 62:d502889e74f1 13 _file_transmission_state = -1;
tnhnrl 62:d502889e74f1 14 _total_number_of_packets = 0;
tnhnrl 62:d502889e74f1 15 _mbed_transmit_loop = false;
tnhnrl 62:d502889e74f1 16 _received_filename = "";
tnhnrl 62:d502889e74f1 17 }
tnhnrl 62:d502889e74f1 18
tnhnrl 62:d502889e74f1 19 //this function has to be called for the time to function correctly
tnhnrl 62:d502889e74f1 20 void MbedLogger::setLogTime() {
tnhnrl 62:d502889e74f1 21 pc().printf("\n%s log time set.\n\r", _file_system_string.c_str());
tnhnrl 62:d502889e74f1 22 set_time(1518467832); // Set RTC time to Mon, 12 FEB 2018 15:37
tnhnrl 62:d502889e74f1 23 }
tnhnrl 62:d502889e74f1 24
tnhnrl 62:d502889e74f1 25 //in the future create the ability to set the start time
tnhnrl 62:d502889e74f1 26 int MbedLogger::getSystemTime() {
tnhnrl 62:d502889e74f1 27 time_t seconds = time(NULL); // Time as seconds since January 1, 1970
tnhnrl 62:d502889e74f1 28
tnhnrl 62:d502889e74f1 29 return seconds;
tnhnrl 62:d502889e74f1 30 }
tnhnrl 62:d502889e74f1 31
tnhnrl 62:d502889e74f1 32 void MbedLogger::recordData(int current_state) {
tnhnrl 62:d502889e74f1 33 int data_log_int = mbedLogger().getSystemTime(); //read the system timer to get unix timestamp
tnhnrl 62:d502889e74f1 34 //_data_log[0] = mbedLogger().getSystemTime(); //read the system timer to get unix timestamp
tnhnrl 62:d502889e74f1 35 _data_log[1] = depthLoop().getCommand(); //depth command
tnhnrl 62:d502889e74f1 36 _data_log[2] = depthLoop().getPosition(); //depth reading
tnhnrl 62:d502889e74f1 37 _data_log[3] = pitchLoop().getCommand(); //pitch command
tnhnrl 62:d502889e74f1 38 _data_log[4] = pitchLoop().getPosition(); //pitch reading
tnhnrl 62:d502889e74f1 39 _data_log[5] = bce().getSetPosition_mm(); //BCE command
tnhnrl 62:d502889e74f1 40 _data_log[6] = bce().getPosition_mm(); //BCE reading
tnhnrl 62:d502889e74f1 41 _data_log[7] = batt().getSetPosition_mm(); //Batt command
tnhnrl 62:d502889e74f1 42 _data_log[8] = batt().getPosition_mm(); //Batt reading
tnhnrl 62:d502889e74f1 43 _data_log[9] = pitchLoop().getVelocity(); // pitchRate_degs (degrees per second)
tnhnrl 62:d502889e74f1 44 _data_log[10] = depthLoop().getVelocity(); // depthRate_fps (feet per second)
tnhnrl 62:d502889e74f1 45
tnhnrl 62:d502889e74f1 46 //check what the current state is and create that string
tnhnrl 62:d502889e74f1 47 string string_state;
tnhnrl 62:d502889e74f1 48 if (current_state == SIT_IDLE)
tnhnrl 62:d502889e74f1 49 string_state = "SIT_IDLE";
tnhnrl 62:d502889e74f1 50 else if (current_state == FIND_NEUTRAL)
tnhnrl 62:d502889e74f1 51 string_state = "FIND_NEUTRAL";
tnhnrl 62:d502889e74f1 52 else if (current_state == DIVE)
tnhnrl 62:d502889e74f1 53 string_state = "DIVE";
tnhnrl 62:d502889e74f1 54 else if (current_state == RISE)
tnhnrl 62:d502889e74f1 55 string_state = "RISE";
tnhnrl 62:d502889e74f1 56 else if (current_state == FLOAT_LEVEL)
tnhnrl 62:d502889e74f1 57 string_state = "FLOAT_LEVEL";
tnhnrl 62:d502889e74f1 58 else if (current_state == FLOAT_BROADCAST)
tnhnrl 62:d502889e74f1 59 string_state = "FLOAT_BROADCAST";
tnhnrl 62:d502889e74f1 60 else if (current_state == EMERGENCY_CLIMB)
tnhnrl 62:d502889e74f1 61 string_state = "EMERGENCY_CLIMB";
tnhnrl 62:d502889e74f1 62 else if (current_state == MULTI_DIVE)
tnhnrl 62:d502889e74f1 63 string_state = "MULTI_DIVE";
tnhnrl 62:d502889e74f1 64 else if (current_state == MULTI_RISE)
tnhnrl 62:d502889e74f1 65 string_state = "MULTI_RISE";
tnhnrl 62:d502889e74f1 66 else if (current_state == KEYBOARD)
tnhnrl 62:d502889e74f1 67 string_state = "KEYBOARD";
tnhnrl 62:d502889e74f1 68 else if (current_state == CHECK_TUNING)
tnhnrl 62:d502889e74f1 69 string_state = "CHECK_TUNING";
tnhnrl 62:d502889e74f1 70 else if (current_state == PITCH_TUNER_DEPTH)
tnhnrl 62:d502889e74f1 71 string_state = "PITCH_TUNER_DEPTH";
tnhnrl 62:d502889e74f1 72 else if (current_state == PITCH_TUNER_RUN)
tnhnrl 62:d502889e74f1 73 string_state = "PITCH_TUNER_RUN";
tnhnrl 62:d502889e74f1 74
tnhnrl 62:d502889e74f1 75 //record the string state, integer state, and then the data
tnhnrl 62:d502889e74f1 76 fprintf(_fp, "%s,%d,",string_state.c_str(),current_state);
tnhnrl 62:d502889e74f1 77 fprintf(_fp, "%d,",data_log_int);
tnhnrl 62:d502889e74f1 78 fprintf(_fp, "%0.1f,%0.1f,%0.1f,%0.1f,%0.1f,%0.1f,%0.1f,%0.1f,%0.1f,%0.1f\n",_data_log[1],
tnhnrl 62:d502889e74f1 79 _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]);
tnhnrl 62:d502889e74f1 80 }
tnhnrl 62:d502889e74f1 81
tnhnrl 62:d502889e74f1 82 void MbedLogger::printMbedDirectory() {
tnhnrl 62:d502889e74f1 83 DIR *dir;
tnhnrl 62:d502889e74f1 84 struct dirent *dp; //dirent.h is the format of directory entries
tnhnrl 62:d502889e74f1 85 int log_found =0,loop=0;
tnhnrl 62:d502889e74f1 86 long int temp=0;
tnhnrl 62:d502889e74f1 87
tnhnrl 62:d502889e74f1 88 //char * char_pointer;
tnhnrl 62:d502889e74f1 89 char * numstart;
tnhnrl 62:d502889e74f1 90 //char *numstop;
tnhnrl 62:d502889e74f1 91
tnhnrl 62:d502889e74f1 92 pc().printf("\n\rPrinting out the directory of device %s\n\r", _file_system_string.c_str());
tnhnrl 62:d502889e74f1 93
tnhnrl 62:d502889e74f1 94 if ( NULL == (dir = opendir( _file_system_string.c_str() )) ) {
tnhnrl 62:d502889e74f1 95 pc().printf("MBED directory could not be opened\r\n");
tnhnrl 62:d502889e74f1 96 }
tnhnrl 62:d502889e74f1 97 else
tnhnrl 62:d502889e74f1 98 {
tnhnrl 62:d502889e74f1 99 while ( NULL != (dp = readdir( dir )) )
tnhnrl 62:d502889e74f1 100 {
tnhnrl 62:d502889e74f1 101 if(strncmp(dp->d_name,"LOG",3)==0)
tnhnrl 62:d502889e74f1 102 {
tnhnrl 62:d502889e74f1 103 log_found=1;
tnhnrl 62:d502889e74f1 104 /*numstart = dp->d_name; //Look for third character (do safety)
tnhnrl 62:d502889e74f1 105 numstop = strchr(dp->d_name,'.');
tnhnrl 62:d502889e74f1 106 if(numstart!=NULL&&numstop!=NULL)
tnhnrl 62:d502889e74f1 107 {
tnhnrl 62:d502889e74f1 108 temp=numstop-numstart;
tnhnrl 62:d502889e74f1 109 }
tnhnrl 62:d502889e74f1 110 else
tnhnrl 62:d502889e74f1 111 log_found=0; //Something is not right. Ignore
tnhnrl 62:d502889e74f1 112 */
tnhnrl 62:d502889e74f1 113 numstart=dp->d_name+3;
tnhnrl 62:d502889e74f1 114 temp=strtol(numstart,NULL,10); //add in check to see if this is null (start logs at one)
tnhnrl 62:d502889e74f1 115 }
tnhnrl 62:d502889e74f1 116 else
tnhnrl 62:d502889e74f1 117 log_found=0;
tnhnrl 62:d502889e74f1 118 pc().printf( "%d. %s (log file: %d, %d)\r\n", loop, dp->d_name,log_found,temp);
tnhnrl 62:d502889e74f1 119
tnhnrl 62:d502889e74f1 120 loop++;
tnhnrl 62:d502889e74f1 121 }
tnhnrl 62:d502889e74f1 122 }
tnhnrl 62:d502889e74f1 123 }
tnhnrl 62:d502889e74f1 124
tnhnrl 62:d502889e74f1 125 void MbedLogger::printCurrentLogFile() {
tnhnrl 62:d502889e74f1 126 //open the file for reading
tnhnrl 62:d502889e74f1 127 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 128
tnhnrl 62:d502889e74f1 129 int log_file_line_counter = 0;
tnhnrl 62:d502889e74f1 130
tnhnrl 62:d502889e74f1 131 _fp = fopen(file_name_string.c_str(), "r");
tnhnrl 62:d502889e74f1 132
tnhnrl 62:d502889e74f1 133 char buffer[500];
tnhnrl 62:d502889e74f1 134
tnhnrl 62:d502889e74f1 135 //read the file line-by-line and print that to the screen
tnhnrl 62:d502889e74f1 136 pc().printf("\n\rCURRENT MBED LOG FILE /local/Log%03d.csv:\n\n\r",_file_number);
tnhnrl 62:d502889e74f1 137 while (!feof(_fp)) {
tnhnrl 62:d502889e74f1 138 // read in the line and make sure it was successful
tnhnrl 62:d502889e74f1 139 if (fgets(buffer,500,_fp) != NULL) { //stops at new line
tnhnrl 62:d502889e74f1 140 pc().printf("%s\r",buffer);
tnhnrl 62:d502889e74f1 141 log_file_line_counter++;
tnhnrl 62:d502889e74f1 142 }
tnhnrl 62:d502889e74f1 143 }
tnhnrl 62:d502889e74f1 144
tnhnrl 62:d502889e74f1 145 //fgets stops when either (n-1) characters are read, the newline character is read,
tnhnrl 62:d502889e74f1 146 // or the end-of-file is reached
tnhnrl 62:d502889e74f1 147
tnhnrl 62:d502889e74f1 148 //close the file
tnhnrl 62:d502889e74f1 149 closeLogFile();
tnhnrl 62:d502889e74f1 150 pc().printf("\n\rLog file closed. Lines in log file: %d.\n\r", log_file_line_counter);
tnhnrl 62:d502889e74f1 151 }
tnhnrl 62:d502889e74f1 152
tnhnrl 62:d502889e74f1 153 void MbedLogger::openFileForTransmit() {
tnhnrl 62:d502889e74f1 154 pc().printf("\n\ropenFileForTransmit\n\r");
tnhnrl 62:d502889e74f1 155 //open the current file to read the contents
tnhnrl 62:d502889e74f1 156 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 157
tnhnrl 62:d502889e74f1 158 _fp = fopen(file_name_string.c_str(), "r");
tnhnrl 62:d502889e74f1 159
tnhnrl 62:d502889e74f1 160 _file_transmission = true;
tnhnrl 62:d502889e74f1 161 }
tnhnrl 62:d502889e74f1 162
tnhnrl 62:d502889e74f1 163 void MbedLogger::transmitCurrentLogFileLine(bool next_line) {
tnhnrl 62:d502889e74f1 164 vector <int> current_packet;
tnhnrl 62:d502889e74f1 165
tnhnrl 62:d502889e74f1 166 pc().printf("\n\rtransmitCurrentLogFile\n\r");
tnhnrl 62:d502889e74f1 167
tnhnrl 62:d502889e74f1 168 //while not end of file, read through line by line???
tnhnrl 62:d502889e74f1 169
tnhnrl 62:d502889e74f1 170 //transmit the file line by line (reads one line)
tnhnrl 62:d502889e74f1 171 //if you get the command to send a new line, go to the next line
tnhnrl 62:d502889e74f1 172 if (next_line) {
tnhnrl 62:d502889e74f1 173 if (fgets(_line_buffer,256,_fp) != NULL) {
tnhnrl 62:d502889e74f1 174 pc().printf("%s\r",_line_buffer);
tnhnrl 62:d502889e74f1 175 }
tnhnrl 62:d502889e74f1 176 }
tnhnrl 62:d502889e74f1 177
tnhnrl 62:d502889e74f1 178 // GET BUFFER LENGTH
tnhnrl 62:d502889e74f1 179 _current_line_length = strlen(_line_buffer);
tnhnrl 62:d502889e74f1 180
tnhnrl 62:d502889e74f1 181 //DEBUG PRINT TO SCREEN
tnhnrl 62:d502889e74f1 182 pc().printf("line_buffer size: %d %<%s>\r",_current_line_length,_line_buffer);
tnhnrl 62:d502889e74f1 183 }
tnhnrl 62:d502889e74f1 184
tnhnrl 62:d502889e74f1 185 void MbedLogger::createDataPacket() {
tnhnrl 62:d502889e74f1 186 // packet is 7565 0001 FFFF EEEE CC DATA DATA DATA ... CRC1 CRC2
tnhnrl 62:d502889e74f1 187
tnhnrl 62:d502889e74f1 188 //CLEAR: Removes all elements from the vector (which are destroyed), leaving the container with a size of 0.
tnhnrl 62:d502889e74f1 189 _data_packet.clear();
tnhnrl 62:d502889e74f1 190
tnhnrl 62:d502889e74f1 191 //DATA PACKET HEADER
tnhnrl 62:d502889e74f1 192 _data_packet.push_back(117); //0x75
tnhnrl 62:d502889e74f1 193 _data_packet.push_back(101); //0x65
tnhnrl 62:d502889e74f1 194
tnhnrl 62:d502889e74f1 195 _data_packet.push_back(_packet_number/256); //current packet number in 0x#### form
tnhnrl 62:d502889e74f1 196 _data_packet.push_back(_packet_number%256); //current packet number in 0x#### form
tnhnrl 62:d502889e74f1 197
tnhnrl 62:d502889e74f1 198 _data_packet.push_back(_total_number_of_packets/256); //total number of packets, 0x#### form
tnhnrl 62:d502889e74f1 199 _data_packet.push_back(_total_number_of_packets%256); //total number of packets, 0x#### form
tnhnrl 62:d502889e74f1 200
tnhnrl 62:d502889e74f1 201 _data_packet.push_back(_current_line_length);
tnhnrl 62:d502889e74f1 202
tnhnrl 62:d502889e74f1 203 pc().printf("DEBUG: Current line buffer: %s\n\r", _line_buffer); //debug
tnhnrl 62:d502889e74f1 204
tnhnrl 62:d502889e74f1 205 //DATA FROM LINE READ (read string character by chracter)
tnhnrl 62:d502889e74f1 206 for (int i = 0; i < _current_line_length; i++) {
tnhnrl 62:d502889e74f1 207 _data_packet.push_back(_line_buffer[i]);
tnhnrl 62:d502889e74f1 208 }
tnhnrl 62:d502889e74f1 209
tnhnrl 62:d502889e74f1 210 //CRC CALCULATIONS BELOW
tnhnrl 62:d502889e74f1 211 //character version of calculation screws up on null character 0x00, scrapped and using vector of integers
tnhnrl 62:d502889e74f1 212
tnhnrl 62:d502889e74f1 213 int crc_one = calcCrcOne();
tnhnrl 62:d502889e74f1 214 int crc_two = calcCrcTwo();
tnhnrl 62:d502889e74f1 215
tnhnrl 62:d502889e74f1 216 //place the crc bytes into the data packet that is transmitted
tnhnrl 62:d502889e74f1 217 _data_packet.push_back(crc_one);
tnhnrl 62:d502889e74f1 218 _data_packet.push_back(crc_two);
tnhnrl 62:d502889e74f1 219 }
tnhnrl 62:d502889e74f1 220
tnhnrl 62:d502889e74f1 221 //should i save it as a string and transmit the string? next iteration maybe
tnhnrl 62:d502889e74f1 222
tnhnrl 62:d502889e74f1 223 void MbedLogger::transmitDataPacket() {
tnhnrl 62:d502889e74f1 224 //WRITE the data (in bytes) to the serial port
tnhnrl 62:d502889e74f1 225 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++) {
tnhnrl 62:d502889e74f1 226 pc().putc(*_it); //send integers over serial port one byte at a time
tnhnrl 62:d502889e74f1 227 }
tnhnrl 62:d502889e74f1 228 }
tnhnrl 62:d502889e74f1 229
tnhnrl 62:d502889e74f1 230 // test to see if transmitDataPacket is working slower than you think.
tnhnrl 62:d502889e74f1 231
tnhnrl 62:d502889e74f1 232 // REACH ONE CHAR AT A TIME (EACH ITERATION OF STATE MACHINE...)
tnhnrl 62:d502889e74f1 233
tnhnrl 62:d502889e74f1 234 void MbedLogger::readTransmitPacketOneChar() {
tnhnrl 62:d502889e74f1 235 static int transmit_state = HEADER_117; //state in switch statement
tnhnrl 62:d502889e74f1 236 int incoming_byte = -1; //reset each time a character is read
tnhnrl 62:d502889e74f1 237 int requested_packet_number = -1; //reset each time a character is read
tnhnrl 62:d502889e74f1 238 static int input_packet[4]; //changed from char in previous iteration 03/28/2018
tnhnrl 62:d502889e74f1 239 static int transmit_crc_one = 0; //hold crc values until they're reset with calculations
tnhnrl 62:d502889e74f1 240 static int transmit_crc_two = 0;
tnhnrl 62:d502889e74f1 241
tnhnrl 62:d502889e74f1 242 incoming_byte = pc().getc();
tnhnrl 62:d502889e74f1 243
tnhnrl 62:d502889e74f1 244 switch(transmit_state) {
tnhnrl 62:d502889e74f1 245 case HEADER_117:
tnhnrl 62:d502889e74f1 246 //continue processing
tnhnrl 62:d502889e74f1 247 if (incoming_byte == 30){ //1E
tnhnrl 62:d502889e74f1 248 transmit_state = HEADER_101;
tnhnrl 62:d502889e74f1 249 }
tnhnrl 62:d502889e74f1 250 //did not receive byte 1
tnhnrl 62:d502889e74f1 251 else {
tnhnrl 62:d502889e74f1 252 transmit_state = HEADER_117; //go back to checking the first packet
tnhnrl 62:d502889e74f1 253 }
tnhnrl 62:d502889e74f1 254 break;
tnhnrl 62:d502889e74f1 255
tnhnrl 62:d502889e74f1 256 case HEADER_101:
tnhnrl 62:d502889e74f1 257 if(incoming_byte == 31) { //1F
tnhnrl 62:d502889e74f1 258 transmit_state = TRANSMIT_PACKET_1;
tnhnrl 62:d502889e74f1 259 }
tnhnrl 62:d502889e74f1 260 break;
tnhnrl 62:d502889e74f1 261
tnhnrl 62:d502889e74f1 262 case TRANSMIT_PACKET_1:
tnhnrl 62:d502889e74f1 263 if (incoming_byte >= 0) {
tnhnrl 62:d502889e74f1 264 input_packet[0] = 30;
tnhnrl 62:d502889e74f1 265 input_packet[1] = 31;
tnhnrl 62:d502889e74f1 266 input_packet[2] = incoming_byte;
tnhnrl 62:d502889e74f1 267
tnhnrl 62:d502889e74f1 268 transmit_state = TRANSMIT_PACKET_2;
tnhnrl 62:d502889e74f1 269 //_reply_byte3 = incoming_byte;
tnhnrl 62:d502889e74f1 270 }
tnhnrl 62:d502889e74f1 271 break;
tnhnrl 62:d502889e74f1 272
tnhnrl 62:d502889e74f1 273 case TRANSMIT_PACKET_2:
tnhnrl 62:d502889e74f1 274
tnhnrl 62:d502889e74f1 275 if (incoming_byte >= 0) {
tnhnrl 62:d502889e74f1 276 input_packet[3] = incoming_byte;
tnhnrl 62:d502889e74f1 277 //_reply_byte4 = incoming_byte;
tnhnrl 62:d502889e74f1 278 }
tnhnrl 62:d502889e74f1 279 transmit_state = PACKET_CRC_ONE;
tnhnrl 62:d502889e74f1 280
tnhnrl 62:d502889e74f1 281 break;
tnhnrl 62:d502889e74f1 282
tnhnrl 62:d502889e74f1 283 case (PACKET_CRC_ONE):
tnhnrl 62:d502889e74f1 284 transmit_crc_one = calcCrcOneArray(input_packet, 4); //calc CRC 1 from the input packet (size 4)
tnhnrl 62:d502889e74f1 285
tnhnrl 62:d502889e74f1 286 if (incoming_byte == transmit_crc_one) {
tnhnrl 62:d502889e74f1 287 transmit_state = PACKET_CRC_TWO;
tnhnrl 62:d502889e74f1 288 }
tnhnrl 62:d502889e74f1 289
tnhnrl 62:d502889e74f1 290 else
tnhnrl 62:d502889e74f1 291 transmit_state = HEADER_117;
tnhnrl 62:d502889e74f1 292 //or state remains the same?
tnhnrl 62:d502889e74f1 293
tnhnrl 62:d502889e74f1 294 break;
tnhnrl 62:d502889e74f1 295
tnhnrl 62:d502889e74f1 296 case (PACKET_CRC_TWO):
tnhnrl 62:d502889e74f1 297 transmit_state = HEADER_117;
tnhnrl 62:d502889e74f1 298 transmit_crc_two = calcCrcTwoArray(input_packet, 4); //calc CRC 2 from the input packet (size 4)
tnhnrl 62:d502889e74f1 299
tnhnrl 62:d502889e74f1 300 //check if CRC TWO is correct (then send full packet)
tnhnrl 62:d502889e74f1 301 if (incoming_byte == transmit_crc_two) {
tnhnrl 62:d502889e74f1 302 requested_packet_number = input_packet[2] * 256 + input_packet[3]; //compute the numbers 0 through 65535 with the two bytes
tnhnrl 62:d502889e74f1 303
tnhnrl 62:d502889e74f1 304 if (requested_packet_number != _previous_reply_byte) { //CHANGE THE NAME TO SOMETHING NOT BYTE!
tnhnrl 62:d502889e74f1 305 //MUST SET THE PACKET NUMBER
tnhnrl 62:d502889e74f1 306 _packet_number = requested_packet_number;
tnhnrl 62:d502889e74f1 307
tnhnrl 62:d502889e74f1 308 // DO NOT READ IF THE CURRENT REQUEST IS PAST THE TOTAL # OF PACKETS (lines of the file)
tnhnrl 62:d502889e74f1 309 if (_packet_number <= _total_number_of_packets) {
tnhnrl 62:d502889e74f1 310 readPacketInSeries();
tnhnrl 62:d502889e74f1 311 createDataPacket();
tnhnrl 62:d502889e74f1 312 }
tnhnrl 62:d502889e74f1 313
tnhnrl 62:d502889e74f1 314 _previous_reply_byte = requested_packet_number; //RECORD THIS BYTE to prevent new packets being created
tnhnrl 62:d502889e74f1 315
tnhnrl 62:d502889e74f1 316 transmitDataPacket(); //continuously transmit current packet until it tells you to do the next packet (response from Python program)
tnhnrl 62:d502889e74f1 317 }
tnhnrl 62:d502889e74f1 318
tnhnrl 62:d502889e74f1 319 else
tnhnrl 62:d502889e74f1 320 transmitDataPacket(); //if you get the same packet request, send the same packet
tnhnrl 62:d502889e74f1 321
tnhnrl 62:d502889e74f1 322 } //end of checksum (incoming_byte) if statement
tnhnrl 62:d502889e74f1 323
tnhnrl 62:d502889e74f1 324 break;
tnhnrl 62:d502889e74f1 325 } //switch statement complete
tnhnrl 62:d502889e74f1 326
tnhnrl 62:d502889e74f1 327 //led1() = !led1();
tnhnrl 62:d502889e74f1 328 }
tnhnrl 62:d502889e74f1 329
tnhnrl 62:d502889e74f1 330 int MbedLogger::readTransmitPacket() {
tnhnrl 62:d502889e74f1 331 _file_transmission = true;
tnhnrl 62:d502889e74f1 332 _file_transmission_state = 0;
tnhnrl 62:d502889e74f1 333
tnhnrl 62:d502889e74f1 334 //first check if you're receiving data, then read four bytes
tnhnrl 62:d502889e74f1 335
tnhnrl 62:d502889e74f1 336 int transmit_state = 0; //for state machine
tnhnrl 62:d502889e74f1 337
tnhnrl 62:d502889e74f1 338 int incoming_byte = -1;
tnhnrl 62:d502889e74f1 339
tnhnrl 62:d502889e74f1 340 int requested_packet_number = -1;
tnhnrl 62:d502889e74f1 341
tnhnrl 62:d502889e74f1 342 static int inside_while_loop = 1;
tnhnrl 62:d502889e74f1 343
tnhnrl 62:d502889e74f1 344 while (inside_while_loop) {
tnhnrl 62:d502889e74f1 345 if (pc().readable()) { //don't rely on pc readable being open all the time
tnhnrl 62:d502889e74f1 346
tnhnrl 62:d502889e74f1 347 incoming_byte = pc().getc();
tnhnrl 62:d502889e74f1 348
tnhnrl 62:d502889e74f1 349 switch(transmit_state) {
tnhnrl 62:d502889e74f1 350
tnhnrl 62:d502889e74f1 351 case (HEADER_117):
tnhnrl 62:d502889e74f1 352 //continue processing
tnhnrl 62:d502889e74f1 353 if (incoming_byte == 117){
tnhnrl 62:d502889e74f1 354 transmit_state = HEADER_101;
tnhnrl 62:d502889e74f1 355 }
tnhnrl 62:d502889e74f1 356 //end transmission
tnhnrl 62:d502889e74f1 357 else if (incoming_byte == 16) {
tnhnrl 62:d502889e74f1 358 transmit_state = END_TRANSMISSION;
tnhnrl 62:d502889e74f1 359 }
tnhnrl 62:d502889e74f1 360 else {
tnhnrl 62:d502889e74f1 361 transmit_state = HEADER_117;
tnhnrl 62:d502889e74f1 362 }
tnhnrl 62:d502889e74f1 363 break;
tnhnrl 62:d502889e74f1 364
tnhnrl 62:d502889e74f1 365 case (HEADER_101):
tnhnrl 62:d502889e74f1 366 if(incoming_byte == 101) {
tnhnrl 62:d502889e74f1 367 transmit_state = TRANSMIT_PACKET_1;
tnhnrl 62:d502889e74f1 368 }
tnhnrl 62:d502889e74f1 369 break;
tnhnrl 62:d502889e74f1 370
tnhnrl 62:d502889e74f1 371 case (TRANSMIT_PACKET_1):
tnhnrl 62:d502889e74f1 372 if (incoming_byte >= 0) {
tnhnrl 62:d502889e74f1 373 transmit_state = TRANSMIT_PACKET_2;
tnhnrl 62:d502889e74f1 374 _reply_byte3 = incoming_byte;
tnhnrl 62:d502889e74f1 375 }
tnhnrl 62:d502889e74f1 376 break;
tnhnrl 62:d502889e74f1 377
tnhnrl 62:d502889e74f1 378 case (TRANSMIT_PACKET_2):
tnhnrl 62:d502889e74f1 379 if (incoming_byte >= 0) {
tnhnrl 62:d502889e74f1 380 _reply_byte4 = incoming_byte;
tnhnrl 62:d502889e74f1 381 }
tnhnrl 62:d502889e74f1 382
tnhnrl 62:d502889e74f1 383 requested_packet_number = _reply_byte3 * 256 + _reply_byte4; //compute the numbers 0 through 65535 with the two bytes
tnhnrl 62:d502889e74f1 384
tnhnrl 62:d502889e74f1 385 if (requested_packet_number != _previous_reply_byte) { //CHANGE THE NAME TO SOMETHING NOT BYTE!
tnhnrl 62:d502889e74f1 386 //MUST SET THE PACKET NUMBER
tnhnrl 62:d502889e74f1 387 _packet_number = requested_packet_number;
tnhnrl 62:d502889e74f1 388
tnhnrl 62:d502889e74f1 389 readPacketInSeries();
tnhnrl 62:d502889e74f1 390 createDataPacket();
tnhnrl 62:d502889e74f1 391 _previous_reply_byte = requested_packet_number; //RECORD THIS BYTE to prevent new packets being created
tnhnrl 62:d502889e74f1 392 }
tnhnrl 62:d502889e74f1 393
tnhnrl 62:d502889e74f1 394 //continuously transmit current packet until it tells you to do the next packet (response from Python program)
tnhnrl 62:d502889e74f1 395 transmitDataPacket();
tnhnrl 62:d502889e74f1 396
tnhnrl 62:d502889e74f1 397 //TRANSMIT_PACKET_2
tnhnrl 62:d502889e74f1 398 inside_while_loop = 0; //exit the while loop with this
tnhnrl 62:d502889e74f1 399 pc().printf("(TRANSMIT_PACKET_2)reached inside_while_loop = 0\n\r"); //DEBUG
tnhnrl 62:d502889e74f1 400 break;
tnhnrl 62:d502889e74f1 401 } //end of switch statement
tnhnrl 62:d502889e74f1 402 } //end of while loop
tnhnrl 62:d502889e74f1 403
tnhnrl 62:d502889e74f1 404 // else {
tnhnrl 62:d502889e74f1 405 // //pc().printf("pc not readable \n\r");
tnhnrl 62:d502889e74f1 406 // }
tnhnrl 62:d502889e74f1 407 //
tnhnrl 62:d502889e74f1 408 }
tnhnrl 62:d502889e74f1 409
tnhnrl 62:d502889e74f1 410 //once you're outside of the while loop
tnhnrl 62:d502889e74f1 411 inside_while_loop = true; //for next iteration
tnhnrl 62:d502889e74f1 412
tnhnrl 62:d502889e74f1 413 pc().printf("DEBUG: (readTransmitPacket) Outside of while loop\n\r");
tnhnrl 62:d502889e74f1 414 return false;
tnhnrl 62:d502889e74f1 415 }
tnhnrl 62:d502889e74f1 416
tnhnrl 62:d502889e74f1 417 void MbedLogger::reOpenLineReader() {
tnhnrl 62:d502889e74f1 418 //open a new one
tnhnrl 62:d502889e74f1 419 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 420
tnhnrl 62:d502889e74f1 421 _fp = fopen(file_name_string.c_str(), "r"); //open the log file to read
tnhnrl 62:d502889e74f1 422
tnhnrl 62:d502889e74f1 423 //check if this actually worked...
tnhnrl 62:d502889e74f1 424 if (!_fp) {
tnhnrl 62:d502889e74f1 425 pc().printf("ERROR: Log file could not be opened\n\r");
tnhnrl 62:d502889e74f1 426 }
tnhnrl 62:d502889e74f1 427 else {
tnhnrl 62:d502889e74f1 428 pc().printf("Current Log file (LOG000.csv) was opened.\n\r");
tnhnrl 62:d502889e74f1 429 }
tnhnrl 62:d502889e74f1 430 }
tnhnrl 62:d502889e74f1 431
tnhnrl 62:d502889e74f1 432 bool MbedLogger::openLineReader() {
tnhnrl 62:d502889e74f1 433 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 434
tnhnrl 62:d502889e74f1 435 _fp = fopen(file_name_string.c_str(), "r"); //open the log file to read
tnhnrl 62:d502889e74f1 436
tnhnrl 62:d502889e74f1 437 //check if this actually worked...
tnhnrl 62:d502889e74f1 438 if (!_fp) {
tnhnrl 62:d502889e74f1 439 //pc().printf("ERROR: Log file could not be opened\n\r");
tnhnrl 62:d502889e74f1 440 return false;
tnhnrl 62:d502889e74f1 441 }
tnhnrl 62:d502889e74f1 442 else {
tnhnrl 62:d502889e74f1 443 //pc().printf("Current Log file (LOG000.csv) was opened.\n\r");
tnhnrl 62:d502889e74f1 444 return true;
tnhnrl 62:d502889e74f1 445 }
tnhnrl 62:d502889e74f1 446 }
tnhnrl 62:d502889e74f1 447
tnhnrl 62:d502889e74f1 448 //VERIFIED THIS IS WORKING
tnhnrl 62:d502889e74f1 449 void MbedLogger::readPacketInSeries(){
tnhnrl 62:d502889e74f1 450 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
tnhnrl 62:d502889e74f1 451
tnhnrl 62:d502889e74f1 452 //read the current line in the file
tnhnrl 62:d502889e74f1 453 fgets(_line_buffer, 256, _fp); //reads the line of characters until you reach a newline character
tnhnrl 62:d502889e74f1 454
tnhnrl 62:d502889e74f1 455 //RECORD THE STRING LENGTH
tnhnrl 62:d502889e74f1 456 _current_line_length = strlen(_line_buffer);
tnhnrl 62:d502889e74f1 457 }
tnhnrl 62:d502889e74f1 458
tnhnrl 62:d502889e74f1 459 void MbedLogger::getNumberOfPacketsInCurrentLog() {
tnhnrl 62:d502889e74f1 460 _packet_number = 0;
tnhnrl 62:d502889e74f1 461
tnhnrl 62:d502889e74f1 462 int ch;
tnhnrl 62:d502889e74f1 463
tnhnrl 62:d502889e74f1 464 _total_number_of_packets = 0; //clear this each time you read the file
tnhnrl 62:d502889e74f1 465
tnhnrl 62:d502889e74f1 466 //if this is null, use the default, else use the new file
tnhnrl 62:d502889e74f1 467
tnhnrl 62:d502889e74f1 468 if (_fp == NULL) {
tnhnrl 62:d502889e74f1 469 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 470
tnhnrl 62:d502889e74f1 471 _fp = fopen(file_name_string.c_str(), "r"); //open the log file to read
tnhnrl 62:d502889e74f1 472 }
tnhnrl 62:d502889e74f1 473 else { //else, use the file that is already open...
tnhnrl 62:d502889e74f1 474 fseek(_fp, 0, SEEK_SET); // SEEK_SET is the beginning of file
tnhnrl 62:d502889e74f1 475 }
tnhnrl 62:d502889e74f1 476
tnhnrl 62:d502889e74f1 477 while (EOF != (ch=getc(_fp))) {
tnhnrl 62:d502889e74f1 478 if ('\n' == ch)
tnhnrl 62:d502889e74f1 479 _total_number_of_packets++; // records the number of new lines to determine how many packets to send
tnhnrl 62:d502889e74f1 480 }
tnhnrl 62:d502889e74f1 481
tnhnrl 62:d502889e74f1 482 //move the FILE pointer back to the start
tnhnrl 62:d502889e74f1 483 fseek(_fp, 0, SEEK_SET); // SEEK_SET is the beginning of file
tnhnrl 62:d502889e74f1 484
tnhnrl 62:d502889e74f1 485 _file_transmission = true; //preparing to transmit files from MBED to Python
tnhnrl 62:d502889e74f1 486 }
tnhnrl 62:d502889e74f1 487
tnhnrl 62:d502889e74f1 488 void MbedLogger::endTransmissionCloseFile() {
tnhnrl 62:d502889e74f1 489 // if the file pointer is null, the file was not opened in the first place
tnhnrl 62:d502889e74f1 490 if (!_fp) {
tnhnrl 62:d502889e74f1 491 pc().printf("\n endTransmissionCloseFile: FILE WAS NOT OPENED!\n\r");
tnhnrl 62:d502889e74f1 492 }
tnhnrl 62:d502889e74f1 493 else {
tnhnrl 62:d502889e74f1 494 pc().printf("\n endTransmissionCloseFile: FILE FOUND AND CLOSED!\n\r");
tnhnrl 62:d502889e74f1 495 closeLogFile();
tnhnrl 62:d502889e74f1 496 }
tnhnrl 62:d502889e74f1 497
tnhnrl 62:d502889e74f1 498 _file_transmission = false;
tnhnrl 62:d502889e74f1 499 }
tnhnrl 62:d502889e74f1 500
tnhnrl 62:d502889e74f1 501 void MbedLogger::openWriteFile() {
tnhnrl 62:d502889e74f1 502 pc().printf("Opening file for reception.\n\r");
tnhnrl 62:d502889e74f1 503
tnhnrl 62:d502889e74f1 504 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 505
tnhnrl 62:d502889e74f1 506 _fp = fopen(file_name_string.c_str(), "w");
tnhnrl 62:d502889e74f1 507 }
tnhnrl 62:d502889e74f1 508
tnhnrl 62:d502889e74f1 509
tnhnrl 62:d502889e74f1 510 //weird bug noticed on 5/25/2018 where if you're not sending data the function is not completing
tnhnrl 62:d502889e74f1 511
tnhnrl 62:d502889e74f1 512
tnhnrl 62:d502889e74f1 513
tnhnrl 62:d502889e74f1 514
tnhnrl 62:d502889e74f1 515 // function checks for incoming data (receiver function) from a Python program that transmits a file
tnhnrl 62:d502889e74f1 516 // current limit is a file that has 255 lines of data
tnhnrl 62:d502889e74f1 517 bool MbedLogger::checkForIncomingData() {
tnhnrl 62:d502889e74f1 518 led1() = !led1();
tnhnrl 62:d502889e74f1 519
tnhnrl 62:d502889e74f1 520 int receive_packet_number;
tnhnrl 62:d502889e74f1 521 int receive_total_number_packets;
tnhnrl 62:d502889e74f1 522 int receive_packet_size;
tnhnrl 62:d502889e74f1 523
tnhnrl 62:d502889e74f1 524 bool data_transmission_complete = false;
tnhnrl 62:d502889e74f1 525
tnhnrl 62:d502889e74f1 526 int incoming_byte;
tnhnrl 62:d502889e74f1 527
tnhnrl 62:d502889e74f1 528 char char_buffer[256] = {}; //create empty buffer
tnhnrl 62:d502889e74f1 529
tnhnrl 62:d502889e74f1 530 //starting state
tnhnrl 62:d502889e74f1 531 int process_state = HEADER_117;
tnhnrl 62:d502889e74f1 532
tnhnrl 62:d502889e74f1 533 //variables for processing data below
tnhnrl 62:d502889e74f1 534 int checksum_one = -1;
tnhnrl 62:d502889e74f1 535 int checksum_two = -1;
tnhnrl 62:d502889e74f1 536
tnhnrl 62:d502889e74f1 537 int i = 5;
tnhnrl 62:d502889e74f1 538 int serial_timeout = 0;
tnhnrl 62:d502889e74f1 539
tnhnrl 62:d502889e74f1 540 while (pc().readable() && !data_transmission_complete) {
tnhnrl 62:d502889e74f1 541 incoming_byte = pc().getc(); //getc returns an unsigned char cast to an int
tnhnrl 62:d502889e74f1 542 //pc().printf("DEBUG: State 0\n\r");
tnhnrl 62:d502889e74f1 543
tnhnrl 62:d502889e74f1 544 switch(process_state) {
tnhnrl 62:d502889e74f1 545 case HEADER_117:
tnhnrl 62:d502889e74f1 546 //continue processing
tnhnrl 62:d502889e74f1 547 if (incoming_byte == 117){
tnhnrl 62:d502889e74f1 548 process_state = HEADER_101;
tnhnrl 62:d502889e74f1 549 //pc().printf("DEBUG: Case 117\n\r");
tnhnrl 62:d502889e74f1 550 }
tnhnrl 62:d502889e74f1 551 //end transmission
tnhnrl 62:d502889e74f1 552 else if (incoming_byte == 16) {
tnhnrl 62:d502889e74f1 553 process_state = END_TRANSMISSION;
tnhnrl 62:d502889e74f1 554 pc().printf("DEBUG: State 16 (END_TRANSMISSION)\n\r");
tnhnrl 62:d502889e74f1 555 }
tnhnrl 62:d502889e74f1 556 else {
tnhnrl 62:d502889e74f1 557 process_state = HEADER_117; // ???
tnhnrl 62:d502889e74f1 558 //pc().printf("DEBUG: State Header 117\n\r");
tnhnrl 62:d502889e74f1 559 }
tnhnrl 62:d502889e74f1 560 break;
tnhnrl 62:d502889e74f1 561
tnhnrl 62:d502889e74f1 562 case HEADER_101:
tnhnrl 62:d502889e74f1 563 if(incoming_byte == 101) {
tnhnrl 62:d502889e74f1 564 process_state = PACKET_NUM;
tnhnrl 62:d502889e74f1 565 //pc().printf("DEBUG: Case 101\n\r");
tnhnrl 62:d502889e74f1 566 }
tnhnrl 62:d502889e74f1 567 break;
tnhnrl 62:d502889e74f1 568
tnhnrl 62:d502889e74f1 569 case PACKET_NUM:
tnhnrl 62:d502889e74f1 570 receive_packet_number = incoming_byte;
tnhnrl 62:d502889e74f1 571 process_state = TOTAL_NUM_PACKETS;
tnhnrl 62:d502889e74f1 572 //pc().printf("DEBUG: Case PACKET_NUM\n\r");
tnhnrl 62:d502889e74f1 573 break;
tnhnrl 62:d502889e74f1 574
tnhnrl 62:d502889e74f1 575 case TOTAL_NUM_PACKETS:
tnhnrl 62:d502889e74f1 576 receive_total_number_packets = incoming_byte;
tnhnrl 62:d502889e74f1 577 process_state = PACKET_SIZE;
tnhnrl 62:d502889e74f1 578 //pc().printf("DEBUG: Case TOTAL_NUM_PACKETS\n\r");
tnhnrl 62:d502889e74f1 579 break;
tnhnrl 62:d502889e74f1 580
tnhnrl 62:d502889e74f1 581 case PACKET_SIZE:
tnhnrl 62:d502889e74f1 582 receive_packet_size = incoming_byte;
tnhnrl 62:d502889e74f1 583 //pc().printf("DEBUG: Case PACKET_SIZE\n\r");
tnhnrl 62:d502889e74f1 584
tnhnrl 62:d502889e74f1 585 //write the header stuff to it
tnhnrl 62:d502889e74f1 586 char_buffer[0] = 117;
tnhnrl 62:d502889e74f1 587 char_buffer[1] = 101;
tnhnrl 62:d502889e74f1 588 char_buffer[2] = receive_packet_number;
tnhnrl 62:d502889e74f1 589 char_buffer[3] = receive_total_number_packets;
tnhnrl 62:d502889e74f1 590 char_buffer[4] = receive_packet_size;
tnhnrl 62:d502889e74f1 591
tnhnrl 62:d502889e74f1 592 // tests confirmed that packet number is zero, number of packets is 12, packet size is 12
tnhnrl 62:d502889e74f1 593 //pc().printf("char_buffer 2/3/4: %d %d %d\n\r", receive_packet_number,receive_total_number_packets,receive_packet_size);
tnhnrl 62:d502889e74f1 594
tnhnrl 62:d502889e74f1 595 led4() = !led4();
tnhnrl 62:d502889e74f1 596
tnhnrl 62:d502889e74f1 597 //process packet data, future version will append for larger data sizes, 0xFFFF
tnhnrl 62:d502889e74f1 598
tnhnrl 62:d502889e74f1 599 // IF YOU GET AN INTERRUPTED DATA STREAM YOU NEED TO BREAK OUT OF THE LOOP
tnhnrl 62:d502889e74f1 600 i = 5;
tnhnrl 62:d502889e74f1 601 serial_timeout = 0;
tnhnrl 62:d502889e74f1 602
tnhnrl 62:d502889e74f1 603 while (true) {
tnhnrl 62:d502889e74f1 604 if (pc().readable()) {
tnhnrl 62:d502889e74f1 605 char_buffer[i] = pc().getc(); //read all of the data packets
tnhnrl 62:d502889e74f1 606 i++;
tnhnrl 62:d502889e74f1 607
tnhnrl 62:d502889e74f1 608 serial_timeout = 0; //reset the timeout
tnhnrl 62:d502889e74f1 609 }
tnhnrl 62:d502889e74f1 610 else {
tnhnrl 62:d502889e74f1 611 serial_timeout++;
tnhnrl 62:d502889e74f1 612 }
tnhnrl 62:d502889e74f1 613
tnhnrl 62:d502889e74f1 614 // When full data packet is received...
tnhnrl 62:d502889e74f1 615 if (i >= receive_packet_size+5) { //cannot do this properly with a for loop
tnhnrl 62:d502889e74f1 616 //get checksum bytes
tnhnrl 62:d502889e74f1 617 checksum_one = pc().getc();
tnhnrl 62:d502889e74f1 618 checksum_two = pc().getc();
tnhnrl 62:d502889e74f1 619
tnhnrl 62:d502889e74f1 620 //calculate the CRC from the header and data bytes using _data_packet (vector)
tnhnrl 62:d502889e74f1 621 //found out calculating crc with string was dropping empty or null spaces
tnhnrl 62:d502889e74f1 622 _data_packet.clear(); //clear it just in case
tnhnrl 62:d502889e74f1 623
tnhnrl 62:d502889e74f1 624 for (int a = 0; a < receive_packet_size+5; a++) {
tnhnrl 62:d502889e74f1 625 _data_packet.push_back(char_buffer[a]); //push the character array into the buffer
tnhnrl 62:d502889e74f1 626 }
tnhnrl 62:d502889e74f1 627
tnhnrl 62:d502889e74f1 628 //calculate the CRC using the vector (strings will cut off null characters)
tnhnrl 62:d502889e74f1 629 int calc_crc_one = calcCrcOne();
tnhnrl 62:d502889e74f1 630 int calc_crc_two = calcCrcTwo();
tnhnrl 62:d502889e74f1 631
tnhnrl 62:d502889e74f1 632 //pc().printf("DEBUG: calc crc 1: %d, crc 2: %d\n\r", calc_crc_one, calc_crc_two);
tnhnrl 62:d502889e74f1 633
tnhnrl 62:d502889e74f1 634 // first confirm that the checksum is correct
tnhnrl 62:d502889e74f1 635 if ((calc_crc_one == checksum_one) and (calc_crc_two == checksum_two)) {
tnhnrl 62:d502889e74f1 636 led2() = !led2();
tnhnrl 62:d502889e74f1 637 // CHECKSUM CORRECT & get the filename from the first packet (check that you receive first packet)
tnhnrl 62:d502889e74f1 638 if (receive_packet_number == 0) {
tnhnrl 62:d502889e74f1 639 char temp_char[receive_packet_size+1]; //temp array for memcpy
tnhnrl 62:d502889e74f1 640 memset(&temp_char[0], 0, sizeof(temp_char)); //clear full array (or get random characters)
tnhnrl 62:d502889e74f1 641 strncpy(temp_char, char_buffer + 5 /* Offset */, receive_packet_size*sizeof(char) /* Length */); //memcpy introduced random characters
tnhnrl 62:d502889e74f1 642
tnhnrl 62:d502889e74f1 643 //have to terminate the string with '\0'
tnhnrl 62:d502889e74f1 644 temp_char[receive_packet_size] = '\0';
tnhnrl 62:d502889e74f1 645
tnhnrl 62:d502889e74f1 646 //pc().printf("\n\rDEBUG: ------ Filename? <<%s>>\n\r", temp_char);
tnhnrl 62:d502889e74f1 647 _received_filename = temp_char;
tnhnrl 62:d502889e74f1 648
tnhnrl 62:d502889e74f1 649 //pc().printf("\n\rDEBUG: _received_filename <<%s>>\n\r", _received_filename);
tnhnrl 62:d502889e74f1 650
tnhnrl 62:d502889e74f1 651 //open a file for writing
tnhnrl 62:d502889e74f1 652 openReceiveFile(_received_filename);
tnhnrl 62:d502889e74f1 653
tnhnrl 62:d502889e74f1 654 //send a reply to Python transmit program
tnhnrl 62:d502889e74f1 655 sendReply();
tnhnrl 62:d502889e74f1 656
tnhnrl 62:d502889e74f1 657 led3() = 1;
tnhnrl 62:d502889e74f1 658
tnhnrl 62:d502889e74f1 659 // even if correct CRC, counter prevents the program from writing the same packet twice
tnhnrl 62:d502889e74f1 660 _confirmed_packet_number++;
tnhnrl 62:d502889e74f1 661 }
tnhnrl 62:d502889e74f1 662
tnhnrl 62:d502889e74f1 663 // check if the packet that you're receiving (receive_packet_number) has been received already...
tnhnrl 62:d502889e74f1 664
tnhnrl 62:d502889e74f1 665 //CHECKSUM CORRECT & packet numbers that are 1 through N packets
tnhnrl 62:d502889e74f1 666 else if (receive_packet_number == _confirmed_packet_number){
tnhnrl 62:d502889e74f1 667 //save the data (char buffer) to the file if both checksums work...
tnhnrl 62:d502889e74f1 668
tnhnrl 62:d502889e74f1 669 // when a packet is received (successfully) send a reply
tnhnrl 62:d502889e74f1 670 sendReply();
tnhnrl 62:d502889e74f1 671
tnhnrl 62:d502889e74f1 672 // write correct data to file
tnhnrl 62:d502889e74f1 673 fprintf(_fp, "%s", char_buffer+5);
tnhnrl 62:d502889e74f1 674
tnhnrl 62:d502889e74f1 675 // even if correct CRC, counter prevents the program from writing the same packet twice
tnhnrl 62:d502889e74f1 676 _confirmed_packet_number++;
tnhnrl 62:d502889e74f1 677 }
tnhnrl 62:d502889e74f1 678
tnhnrl 62:d502889e74f1 679 //clear the variables
tnhnrl 62:d502889e74f1 680 checksum_one = -1;
tnhnrl 62:d502889e74f1 681 checksum_two = -1;
tnhnrl 62:d502889e74f1 682 }
tnhnrl 62:d502889e74f1 683
tnhnrl 62:d502889e74f1 684 process_state = HEADER_117;
tnhnrl 62:d502889e74f1 685
tnhnrl 62:d502889e74f1 686 break;
tnhnrl 62:d502889e74f1 687 }
tnhnrl 62:d502889e74f1 688
tnhnrl 62:d502889e74f1 689 //counter breaks out of the loop if no data received
tnhnrl 62:d502889e74f1 690 if (serial_timeout >= 10000) {
tnhnrl 62:d502889e74f1 691 //pc().printf("break serial_timeout %d\n\r", serial_timeout);
tnhnrl 62:d502889e74f1 692 break;
tnhnrl 62:d502889e74f1 693 }
tnhnrl 62:d502889e74f1 694 }
tnhnrl 62:d502889e74f1 695 break;
tnhnrl 62:d502889e74f1 696
tnhnrl 62:d502889e74f1 697 case END_TRANSMISSION:
tnhnrl 62:d502889e74f1 698 if (pc().getc() == 16) {
tnhnrl 62:d502889e74f1 699 pc().printf("DEBUG: END_TRANSMISSION REACHED: 1. \n\r");
tnhnrl 62:d502889e74f1 700
tnhnrl 62:d502889e74f1 701 if (pc().getc() == 16) {
tnhnrl 62:d502889e74f1 702 pc().printf("DEBUG: END_TRANSMISSION REACHED: 2. \n\r");
tnhnrl 62:d502889e74f1 703
tnhnrl 62:d502889e74f1 704 endReceiveData();
tnhnrl 62:d502889e74f1 705 }
tnhnrl 62:d502889e74f1 706 }
tnhnrl 62:d502889e74f1 707
tnhnrl 62:d502889e74f1 708 pc().printf("DEBUG: END_TRANSMISSION REACHED: 5. \n\r");
tnhnrl 62:d502889e74f1 709
tnhnrl 62:d502889e74f1 710 //process_state = HEADER_117; //don't do this unless the check is wrong
tnhnrl 62:d502889e74f1 711 pc().printf("END_TRANSMISSION process_state is %d\n\r", process_state); //should be 5 (debug) 02/06/2018
tnhnrl 62:d502889e74f1 712 data_transmission_complete = true;
tnhnrl 62:d502889e74f1 713 break;
tnhnrl 62:d502889e74f1 714 }//END OF SWITCH
tnhnrl 62:d502889e74f1 715
tnhnrl 62:d502889e74f1 716 if (data_transmission_complete) {
tnhnrl 62:d502889e74f1 717 pc().printf("DEBUG: checkForIncomingData data_transmission_complete \n\r");
tnhnrl 62:d502889e74f1 718 break; //out of while loop
tnhnrl 62:d502889e74f1 719 }
tnhnrl 62:d502889e74f1 720 } // while loop
tnhnrl 62:d502889e74f1 721
tnhnrl 62:d502889e74f1 722 led3() = !led3();
tnhnrl 62:d502889e74f1 723
tnhnrl 62:d502889e74f1 724 if (data_transmission_complete)
tnhnrl 62:d502889e74f1 725 return false; //tell state machine class that this is done (not transmitting, false)
tnhnrl 62:d502889e74f1 726 else {
tnhnrl 62:d502889e74f1 727 return true;
tnhnrl 62:d502889e74f1 728 }
tnhnrl 62:d502889e74f1 729 }
tnhnrl 62:d502889e74f1 730
tnhnrl 62:d502889e74f1 731 void MbedLogger::checkForPythonCommand() {
tnhnrl 62:d502889e74f1 732 // STARTING STATE
tnhnrl 62:d502889e74f1 733 static int process_state = HEADER_117;
tnhnrl 62:d502889e74f1 734
tnhnrl 62:d502889e74f1 735 static string command_string = "";
tnhnrl 62:d502889e74f1 736
tnhnrl 62:d502889e74f1 737 int incoming_byte;
tnhnrl 62:d502889e74f1 738
tnhnrl 62:d502889e74f1 739 if ( pc().readable() ) {
tnhnrl 62:d502889e74f1 740 led1() = !led1();
tnhnrl 62:d502889e74f1 741 incoming_byte = pc().getc(); //getc returns an unsigned char cast to an int
tnhnrl 62:d502889e74f1 742
tnhnrl 62:d502889e74f1 743 switch(process_state) {
tnhnrl 62:d502889e74f1 744 case HEADER_117:
tnhnrl 62:d502889e74f1 745 //continue processing
tnhnrl 62:d502889e74f1 746 if (incoming_byte == 117){
tnhnrl 62:d502889e74f1 747 led2() = !led2();
tnhnrl 62:d502889e74f1 748 process_state = HEADER_101;
tnhnrl 62:d502889e74f1 749 pc().printf("DEBUG: Case 117\n\r");
tnhnrl 62:d502889e74f1 750 }
tnhnrl 62:d502889e74f1 751 //end transmission
tnhnrl 62:d502889e74f1 752 else if (incoming_byte == 16) {
tnhnrl 62:d502889e74f1 753 process_state = END_TRANSMISSION;
tnhnrl 62:d502889e74f1 754 pc().printf("DEBUG: State 16 (END_TRANSMISSION)\n\r");
tnhnrl 62:d502889e74f1 755 }
tnhnrl 62:d502889e74f1 756 else {
tnhnrl 62:d502889e74f1 757 process_state = HEADER_117; // ???
tnhnrl 62:d502889e74f1 758 //pc().printf("DEBUG: State Header 117\n\r");
tnhnrl 62:d502889e74f1 759 }
tnhnrl 62:d502889e74f1 760 break;
tnhnrl 62:d502889e74f1 761
tnhnrl 62:d502889e74f1 762 case HEADER_101:
tnhnrl 62:d502889e74f1 763 if(incoming_byte == 101) {
tnhnrl 62:d502889e74f1 764 led3() = !led3();
tnhnrl 62:d502889e74f1 765 process_state = COMMAND_ONE;
tnhnrl 62:d502889e74f1 766 pc().printf("DEBUG: Case 101\n\r");
tnhnrl 62:d502889e74f1 767 }
tnhnrl 62:d502889e74f1 768 break;
tnhnrl 62:d502889e74f1 769 case COMMAND_ONE:
tnhnrl 62:d502889e74f1 770 command_string += (char)incoming_byte;
tnhnrl 62:d502889e74f1 771 process_state = COMMAND_TWO;
tnhnrl 62:d502889e74f1 772 pc().printf("DEBUG: COMMAND: [%s]\n\r", command_string.c_str());
tnhnrl 62:d502889e74f1 773 break;
tnhnrl 62:d502889e74f1 774 case COMMAND_TWO:
tnhnrl 62:d502889e74f1 775 command_string += (char)incoming_byte;
tnhnrl 62:d502889e74f1 776 process_state = HEADER_117;
tnhnrl 62:d502889e74f1 777 pc().printf("DEBUG: COMMAND: [%s]\n\r", command_string.c_str());
tnhnrl 62:d502889e74f1 778
tnhnrl 62:d502889e74f1 779 // COMMAND
tnhnrl 62:d502889e74f1 780 if ( command_string.find("CT") == 0 ) { //find returns the position of the string
tnhnrl 62:d502889e74f1 781 stateMachine().setFSMCommand(CHECK_TUNING);
tnhnrl 62:d502889e74f1 782 }
tnhnrl 62:d502889e74f1 783 else if ( command_string.find("FN") == 0 ) { //find returns the position of the string
tnhnrl 62:d502889e74f1 784 stateMachine().setFSMCommand(FIND_NEUTRAL);
tnhnrl 62:d502889e74f1 785 }
tnhnrl 62:d502889e74f1 786 else if ( command_string.find("DV") == 0 ) { //find returns the position of the string
tnhnrl 62:d502889e74f1 787 stateMachine().setFSMCommand(DIVE);
tnhnrl 62:d502889e74f1 788 }
tnhnrl 62:d502889e74f1 789
tnhnrl 62:d502889e74f1 790 command_string = "";
tnhnrl 62:d502889e74f1 791
tnhnrl 62:d502889e74f1 792 // COMMAND
tnhnrl 62:d502889e74f1 793
tnhnrl 62:d502889e74f1 794 break;
tnhnrl 62:d502889e74f1 795 }
tnhnrl 62:d502889e74f1 796 //
tnhnrl 62:d502889e74f1 797 // case PACKET_NUM:
tnhnrl 62:d502889e74f1 798 // receive_packet_number = incoming_byte;
tnhnrl 62:d502889e74f1 799 // process_state = TOTAL_NUM_PACKETS;
tnhnrl 62:d502889e74f1 800 // //pc().printf("DEBUG: Case PACKET_NUM\n\r");
tnhnrl 62:d502889e74f1 801 // break;
tnhnrl 62:d502889e74f1 802 }
tnhnrl 62:d502889e74f1 803 //else {
tnhnrl 62:d502889e74f1 804 // return false;
tnhnrl 62:d502889e74f1 805 // }
tnhnrl 62:d502889e74f1 806 //
tnhnrl 62:d502889e74f1 807 // switch(process_state) {
tnhnrl 62:d502889e74f1 808 // case HEADER_117:
tnhnrl 62:d502889e74f1 809 // //continue processing
tnhnrl 62:d502889e74f1 810 // if (incoming_byte == 101){
tnhnrl 62:d502889e74f1 811 // process_state = HEADER_101;
tnhnrl 62:d502889e74f1 812 // pc().printf("DEBUG: Case 101\n\r");
tnhnrl 62:d502889e74f1 813 // }
tnhnrl 62:d502889e74f1 814 // //end transmission
tnhnrl 62:d502889e74f1 815 // else if (incoming_byte == 16) {
tnhnrl 62:d502889e74f1 816 // process_state = END_TRANSMISSION;
tnhnrl 62:d502889e74f1 817 // pc().printf("DEBUG: State 16 (END_TRANSMISSION)\n\r");
tnhnrl 62:d502889e74f1 818 // }
tnhnrl 62:d502889e74f1 819 // else {
tnhnrl 62:d502889e74f1 820 // process_state = HEADER_117; // ???
tnhnrl 62:d502889e74f1 821 // //pc().printf("DEBUG: State Header 117\n\r");
tnhnrl 62:d502889e74f1 822 // }
tnhnrl 62:d502889e74f1 823 // break;
tnhnrl 62:d502889e74f1 824 //
tnhnrl 62:d502889e74f1 825 // case HEADER_101:
tnhnrl 62:d502889e74f1 826 // if(incoming_byte == 117) {
tnhnrl 62:d502889e74f1 827 // process_state = PACKET_NUM;
tnhnrl 62:d502889e74f1 828 // pc().printf("DEBUG: Case 117\n\r");
tnhnrl 62:d502889e74f1 829 // }
tnhnrl 62:d502889e74f1 830 // break;
tnhnrl 62:d502889e74f1 831 //
tnhnrl 62:d502889e74f1 832 // case PACKET_NUM:
tnhnrl 62:d502889e74f1 833 // receive_packet_number = incoming_byte;
tnhnrl 62:d502889e74f1 834 // process_state = TOTAL_NUM_PACKETS;
tnhnrl 62:d502889e74f1 835 // //pc().printf("DEBUG: Case PACKET_NUM\n\r");
tnhnrl 62:d502889e74f1 836 // break;
tnhnrl 62:d502889e74f1 837 //
tnhnrl 62:d502889e74f1 838 // case TOTAL_NUM_PACKETS:
tnhnrl 62:d502889e74f1 839 // receive_total_number_packets = incoming_byte;
tnhnrl 62:d502889e74f1 840 // process_state = PACKET_SIZE;
tnhnrl 62:d502889e74f1 841 // //pc().printf("DEBUG: Case TOTAL_NUM_PACKETS\n\r");
tnhnrl 62:d502889e74f1 842 // break;
tnhnrl 62:d502889e74f1 843 //
tnhnrl 62:d502889e74f1 844 // case PACKET_SIZE:
tnhnrl 62:d502889e74f1 845 // receive_packet_size = incoming_byte;
tnhnrl 62:d502889e74f1 846 // //pc().printf("DEBUG: Case PACKET_SIZE\n\r");
tnhnrl 62:d502889e74f1 847 //
tnhnrl 62:d502889e74f1 848 // //write the header stuff to it
tnhnrl 62:d502889e74f1 849 // char_buffer[0] = 117;
tnhnrl 62:d502889e74f1 850 // char_buffer[1] = 101;
tnhnrl 62:d502889e74f1 851 // char_buffer[2] = receive_packet_number;
tnhnrl 62:d502889e74f1 852 // char_buffer[3] = receive_total_number_packets;
tnhnrl 62:d502889e74f1 853 // char_buffer[4] = receive_packet_size;
tnhnrl 62:d502889e74f1 854 //
tnhnrl 62:d502889e74f1 855 // break;
tnhnrl 62:d502889e74f1 856 //
tnhnrl 62:d502889e74f1 857 // case END_TRANSMISSION:
tnhnrl 62:d502889e74f1 858 // if (pc().getc() == 16) {
tnhnrl 62:d502889e74f1 859 // pc().printf("DEBUG: END_TRANSMISSION REACHED: 1. \n\r");
tnhnrl 62:d502889e74f1 860 //
tnhnrl 62:d502889e74f1 861 // if (pc().getc() == 16) {
tnhnrl 62:d502889e74f1 862 // pc().printf("DEBUG: END_TRANSMISSION REACHED: 2. \n\r");
tnhnrl 62:d502889e74f1 863 //
tnhnrl 62:d502889e74f1 864 // endReceiveData();
tnhnrl 62:d502889e74f1 865 // }
tnhnrl 62:d502889e74f1 866 // }
tnhnrl 62:d502889e74f1 867 //
tnhnrl 62:d502889e74f1 868 // pc().printf("DEBUG: END_TRANSMISSION REACHED: 5. \n\r");
tnhnrl 62:d502889e74f1 869 //
tnhnrl 62:d502889e74f1 870 // //process_state = HEADER_117; //don't do this unless the check is wrong
tnhnrl 62:d502889e74f1 871 // pc().printf("END_TRANSMISSION process_state is %d\n\r", process_state); //should be 5 (debug) 02/06/2018
tnhnrl 62:d502889e74f1 872 // data_transmission_complete = true;
tnhnrl 62:d502889e74f1 873 // break;
tnhnrl 62:d502889e74f1 874 // }//END OF SWITCH STATEMENT
tnhnrl 62:d502889e74f1 875 //
tnhnrl 62:d502889e74f1 876 // return true;
tnhnrl 62:d502889e74f1 877 }
tnhnrl 62:d502889e74f1 878
tnhnrl 62:d502889e74f1 879 int MbedLogger::sendReply() {
tnhnrl 62:d502889e74f1 880 //being explicit in what's being transmitted
tnhnrl 62:d502889e74f1 881
tnhnrl 62:d502889e74f1 882 //change this method to be more explicit later
tnhnrl 62:d502889e74f1 883
tnhnrl 62:d502889e74f1 884 //integer vector _data_packet is used here, cleared fist just in case
tnhnrl 62:d502889e74f1 885
tnhnrl 62:d502889e74f1 886 _data_packet.clear(); //same data packet for transmission
tnhnrl 62:d502889e74f1 887 _data_packet.push_back(117);
tnhnrl 62:d502889e74f1 888 _data_packet.push_back(101);
tnhnrl 62:d502889e74f1 889
tnhnrl 62:d502889e74f1 890 //_confirmed_packet_number comes from the packet number that is sent from the Python program
tnhnrl 62:d502889e74f1 891 _data_packet.push_back(_confirmed_packet_number / 256); //packet number only changed when confirmed
tnhnrl 62:d502889e74f1 892 _data_packet.push_back(_confirmed_packet_number % 256); //split into first and second byte
tnhnrl 62:d502889e74f1 893
tnhnrl 62:d502889e74f1 894 //compute checksums
tnhnrl 62:d502889e74f1 895
tnhnrl 62:d502889e74f1 896 int receiver_crc_one = calcCrcOne();
tnhnrl 62:d502889e74f1 897 int receiver_crc_two = calcCrcTwo();
tnhnrl 62:d502889e74f1 898
tnhnrl 62:d502889e74f1 899 _data_packet.push_back(receiver_crc_one);
tnhnrl 62:d502889e74f1 900 _data_packet.push_back(receiver_crc_two);
tnhnrl 62:d502889e74f1 901
tnhnrl 62:d502889e74f1 902 //transmit this packet
tnhnrl 62:d502889e74f1 903 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++) {
tnhnrl 62:d502889e74f1 904 pc().putc(*_it); //send integers over serial port one byte at a time
tnhnrl 62:d502889e74f1 905 }
tnhnrl 62:d502889e74f1 906
tnhnrl 62:d502889e74f1 907 //change process methodology later...
tnhnrl 62:d502889e74f1 908
tnhnrl 62:d502889e74f1 909 return _confirmed_packet_number;
tnhnrl 62:d502889e74f1 910 }
tnhnrl 62:d502889e74f1 911
tnhnrl 62:d502889e74f1 912 void MbedLogger::endReceiveData() { //DLE character * 4 ==> 10 10 10 10
tnhnrl 62:d502889e74f1 913 closeLogFile(); //close the file here
tnhnrl 62:d502889e74f1 914 pc().printf("endReceiveData closed the file and ended transmission\n\r");
tnhnrl 62:d502889e74f1 915 }
tnhnrl 62:d502889e74f1 916
tnhnrl 62:d502889e74f1 917 //calculate the crc with an integer array
tnhnrl 62:d502889e74f1 918 int MbedLogger::calcCrcOneArray(int *input_array, int array_length) {
tnhnrl 62:d502889e74f1 919 //can't initialize the table in the constructor in c++
tnhnrl 62:d502889e74f1 920 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};
tnhnrl 62:d502889e74f1 921 int crc = 0;
tnhnrl 62:d502889e74f1 922 for (int z = 0; z < array_length; z++) {
tnhnrl 62:d502889e74f1 923 crc = (crc_table[(input_array[z] ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF;
tnhnrl 62:d502889e74f1 924 }
tnhnrl 62:d502889e74f1 925 return crc / 256; //second-to-last byte
tnhnrl 62:d502889e74f1 926 }
tnhnrl 62:d502889e74f1 927
tnhnrl 62:d502889e74f1 928 int MbedLogger::calcCrcTwoArray(int *input_array, int array_length) {
tnhnrl 62:d502889e74f1 929 //can't initialize the table in the constructor in c++
tnhnrl 62:d502889e74f1 930 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};
tnhnrl 62:d502889e74f1 931 int crc = 0;
tnhnrl 62:d502889e74f1 932 for (int z = 0; z < array_length; z++) {
tnhnrl 62:d502889e74f1 933 crc = (crc_table[(input_array[z] ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF;
tnhnrl 62:d502889e74f1 934 }
tnhnrl 62:d502889e74f1 935 return crc % 256; //second-to-last byte
tnhnrl 62:d502889e74f1 936 }
tnhnrl 62:d502889e74f1 937
tnhnrl 62:d502889e74f1 938 int MbedLogger::calcCrcOne() {
tnhnrl 62:d502889e74f1 939 //can't initialize the table in the constructor in c++
tnhnrl 62:d502889e74f1 940 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};
tnhnrl 62:d502889e74f1 941
tnhnrl 62:d502889e74f1 942 int crc = 0;
tnhnrl 62:d502889e74f1 943 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++)
tnhnrl 62:d502889e74f1 944 crc = (crc_table[(*_it ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF;
tnhnrl 62:d502889e74f1 945
tnhnrl 62:d502889e74f1 946 return crc / 256; //second-to-last byte
tnhnrl 62:d502889e74f1 947 }
tnhnrl 62:d502889e74f1 948
tnhnrl 62:d502889e74f1 949 int MbedLogger::calcCrcTwo() {
tnhnrl 62:d502889e74f1 950 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};
tnhnrl 62:d502889e74f1 951
tnhnrl 62:d502889e74f1 952 int crc = 0;
tnhnrl 62:d502889e74f1 953 for (_it=_data_packet.begin(); _it < _data_packet.end(); _it++)
tnhnrl 62:d502889e74f1 954 crc = (crc_table[(*_it ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF;
tnhnrl 62:d502889e74f1 955
tnhnrl 62:d502889e74f1 956 //pc().printf("DEBUG: calcCrcTwo string length: %d crc: %d\n\r", input_array.length(), crc % 256);
tnhnrl 62:d502889e74f1 957
tnhnrl 62:d502889e74f1 958 return crc % 256; //last byte
tnhnrl 62:d502889e74f1 959 }
tnhnrl 62:d502889e74f1 960
tnhnrl 62:d502889e74f1 961 void MbedLogger::resetReplyPacket() {
tnhnrl 62:d502889e74f1 962 _confirmed_packet_number = 0;
tnhnrl 62:d502889e74f1 963 }
tnhnrl 62:d502889e74f1 964
tnhnrl 62:d502889e74f1 965 void MbedLogger::openNewMissionFile() {
tnhnrl 62:d502889e74f1 966 pc().printf("Opening Mission file (sequence.txt) for reception.\n\r");
tnhnrl 62:d502889e74f1 967 string filename_string = _file_system_string + "sequence.txt";
tnhnrl 62:d502889e74f1 968
tnhnrl 62:d502889e74f1 969 pc().printf("openNewMissionFile: %s\n\r", filename_string.c_str());
tnhnrl 62:d502889e74f1 970
tnhnrl 62:d502889e74f1 971 _fp = fopen(filename_string.c_str(), "w");
tnhnrl 62:d502889e74f1 972 }
tnhnrl 62:d502889e74f1 973
tnhnrl 62:d502889e74f1 974 void MbedLogger::openReceiveFile(string filename) {
tnhnrl 62:d502889e74f1 975 string filename_string = _file_system_string + filename; //example "sequence.txt"
tnhnrl 62:d502889e74f1 976
tnhnrl 62:d502889e74f1 977 _fp = fopen(filename_string.c_str(), "w"); //open a file for writing
tnhnrl 62:d502889e74f1 978 }
tnhnrl 62:d502889e74f1 979
tnhnrl 62:d502889e74f1 980 void MbedLogger::setDataCounter(int input_counter) {
tnhnrl 62:d502889e74f1 981 _transmit_counter = input_counter;
tnhnrl 62:d502889e74f1 982 }
tnhnrl 62:d502889e74f1 983
tnhnrl 62:d502889e74f1 984 void MbedLogger::closeIncompleteFile() {
tnhnrl 62:d502889e74f1 985 fprintf(_fp, "TRANSMISSION INTERRUPTED!"); //write this warning to the file
tnhnrl 62:d502889e74f1 986 closeLogFile(); //close file
tnhnrl 62:d502889e74f1 987 }
tnhnrl 62:d502889e74f1 988
tnhnrl 62:d502889e74f1 989 void MbedLogger::appendLogFile(int current_state, int option) {
tnhnrl 62:d502889e74f1 990 //option one means write to file
tnhnrl 62:d502889e74f1 991
tnhnrl 62:d502889e74f1 992 if (option == 1) {
tnhnrl 62:d502889e74f1 993 if (!_fp) { //if not present
tnhnrl 62:d502889e74f1 994 _fp = fopen(_full_file_path_string.c_str(), "a");
tnhnrl 62:d502889e74f1 995 }
tnhnrl 62:d502889e74f1 996
tnhnrl 62:d502889e74f1 997 //record data using the recordData function (takes in the state integer)
tnhnrl 62:d502889e74f1 998 recordData(current_state);
tnhnrl 62:d502889e74f1 999 }
tnhnrl 62:d502889e74f1 1000
tnhnrl 62:d502889e74f1 1001 else {
tnhnrl 62:d502889e74f1 1002 closeLogFile();
tnhnrl 62:d502889e74f1 1003 }
tnhnrl 62:d502889e74f1 1004 }
tnhnrl 62:d502889e74f1 1005
tnhnrl 62:d502889e74f1 1006 // initialize and close the file
tnhnrl 62:d502889e74f1 1007 // log file freezes at 0x0000006c
tnhnrl 62:d502889e74f1 1008 void MbedLogger::initializeLogFile() {
tnhnrl 62:d502889e74f1 1009 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 1010 pc().printf("%s file system init\n\r", _file_system_string.c_str());
tnhnrl 62:d502889e74f1 1011
tnhnrl 62:d502889e74f1 1012 //try to open this file...
tnhnrl 62:d502889e74f1 1013 _fp = fopen(file_name_string.c_str(), "r");
tnhnrl 62:d502889e74f1 1014
tnhnrl 62:d502889e74f1 1015 //if the file is empty, create this.
tnhnrl 62:d502889e74f1 1016 if (!_fp) {
tnhnrl 62:d502889e74f1 1017 _fp = fopen(file_name_string.c_str(), "w"); //write,print,close
tnhnrl 62:d502889e74f1 1018 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");
tnhnrl 62:d502889e74f1 1019 closeLogFile();
tnhnrl 62:d502889e74f1 1020 }
tnhnrl 62:d502889e74f1 1021 else
tnhnrl 62:d502889e74f1 1022 closeLogFile(); //close the opened read file
tnhnrl 62:d502889e74f1 1023 }
tnhnrl 62:d502889e74f1 1024
tnhnrl 62:d502889e74f1 1025 int MbedLogger::fileTransmitState() {
tnhnrl 62:d502889e74f1 1026 return _file_transmission_state;
tnhnrl 62:d502889e74f1 1027 }
tnhnrl 62:d502889e74f1 1028
tnhnrl 62:d502889e74f1 1029 int MbedLogger::calcCrcOneString (string input_string) {
tnhnrl 62:d502889e74f1 1030 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};
tnhnrl 62:d502889e74f1 1031
tnhnrl 62:d502889e74f1 1032 int crc = 0;
tnhnrl 62:d502889e74f1 1033 for (unsigned int i = 0; i < input_string.length(); i++) {
tnhnrl 62:d502889e74f1 1034 //convert each character to an integer
tnhnrl 62:d502889e74f1 1035 int character_to_integer = input_string[i]; //correct
tnhnrl 62:d502889e74f1 1036
tnhnrl 62:d502889e74f1 1037 crc = (crc_table[(character_to_integer ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF;
tnhnrl 62:d502889e74f1 1038 }
tnhnrl 62:d502889e74f1 1039
tnhnrl 62:d502889e74f1 1040 //pc().printf("DEBUG: calcCrcOne string length: %d crc: %d\n\r", input_string.length(), crc/256);
tnhnrl 62:d502889e74f1 1041
tnhnrl 62:d502889e74f1 1042 return crc / 256; //second-to-last byte
tnhnrl 62:d502889e74f1 1043 }
tnhnrl 62:d502889e74f1 1044
tnhnrl 62:d502889e74f1 1045 int MbedLogger::calcCrcTwoString (string input_string) {
tnhnrl 62:d502889e74f1 1046 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};
tnhnrl 62:d502889e74f1 1047
tnhnrl 62:d502889e74f1 1048 int crc = 0;
tnhnrl 62:d502889e74f1 1049 for (unsigned int i = 0; i < input_string.length(); i++) {
tnhnrl 62:d502889e74f1 1050 //convert each character to an integer
tnhnrl 62:d502889e74f1 1051 int character_to_integer = input_string[i]; //correct
tnhnrl 62:d502889e74f1 1052
tnhnrl 62:d502889e74f1 1053 crc = (crc_table[(character_to_integer ^ crc) & 0xff] ^ (crc >> 8)) & 0xFFFF;
tnhnrl 62:d502889e74f1 1054 }
tnhnrl 62:d502889e74f1 1055
tnhnrl 62:d502889e74f1 1056 //pc().printf("DEBUG: calcCrcTwo string length: %d crc: %d\n\r", input_string.length(), crc % 256);
tnhnrl 62:d502889e74f1 1057
tnhnrl 62:d502889e74f1 1058 return crc % 256; //last byte
tnhnrl 62:d502889e74f1 1059 }
tnhnrl 62:d502889e74f1 1060
tnhnrl 62:d502889e74f1 1061 int MbedLogger::testGetFileSize() {
tnhnrl 62:d502889e74f1 1062 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 1063
tnhnrl 62:d502889e74f1 1064 _fp = fopen(file_name_string.c_str(), "rb"); //open the file for reading as a binary file
tnhnrl 62:d502889e74f1 1065
tnhnrl 62:d502889e74f1 1066 fseek(_fp, 0, SEEK_END); //SEEK_END is a constant in cstdio (end of the file)
tnhnrl 62:d502889e74f1 1067 unsigned int file_size = ftell(_fp); //For binary streams, this is the number of bytes from the beginning of the file.
tnhnrl 62:d502889e74f1 1068 fseek(_fp, 0, SEEK_SET); //SEEK_SET is hte beginning of the file, not sure this is necessary
tnhnrl 62:d502889e74f1 1069
tnhnrl 62:d502889e74f1 1070 closeLogFile(); //can probably just close the file pointer and not worry about position
tnhnrl 62:d502889e74f1 1071
tnhnrl 62:d502889e74f1 1072 pc().printf("(%s) LOG000.csv file size is %d\n\r", _file_system_string.c_str(), file_size);
tnhnrl 62:d502889e74f1 1073
tnhnrl 62:d502889e74f1 1074 if (file_size == 0)
tnhnrl 62:d502889e74f1 1075 createEmptyLog(); //this is not actually a completely empty log
tnhnrl 62:d502889e74f1 1076
tnhnrl 62:d502889e74f1 1077 return file_size;
tnhnrl 62:d502889e74f1 1078
tnhnrl 62:d502889e74f1 1079 // http://www.cplusplus.com/reference/cstdio/ftell/
tnhnrl 62:d502889e74f1 1080 // https://os.mbed.com/questions/1260/How-to-read-the-LocalFileSystem-filesize/
tnhnrl 62:d502889e74f1 1081 }
tnhnrl 62:d502889e74f1 1082
tnhnrl 62:d502889e74f1 1083 void MbedLogger::createEmptyLog() {
tnhnrl 62:d502889e74f1 1084 string file_name_string = _file_system_string + "LOG000.csv";
tnhnrl 62:d502889e74f1 1085
tnhnrl 62:d502889e74f1 1086 _fp = fopen(file_name_string.c_str(), "w");
tnhnrl 62:d502889e74f1 1087 fprintf(_fp, "EMPTY LOG\n"); //just write this string to the log (processing needs a file size that is not zero)
tnhnrl 62:d502889e74f1 1088 closeLogFile();
tnhnrl 62:d502889e74f1 1089 }
tnhnrl 62:d502889e74f1 1090
tnhnrl 62:d502889e74f1 1091 int MbedLogger::getFileSize(string filename) {
tnhnrl 62:d502889e74f1 1092 // fixed the const char * errror:
tnhnrl 62:d502889e74f1 1093 // https://stackoverflow.com/questions/347949/how-to-convert-a-stdstring-to-const-char-or-char
tnhnrl 62:d502889e74f1 1094 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.
tnhnrl 62:d502889e74f1 1095 //http://www.cplusplus.com/reference/string/string/c_str/
tnhnrl 62:d502889e74f1 1096
tnhnrl 62:d502889e74f1 1097 _fp = fopen(filename.c_str(), "rb"); //open the file for reading as a binary file
tnhnrl 62:d502889e74f1 1098
tnhnrl 62:d502889e74f1 1099 fseek(_fp, 0, SEEK_END); //SEEK_END is a constant in cstdio (end of the file)
tnhnrl 62:d502889e74f1 1100 unsigned int file_size = ftell(_fp); //For binary streams, this is the number of bytes from the beginning of the file.
tnhnrl 62:d502889e74f1 1101 fseek(_fp, 0, SEEK_SET); //SEEK_SET is hte beginning of the file, not sure this is necessary
tnhnrl 62:d502889e74f1 1102
tnhnrl 62:d502889e74f1 1103 closeLogFile(); //can probably just close the file pointer and not worry about position
tnhnrl 62:d502889e74f1 1104
tnhnrl 62:d502889e74f1 1105 pc().printf("%s file size is %d\n\r", filename.c_str(), file_size);
tnhnrl 62:d502889e74f1 1106
tnhnrl 62:d502889e74f1 1107 return file_size;
tnhnrl 62:d502889e74f1 1108 }
tnhnrl 62:d502889e74f1 1109
tnhnrl 62:d502889e74f1 1110 int MbedLogger::debugFileState() {
tnhnrl 62:d502889e74f1 1111 pc().printf("What is _fp right now? %p\n\r", _fp); //pointer notation
tnhnrl 62:d502889e74f1 1112
tnhnrl 62:d502889e74f1 1113 if (_fp)
tnhnrl 62:d502889e74f1 1114 return 1; //file pointer does exist
tnhnrl 62:d502889e74f1 1115 else
tnhnrl 62:d502889e74f1 1116 return 0; //file pointer does not exist
tnhnrl 62:d502889e74f1 1117 }
tnhnrl 62:d502889e74f1 1118
tnhnrl 62:d502889e74f1 1119 void MbedLogger::specifyFileForTransmit(string input_string) {
tnhnrl 62:d502889e74f1 1120 pc().printf("specifyFileForTransmit\n\r");
tnhnrl 62:d502889e74f1 1121
tnhnrl 62:d502889e74f1 1122 string file_string = _file_system_string + input_string;
tnhnrl 62:d502889e74f1 1123
tnhnrl 62:d502889e74f1 1124 pc().printf("file_string is <%s>\n\r", file_string.c_str());
tnhnrl 62:d502889e74f1 1125
tnhnrl 62:d502889e74f1 1126 //open this file to read
tnhnrl 62:d502889e74f1 1127 _fp = fopen(file_string.c_str(), "r");
tnhnrl 62:d502889e74f1 1128
tnhnrl 62:d502889e74f1 1129 //transmit that file
tnhnrl 62:d502889e74f1 1130 //transmitDataWithTicker(); //replaced ticker
tnhnrl 62:d502889e74f1 1131
tnhnrl 62:d502889e74f1 1132 _file_transmission = true;
tnhnrl 62:d502889e74f1 1133 }
tnhnrl 62:d502889e74f1 1134
tnhnrl 62:d502889e74f1 1135 void MbedLogger::transmitFileFromDirectory( int file_number ) {
tnhnrl 62:d502889e74f1 1136 file_number = file_number + 1; //to get the correct number
tnhnrl 62:d502889e74f1 1137
tnhnrl 62:d502889e74f1 1138 DIR *dir;
tnhnrl 62:d502889e74f1 1139 struct dirent *dp; //dirent.h is the format of directory entries
tnhnrl 62:d502889e74f1 1140 int log_found =0, loop=1; //start file numbers at 1
tnhnrl 62:d502889e74f1 1141 long int temp=0;
tnhnrl 62:d502889e74f1 1142
tnhnrl 62:d502889e74f1 1143 // char * char_pointer;
tnhnrl 62:d502889e74f1 1144 // char * numstart, *numstop;
tnhnrl 62:d502889e74f1 1145
tnhnrl 62:d502889e74f1 1146 if ( NULL == (dir = opendir( _file_system_string.c_str() )) ) {
tnhnrl 62:d502889e74f1 1147 pc().printf("MBED directory could not be opened\r\n");
tnhnrl 62:d502889e74f1 1148 }
tnhnrl 62:d502889e74f1 1149 else
tnhnrl 62:d502889e74f1 1150 {
tnhnrl 62:d502889e74f1 1151 while ( NULL != (dp = readdir( dir )) )
tnhnrl 62:d502889e74f1 1152 {
tnhnrl 62:d502889e74f1 1153 pc().printf( "%d. %s (log file: %d, %d)\r\n", loop, dp->d_name,log_found,temp);
tnhnrl 62:d502889e74f1 1154
tnhnrl 62:d502889e74f1 1155 //process current file if it matches the file number
tnhnrl 62:d502889e74f1 1156 if (file_number == loop) {
tnhnrl 62:d502889e74f1 1157 char * current_file_name = dp->d_name; //pointer to this char array
tnhnrl 62:d502889e74f1 1158
tnhnrl 62:d502889e74f1 1159 specifyFileForTransmit(current_file_name);
tnhnrl 62:d502889e74f1 1160
tnhnrl 62:d502889e74f1 1161 break;
tnhnrl 62:d502889e74f1 1162 }
tnhnrl 62:d502889e74f1 1163
tnhnrl 62:d502889e74f1 1164 loop++;
tnhnrl 62:d502889e74f1 1165 }
tnhnrl 62:d502889e74f1 1166 }
tnhnrl 62:d502889e74f1 1167 }
tnhnrl 62:d502889e74f1 1168
tnhnrl 62:d502889e74f1 1169 void MbedLogger::accessMbedDirectory() {
tnhnrl 62:d502889e74f1 1170 printMbedDirectory();
tnhnrl 62:d502889e74f1 1171
tnhnrl 62:d502889e74f1 1172 pc().printf("Type in the number of the file you want to transmit.\n\r");
tnhnrl 62:d502889e74f1 1173
tnhnrl 62:d502889e74f1 1174 char message[42];
tnhnrl 62:d502889e74f1 1175
tnhnrl 62:d502889e74f1 1176 pc().scanf("%41s", message);
tnhnrl 62:d502889e74f1 1177
tnhnrl 62:d502889e74f1 1178 pc().printf("Input received!\n\r");
tnhnrl 62:d502889e74f1 1179
tnhnrl 62:d502889e74f1 1180 //check if char array is an integer
tnhnrl 62:d502889e74f1 1181 char* conversion_pointer;
tnhnrl 62:d502889e74f1 1182 long converted = strtol(message, &conversion_pointer, 10);
tnhnrl 62:d502889e74f1 1183
tnhnrl 62:d502889e74f1 1184 if (*conversion_pointer) {
tnhnrl 62:d502889e74f1 1185 //conversion failed because the input was not a number
tnhnrl 62:d502889e74f1 1186 pc().printf("NOT A VALID FILE NUMBER!\n\r");
tnhnrl 62:d502889e74f1 1187 }
tnhnrl 62:d502889e74f1 1188 else {
tnhnrl 62:d502889e74f1 1189 //conversion worked!
tnhnrl 62:d502889e74f1 1190 pc().printf("You chose file number: %d\n\r", converted);
tnhnrl 62:d502889e74f1 1191
tnhnrl 62:d502889e74f1 1192 // transmit the file
tnhnrl 62:d502889e74f1 1193 transmitFileFromDirectory(converted);
tnhnrl 62:d502889e74f1 1194 }
tnhnrl 62:d502889e74f1 1195 }
tnhnrl 62:d502889e74f1 1196
tnhnrl 62:d502889e74f1 1197 void MbedLogger::closeLogFile() {
tnhnrl 62:d502889e74f1 1198 if (_fp == NULL){
tnhnrl 62:d502889e74f1 1199 pc().printf("MbedLogger: (%s) LOG FILE WAS ALREADY CLOSED!\n\r", _file_system_string.c_str());
tnhnrl 62:d502889e74f1 1200 }
tnhnrl 62:d502889e74f1 1201
tnhnrl 62:d502889e74f1 1202 else {
tnhnrl 62:d502889e74f1 1203 pc().printf("MbedLogger: (%s) CLOSING LOG FILE!\n\r", _file_system_string.c_str());
tnhnrl 62:d502889e74f1 1204
tnhnrl 62:d502889e74f1 1205 //close file
tnhnrl 62:d502889e74f1 1206 fclose(_fp);
tnhnrl 62:d502889e74f1 1207
tnhnrl 62:d502889e74f1 1208 _fp = NULL; //set pointer to zero
tnhnrl 62:d502889e74f1 1209 }
tnhnrl 62:d502889e74f1 1210 }
tnhnrl 62:d502889e74f1 1211
tnhnrl 62:d502889e74f1 1212 void MbedLogger::activateReceivePacket() {
tnhnrl 62:d502889e74f1 1213 _mbed_receive_loop = true;
tnhnrl 62:d502889e74f1 1214 }
tnhnrl 62:d502889e74f1 1215
tnhnrl 62:d502889e74f1 1216 void MbedLogger::receiveMissionDataWithFSM() {
tnhnrl 62:d502889e74f1 1217 led4() = !led4();
tnhnrl 62:d502889e74f1 1218
tnhnrl 62:d502889e74f1 1219 checkForIncomingData();
tnhnrl 62:d502889e74f1 1220
tnhnrl 62:d502889e74f1 1221 // Example: send reply 75 65 00 00
tnhnrl 62:d502889e74f1 1222 // Example: send reply 75 65 00 01
tnhnrl 62:d502889e74f1 1223 }
tnhnrl 62:d502889e74f1 1224
tnhnrl 62:d502889e74f1 1225 void MbedLogger::receiveMissionDataWithTicker() {
tnhnrl 62:d502889e74f1 1226 openNewMissionFile(); //sequence.txt file opened
tnhnrl 62:d502889e74f1 1227
tnhnrl 62:d502889e74f1 1228 _mbed_receive_ticker.attach(callback(this, &MbedLogger::activateReceivePacket), 0.5);
tnhnrl 62:d502889e74f1 1229
tnhnrl 62:d502889e74f1 1230 pc().printf("\n\r02/09/2018 MbedLogger receiveMissionData Beginning to receive sequence data...\n\r");
tnhnrl 62:d502889e74f1 1231
tnhnrl 62:d502889e74f1 1232 resetReplyPacket(); //reset the reply packet
tnhnrl 62:d502889e74f1 1233
tnhnrl 62:d502889e74f1 1234 //idea for stopping this if data not being received
tnhnrl 62:d502889e74f1 1235 int current_packet_number = 0;
tnhnrl 62:d502889e74f1 1236 int last_packet_number = -1;
tnhnrl 62:d502889e74f1 1237 int break_transmission = 0;
tnhnrl 62:d502889e74f1 1238
tnhnrl 62:d502889e74f1 1239 while(1) {
tnhnrl 62:d502889e74f1 1240 //runs at 10 hz
tnhnrl 62:d502889e74f1 1241 if (_mbed_receive_loop) {
tnhnrl 62:d502889e74f1 1242 if (!checkForIncomingData()) { // run this until it finishes
tnhnrl 62:d502889e74f1 1243 //when you complete data reception, this will become false
tnhnrl 62:d502889e74f1 1244 pc().printf("\n\rMbedLogger: Data RECEPTION complete.\n\r");
tnhnrl 62:d502889e74f1 1245 _mbed_receive_ticker.detach();
tnhnrl 62:d502889e74f1 1246 break;
tnhnrl 62:d502889e74f1 1247 }
tnhnrl 62:d502889e74f1 1248 else {
tnhnrl 62:d502889e74f1 1249
tnhnrl 62:d502889e74f1 1250 // SEND REPLY 75 65 00 00
tnhnrl 62:d502889e74f1 1251 // SEND REPLY 75 65 00 01
tnhnrl 62:d502889e74f1 1252
tnhnrl 62:d502889e74f1 1253 //check if you keep getting the same thing
tnhnrl 62:d502889e74f1 1254 current_packet_number = sendReply();
tnhnrl 62:d502889e74f1 1255
tnhnrl 62:d502889e74f1 1256 //pc().printf("DEBUG: current packet number %d (last packet number %d) \n\r", current_packet_number, last_packet_number); //debug
tnhnrl 62:d502889e74f1 1257
tnhnrl 62:d502889e74f1 1258 //let this count up a few times before it exits
tnhnrl 62:d502889e74f1 1259 if (current_packet_number == last_packet_number) {
tnhnrl 62:d502889e74f1 1260 break_transmission++;
tnhnrl 62:d502889e74f1 1261
tnhnrl 62:d502889e74f1 1262 //break transmission after 50 failed attempts (was 100)
tnhnrl 62:d502889e74f1 1263 if (break_transmission >= 50) {
tnhnrl 62:d502889e74f1 1264 closeIncompleteFile(); //close the file
tnhnrl 62:d502889e74f1 1265 _mbed_receive_ticker.detach();
tnhnrl 62:d502889e74f1 1266 pc().printf("MbedLogger: TRANSMISSION INTERRUPTED!\n\r");
tnhnrl 62:d502889e74f1 1267 break;
tnhnrl 62:d502889e74f1 1268 }
tnhnrl 62:d502889e74f1 1269 }
tnhnrl 62:d502889e74f1 1270 else
tnhnrl 62:d502889e74f1 1271 last_packet_number = current_packet_number;
tnhnrl 62:d502889e74f1 1272 }
tnhnrl 62:d502889e74f1 1273 _mbed_receive_loop = false; // wait until the loop rate timer fires again
tnhnrl 62:d502889e74f1 1274 }
tnhnrl 62:d502889e74f1 1275 }
tnhnrl 62:d502889e74f1 1276 }
tnhnrl 62:d502889e74f1 1277
tnhnrl 62:d502889e74f1 1278 int MbedLogger::getFilePointerState() {
tnhnrl 62:d502889e74f1 1279 if (_fp)
tnhnrl 62:d502889e74f1 1280 return 1; //file is not null (has an address), open
tnhnrl 62:d502889e74f1 1281 else
tnhnrl 62:d502889e74f1 1282 return 0; //file is null, closed
tnhnrl 62:d502889e74f1 1283 }
tnhnrl 62:d502889e74f1 1284
tnhnrl 62:d502889e74f1 1285 void MbedLogger::testToggleFilePointer() {
tnhnrl 62:d502889e74f1 1286 pc().printf("testToggleFilePointer\n\r");
tnhnrl 62:d502889e74f1 1287
tnhnrl 62:d502889e74f1 1288 string file_name_string = _file_system_string + "example99.txt";
tnhnrl 62:d502889e74f1 1289
tnhnrl 62:d502889e74f1 1290 if (_fp)
tnhnrl 62:d502889e74f1 1291 _fp = NULL;
tnhnrl 62:d502889e74f1 1292 else
tnhnrl 62:d502889e74f1 1293 _fp = fopen(file_name_string.c_str(), "w");
tnhnrl 62:d502889e74f1 1294 }
tnhnrl 62:d502889e74f1 1295
tnhnrl 62:d502889e74f1 1296 int MbedLogger::getNumberOfPackets() {
tnhnrl 62:d502889e74f1 1297 return _total_number_of_packets;
tnhnrl 62:d502889e74f1 1298 }
tnhnrl 62:d502889e74f1 1299
tnhnrl 62:d502889e74f1 1300 int MbedLogger::currentPacketNumber() {
tnhnrl 62:d502889e74f1 1301 return _packet_number;
tnhnrl 62:d502889e74f1 1302 }
tnhnrl 62:d502889e74f1 1303
tnhnrl 62:d502889e74f1 1304 //only do this for the MBED because of the limited file size
tnhnrl 62:d502889e74f1 1305 //write one line to the file (open to write, this will erase all other data) and close it.
tnhnrl 62:d502889e74f1 1306 void MbedLogger::eraseFile() {
tnhnrl 62:d502889e74f1 1307 _fp = fopen(_full_file_path_string.c_str(), "w"); // LOG000.csv
tnhnrl 62:d502889e74f1 1308
tnhnrl 62:d502889e74f1 1309 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\n(file erased)\n");
tnhnrl 62:d502889e74f1 1310
tnhnrl 62:d502889e74f1 1311 closeLogFile();
tnhnrl 62:d502889e74f1 1312 }
tnhnrl 62:d502889e74f1 1313
tnhnrl 62:d502889e74f1 1314 void MbedLogger::intCreateDataPacket(int data_buffer[],int payload_length) {
tnhnrl 62:d502889e74f1 1315 // packet is 7565 0001 FFFF EEEE CC DATA DATA DATA ... CRC1 CRC2
tnhnrl 62:d502889e74f1 1316
tnhnrl 62:d502889e74f1 1317 //check here https://www.rapidtables.com/convert/number/hex-to-decimal.html?x=01c0
tnhnrl 62:d502889e74f1 1318 // ieee 754: http://www6.uniovi.es/~antonio/uned/ieee754/IEEE-754hex32.html
tnhnrl 62:d502889e74f1 1319
tnhnrl 62:d502889e74f1 1320 //CLEAR: Removes all elements from the vector (which are destroyed), leaving the container with a size of 0.
tnhnrl 62:d502889e74f1 1321 _data_packet.clear();
tnhnrl 62:d502889e74f1 1322
tnhnrl 62:d502889e74f1 1323 //DATA PACKET HEADER
tnhnrl 62:d502889e74f1 1324 _data_packet.push_back(117); //0x75
tnhnrl 62:d502889e74f1 1325 _data_packet.push_back(101); //0x65
tnhnrl 62:d502889e74f1 1326
tnhnrl 62:d502889e74f1 1327 _data_packet.push_back(_packet_number/256); //current packet number in 0x#### form
tnhnrl 62:d502889e74f1 1328 _data_packet.push_back(_packet_number%256); //current packet number in 0x#### form
tnhnrl 62:d502889e74f1 1329
tnhnrl 62:d502889e74f1 1330 _data_packet.push_back(_total_number_of_packets/256); //total number of packets, 0x#### form
tnhnrl 62:d502889e74f1 1331 _data_packet.push_back(_total_number_of_packets%256); //total number of packets, 0x#### form
tnhnrl 62:d502889e74f1 1332
tnhnrl 62:d502889e74f1 1333 _data_packet.push_back(_current_line_length);
tnhnrl 62:d502889e74f1 1334
tnhnrl 62:d502889e74f1 1335 //DATA FROM INTEGER ARRAY (read the array)
tnhnrl 62:d502889e74f1 1336 for (int i = 0; i < payload_length; i++) {
tnhnrl 62:d502889e74f1 1337 _data_packet.push_back(data_buffer[i]);
tnhnrl 62:d502889e74f1 1338 }
tnhnrl 62:d502889e74f1 1339
tnhnrl 62:d502889e74f1 1340 //CRC CALCULATIONS BELOW, character version of calculation screws up on null character 0x00, scrapped and using vector of integers
tnhnrl 62:d502889e74f1 1341 int crc_one = calcCrcOne();
tnhnrl 62:d502889e74f1 1342 int crc_two = calcCrcTwo();
tnhnrl 62:d502889e74f1 1343
tnhnrl 62:d502889e74f1 1344 //place the crc bytes into the data packet that is transmitted
tnhnrl 62:d502889e74f1 1345 _data_packet.push_back(crc_one);
tnhnrl 62:d502889e74f1 1346 _data_packet.push_back(crc_two);
tnhnrl 62:d502889e74f1 1347 }
tnhnrl 62:d502889e74f1 1348
tnhnrl 62:d502889e74f1 1349 void MbedLogger::sendStatus() {
tnhnrl 62:d502889e74f1 1350 led3() = !led3();
tnhnrl 62:d502889e74f1 1351 //readPacketInSeries() //uses this functionality
tnhnrl 62:d502889e74f1 1352
tnhnrl 62:d502889e74f1 1353 //get data depth, pitch, heading, timer
tnhnrl 62:d502889e74f1 1354
tnhnrl 62:d502889e74f1 1355 //store the data as a hex char array
tnhnrl 62:d502889e74f1 1356 char hex_char_depth[256];
tnhnrl 62:d502889e74f1 1357 char hex_char_pitch[256];
tnhnrl 62:d502889e74f1 1358 char hex_char_heading[256];
tnhnrl 62:d502889e74f1 1359 char hex_char_timer[256];
tnhnrl 62:d502889e74f1 1360
tnhnrl 62:d502889e74f1 1361 string string_hex_buffer = ""; //buffer to store the hex data as a string
tnhnrl 62:d502889e74f1 1362 string string_temp; // ELIMINATE THIS ASAP
tnhnrl 62:d502889e74f1 1363
tnhnrl 62:d502889e74f1 1364 float depth_value = depthLoop().getPosition();
tnhnrl 62:d502889e74f1 1365 float pitch_value = imu().getPitch();
tnhnrl 62:d502889e74f1 1366 float heading_value = imu().getHeading();
tnhnrl 62:d502889e74f1 1367 float timer_value = stateMachine().getTimer();
tnhnrl 62:d502889e74f1 1368
tnhnrl 62:d502889e74f1 1369 sprintf(hex_char_depth, "%08X" , *(unsigned int*)&depth_value);
tnhnrl 62:d502889e74f1 1370 sprintf(hex_char_pitch, "%08X" , *(unsigned int*)&pitch_value);
tnhnrl 62:d502889e74f1 1371 sprintf(hex_char_heading, "%08X" , *(unsigned int*)&heading_value);
tnhnrl 62:d502889e74f1 1372 sprintf(hex_char_timer, "%08X" , *(unsigned int*)&timer_value);
tnhnrl 62:d502889e74f1 1373
tnhnrl 62:d502889e74f1 1374 //store the integer values
tnhnrl 62:d502889e74f1 1375 int hex_to_int[128];
tnhnrl 62:d502889e74f1 1376
tnhnrl 62:d502889e74f1 1377 //read through hex string and break apart into chunks and save the decimal values
tnhnrl 62:d502889e74f1 1378 int hex_counter = 0;
tnhnrl 62:d502889e74f1 1379
tnhnrl 62:d502889e74f1 1380 //////////////////////////
tnhnrl 62:d502889e74f1 1381 string_hex_buffer = hex_char_depth;
tnhnrl 62:d502889e74f1 1382
tnhnrl 62:d502889e74f1 1383 for (int i = 0; i < 8; i = i+2) {
tnhnrl 62:d502889e74f1 1384 //substring starts at x substr(x, length of substring)
tnhnrl 62:d502889e74f1 1385 string_temp = string_hex_buffer.substr(i,2); // get substring from string (converted from char array)
tnhnrl 62:d502889e74f1 1386
tnhnrl 62:d502889e74f1 1387 //convoluted, fix this!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
tnhnrl 62:d502889e74f1 1388 // copying the contents of the string to char array
tnhnrl 62:d502889e74f1 1389 char temp_char_array[256];
tnhnrl 62:d502889e74f1 1390 strcpy(temp_char_array, string_temp.c_str());
tnhnrl 62:d502889e74f1 1391
tnhnrl 62:d502889e74f1 1392 //store char array hex value as decimal value
tnhnrl 62:d502889e74f1 1393 int decimal_value;
tnhnrl 62:d502889e74f1 1394 sscanf(temp_char_array,"%x",&decimal_value);
tnhnrl 62:d502889e74f1 1395
tnhnrl 62:d502889e74f1 1396 hex_to_int[hex_counter] = decimal_value;
tnhnrl 62:d502889e74f1 1397 hex_counter++; //iterate to keep up with for loop
tnhnrl 62:d502889e74f1 1398
tnhnrl 62:d502889e74f1 1399 //clear the string each time
tnhnrl 62:d502889e74f1 1400 //string_temp = "";
tnhnrl 62:d502889e74f1 1401 //cout << "string_temp CLEARED? is " << string_temp << endl;
tnhnrl 62:d502889e74f1 1402 //cout << "string_temp is " << string_temp << " and the value is " << decimal_value << endl;
tnhnrl 62:d502889e74f1 1403 }
tnhnrl 62:d502889e74f1 1404
tnhnrl 62:d502889e74f1 1405 string_hex_buffer = hex_char_pitch;
tnhnrl 62:d502889e74f1 1406
tnhnrl 62:d502889e74f1 1407 for (int i = 0; i < 8; i = i+2) {
tnhnrl 62:d502889e74f1 1408 //substring starts at x substr(x, length of substring)
tnhnrl 62:d502889e74f1 1409 string_temp = string_hex_buffer.substr(i,2);
tnhnrl 62:d502889e74f1 1410
tnhnrl 62:d502889e74f1 1411 //convoluted, fix this!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
tnhnrl 62:d502889e74f1 1412 // copying the contents of the string to char array
tnhnrl 62:d502889e74f1 1413 char temp_char_array[256];
tnhnrl 62:d502889e74f1 1414 strcpy(temp_char_array, string_temp.c_str());
tnhnrl 62:d502889e74f1 1415
tnhnrl 62:d502889e74f1 1416 //store char array hex value as decimal value
tnhnrl 62:d502889e74f1 1417 int decimal_value;
tnhnrl 62:d502889e74f1 1418 sscanf(temp_char_array,"%x",&decimal_value);
tnhnrl 62:d502889e74f1 1419
tnhnrl 62:d502889e74f1 1420 hex_to_int[hex_counter] = decimal_value;
tnhnrl 62:d502889e74f1 1421 hex_counter++; //iterate to keep up with for loop
tnhnrl 62:d502889e74f1 1422
tnhnrl 62:d502889e74f1 1423 //clear the string each time
tnhnrl 62:d502889e74f1 1424 //string_temp = "";
tnhnrl 62:d502889e74f1 1425 //cout << "string_temp CLEARED? is " << string_temp << endl;
tnhnrl 62:d502889e74f1 1426 //cout << "string_temp is " << string_temp << " and the value is " << decimal_value << endl;
tnhnrl 62:d502889e74f1 1427 }
tnhnrl 62:d502889e74f1 1428
tnhnrl 62:d502889e74f1 1429 string_hex_buffer = hex_char_heading;
tnhnrl 62:d502889e74f1 1430
tnhnrl 62:d502889e74f1 1431 for (int i = 0; i < 8; i = i+2) {
tnhnrl 62:d502889e74f1 1432 //substring starts at x substr(x, length of substring)
tnhnrl 62:d502889e74f1 1433 string_temp = string_hex_buffer.substr(i,2);
tnhnrl 62:d502889e74f1 1434
tnhnrl 62:d502889e74f1 1435 //convoluted, fix this!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
tnhnrl 62:d502889e74f1 1436 // copying the contents of the string to char array
tnhnrl 62:d502889e74f1 1437 char temp_char_array[256];
tnhnrl 62:d502889e74f1 1438 strcpy(temp_char_array, string_temp.c_str());
tnhnrl 62:d502889e74f1 1439
tnhnrl 62:d502889e74f1 1440 //store char array hex value as decimal value
tnhnrl 62:d502889e74f1 1441 int decimal_value;
tnhnrl 62:d502889e74f1 1442 sscanf(temp_char_array,"%x",&decimal_value);
tnhnrl 62:d502889e74f1 1443
tnhnrl 62:d502889e74f1 1444 hex_to_int[hex_counter] = decimal_value;
tnhnrl 62:d502889e74f1 1445 hex_counter++; //iterate to keep up with for loop
tnhnrl 62:d502889e74f1 1446
tnhnrl 62:d502889e74f1 1447 //clear the string each time
tnhnrl 62:d502889e74f1 1448 //string_temp = "";
tnhnrl 62:d502889e74f1 1449 //cout << "string_temp CLEARED? is " << string_temp << endl;
tnhnrl 62:d502889e74f1 1450 //cout << "string_temp is " << string_temp << " and the value is " << decimal_value << endl;
tnhnrl 62:d502889e74f1 1451 }
tnhnrl 62:d502889e74f1 1452
tnhnrl 62:d502889e74f1 1453 string_hex_buffer = hex_char_timer;
tnhnrl 62:d502889e74f1 1454
tnhnrl 62:d502889e74f1 1455 for (int i = 0; i < 8; i = i+2) {
tnhnrl 62:d502889e74f1 1456 //substring starts at x substr(x, length of substring)
tnhnrl 62:d502889e74f1 1457 string_temp = string_hex_buffer.substr(i,2);
tnhnrl 62:d502889e74f1 1458
tnhnrl 62:d502889e74f1 1459 //convoluted, fix this!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
tnhnrl 62:d502889e74f1 1460 // copying the contents of the string to char array
tnhnrl 62:d502889e74f1 1461 char temp_char_array[256];
tnhnrl 62:d502889e74f1 1462 strcpy(temp_char_array, string_temp.c_str());
tnhnrl 62:d502889e74f1 1463
tnhnrl 62:d502889e74f1 1464 //store char array hex value as decimal value
tnhnrl 62:d502889e74f1 1465 int decimal_value;
tnhnrl 62:d502889e74f1 1466 sscanf(temp_char_array,"%x",&decimal_value);
tnhnrl 62:d502889e74f1 1467
tnhnrl 62:d502889e74f1 1468 hex_to_int[hex_counter] = decimal_value;
tnhnrl 62:d502889e74f1 1469 hex_counter++; //iterate to keep up with for loop
tnhnrl 62:d502889e74f1 1470
tnhnrl 62:d502889e74f1 1471 //clear the string each time
tnhnrl 62:d502889e74f1 1472 //string_temp = "";
tnhnrl 62:d502889e74f1 1473 //cout << "string_temp CLEARED? is " << string_temp << endl;
tnhnrl 62:d502889e74f1 1474 //cout << "string_temp is " << string_temp << " and the value is " << decimal_value << endl;
tnhnrl 62:d502889e74f1 1475 }
tnhnrl 62:d502889e74f1 1476 //////////////////////////
tnhnrl 62:d502889e74f1 1477
tnhnrl 62:d502889e74f1 1478 //create new packet based on int array
tnhnrl 62:d502889e74f1 1479 _packet_number = 1; // TEST, FIX THIS
tnhnrl 62:d502889e74f1 1480 _total_number_of_packets = 1;
tnhnrl 62:d502889e74f1 1481 _current_line_length = 16;
tnhnrl 62:d502889e74f1 1482
tnhnrl 62:d502889e74f1 1483 intCreateDataPacket(hex_to_int,16);
tnhnrl 62:d502889e74f1 1484
tnhnrl 62:d502889e74f1 1485
tnhnrl 62:d502889e74f1 1486 transmitDataPacket();
tnhnrl 62:d502889e74f1 1487 }