Flying Sea Glider / Mbed 2 deprecated 2019_10may_firstflight_jcw_nosd

most functionality to splashdwon, find neutral and start mission. short timeouts still in code for testing, will adjust to go directly to sit_idle after splashdown

Dependencies:   mbed MODSERIAL FATFileSystem

MbedLogger/MbedLogger.cpp@74:d281aaef9766, 2018-08-14 (annotated)

Committer:
tnhnrl
Date:
Tue Aug 14 21:06:48 2018 +0000
Revision:
74:d281aaef9766
Parent:
73:f6f378311c8d
Child:
76:c802e1da4179
1) Fixed deadband on float broadcast ; 2) Fixed find neutral commands

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