xbee.cpp

00001 /////////////////////////////////////////////////////////////
00002 // APP 3                                                   //
00003 //                                                         //
00004 // Université de Sherbrooke                                //
00005 // Génie informatique                                      //
00006 // Session 5, Hiver 2017                                   //
00007 //                                                         //
00008 // Date:    14 février 2017                                //
00009 //                                                         //
00010 // Auteurs: Maxime Dupuis,       dupm2216                  //
00011 //          Bruno Allaire-Lemay, allb2701                  //
00012 /////////////////////////////////////////////////////////////
00013 
00014 #include "xbee.h"
00015 #include <cassert>
00016 
00017 DigitalOut led_1(LED1);
00018 Mail<ingoing_value_t, 30> parsed_frames;
00019 RawSerial xbee(p13, p14);
00020 Mutex mutex;
00021 DigitalOut error_led(p6);
00022 Thread error_led_thread;
00023 
00024 const int FRAME_SPECIFIC_DATA_BEGIN_BEFORE_ADDRESS[2] = {0x10, 0x01};
00025 const int FRAME_SPECIFIC_DATA_BEGIN_AFTER_ADDRESS[4] = {0xFF, 0xFE, 0x00, 0x00};
00026 const int AT_COMMAND_LED_FRAME_SPECIFIC_DATA_BEGIN[15] = {0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x02, 0x50, 0x32};
00027 const char LED_COMMAND_POWER_ON = 0x05;
00028 const char LED_COMMAND_POWER_OFF = 0x04;
00029 const int RECEIVE_PACKET_MESSAGE_START_INDEX = 15;
00030 const int RECEIVE_PACKET_SOURCE_ADDRESS_START_INDEX = 4;
00031 
00032 const char START_DELIMITER = 0x7E;
00033 
00034 bool is_character_that_needs_escape(const char character)
00035 {
00036     //printf("%X\r\n", character);
00037     switch(character)
00038     {
00039         case 0x7E: return true;
00040         case 0x7D: return true;
00041         case 0x11: return true;
00042         case 0x13: return true;
00043         default: return false;
00044     }
00045 }
00046 
00047 void send_message_via_xbee(const char* message, const int length, int address[8])
00048 {
00049     const vector<char> transmit_request = generate_transmit_request(message, length, address);
00050     
00051     mutex.lock();
00052     for(int i=0; i<transmit_request.size(); i++)
00053     {
00054         xbee.putc(transmit_request[i]);
00055     }
00056     mutex.unlock();
00057 }
00058 
00059 vector<char> generate_transmit_request(const char* message, const int length, int address[8])
00060 {
00061     vector<char> request;
00062     
00063     unsigned char checksum = 0xFF;
00064     
00065     request.push_back(START_DELIMITER);
00066     
00067     const uint16_t frame_length = 0x0E + length;
00068     const uint8_t frame_length_msb = frame_length >> 8;
00069     const uint8_t frame_length_lsb = (frame_length << 8) >> 8;
00070     request.push_back(frame_length_msb);
00071     request.push_back(frame_length_lsb);
00072     
00073     for(int i=0; i<2; i++)
00074     {
00075         request.push_back(FRAME_SPECIFIC_DATA_BEGIN_BEFORE_ADDRESS[i]);
00076         checksum -= FRAME_SPECIFIC_DATA_BEGIN_BEFORE_ADDRESS[i];
00077     }
00078     
00079     for(int i=0; i<8; i++)
00080     {
00081         request.push_back(address[i]);
00082         checksum -= address[i];
00083     }
00084     
00085     for(int i=0; i<4; i++)
00086     {
00087         request.push_back(FRAME_SPECIFIC_DATA_BEGIN_AFTER_ADDRESS[i]);
00088         checksum -= FRAME_SPECIFIC_DATA_BEGIN_AFTER_ADDRESS[i];
00089     }
00090     
00091     for(int i=0; i<length; i++)
00092     {
00093         request.push_back(message[i]);
00094         checksum -= message[i];
00095     }
00096     
00097     request.push_back(checksum);
00098     
00099     return request;
00100 }
00101 
00102 vector<char> generate_led_command(const bool power_on)
00103 {
00104     vector<char> request;
00105     
00106     unsigned char checksum = 0xFF;
00107     
00108     request.push_back(START_DELIMITER);
00109     
00110     const uint16_t frame_length = 0x10;
00111     const uint8_t frame_length_msb = frame_length >> 8;
00112     const uint8_t frame_length_lsb = (frame_length << 8) >> 8;
00113     request.push_back(frame_length_msb);
00114     request.push_back(frame_length_lsb);
00115     
00116     for(int i=0; i<15; i++)
00117     {
00118         request.push_back(AT_COMMAND_LED_FRAME_SPECIFIC_DATA_BEGIN[i]);
00119         checksum -= AT_COMMAND_LED_FRAME_SPECIFIC_DATA_BEGIN[i];
00120     }
00121     
00122     const char led_power_state = power_on ? LED_COMMAND_POWER_ON : LED_COMMAND_POWER_OFF;
00123     request.push_back(led_power_state);
00124     checksum -= led_power_state;
00125     
00126     request.push_back(checksum);
00127     
00128     return request;
00129 }
00130 
00131 void read_frame()
00132 {
00133     while(true)
00134     {
00135         while(xbee.getc() != 0x7E);
00136         
00137         vector<char> frame;
00138         
00139         frame.push_back(0x7E);
00140         
00141         const uint8_t frame_size_msb = xbee.getc();
00142         const uint8_t frame_size_lsb = xbee.getc();
00143         frame.push_back(frame_size_msb);
00144         frame.push_back(frame_size_lsb);
00145         const uint16_t frame_size = (frame_size_msb << 8) + frame_size_lsb;
00146         
00147         for(int i=0; i<frame_size + 1; i++)
00148         {
00149             frame.push_back(xbee.getc());
00150         }
00151         
00152         handle_frame(frame);
00153     }
00154 }
00155 
00156 vector<char> parse_receive_packet(const vector<char>& frame)
00157 {
00158     vector<char> message;
00159     for(int i=0; i<8; i++)
00160     {
00161         message.push_back(frame.at(RECEIVE_PACKET_SOURCE_ADDRESS_START_INDEX + i));
00162     }
00163     for(int i=0; i< frame.size() - RECEIVE_PACKET_MESSAGE_START_INDEX; i++)
00164     {
00165         message.push_back(frame.at(RECEIVE_PACKET_MESSAGE_START_INDEX + i));
00166     }
00167     return message;
00168 }
00169 
00170 vector<char> parse_transmit_status(const vector<char>& frame)
00171 {    
00172     vector<char> relevant_content;
00173 
00174     const char delivery_status = frame.at(8);    
00175     relevant_content.push_back(delivery_status);
00176     
00177     return relevant_content;
00178 }
00179 
00180 vector<char> parse_at_command_response(const vector<char>& frame)
00181 {    
00182     vector<char> relevant_content;
00183 
00184     const char command_status = frame.at(7);    
00185     relevant_content.push_back(command_status);
00186     
00187     return relevant_content;
00188 }
00189 
00190 vector<char> parse_remote_command_response(const vector<char>& frame)
00191 {    
00192     vector<char> relevant_content;
00193 
00194     const char command_status = frame.at(17);    
00195     relevant_content.push_back(command_status);
00196     
00197     return relevant_content;
00198 }
00199 
00200 void manage_error_led()
00201 {
00202     while(true)
00203     {
00204         osSignalWait(0x1, osWaitForever);
00205         error_led = 1;
00206         wait_ms(1000);
00207         error_led = 0;
00208     }
00209 }
00210 
00211 void send_blink_led_at_command(const bool toggle_current_command)
00212 {
00213     static bool is_current_command_turn_on = false;
00214     if(toggle_current_command)
00215     {
00216         is_current_command_turn_on = !is_current_command_turn_on;   
00217     }
00218     
00219     const vector<char> led_command = generate_led_command(is_current_command_turn_on);
00220     for(int i=0; i<led_command.size(); i++)
00221     {
00222         xbee.putc(led_command[i]);
00223     }
00224 }
00225 
00226 void handle_parsed_frames_from_mailbox(void const *args)
00227 {
00228     while(true)
00229     {
00230         osEvent event = parsed_frames.get();
00231         assert(event.status == osEventMail);
00232         
00233         ingoing_value_t *parsed_frame = (ingoing_value_t*)event.value.p;
00234         parse_nerfus_message(ingoing_value_to_vector(*parsed_frame), (void(*)(vector<uint8_t>, int*))args);
00235         parsed_frames.free(parsed_frame);
00236     }
00237 }
00238 
00239 vector<char> ingoing_value_to_vector(const ingoing_value_t& value)
00240 {
00241     vector<char> result;
00242     for(int i=0; i<value.size; i++)
00243     {
00244         result.push_back(value.content[i]);
00245     }
00246     return result;
00247 }
00248 
00249 void handle_frame(const vector<char>& frame)
00250 {
00251     ingoing_value_t *parsed_frame = parsed_frames.alloc();
00252     
00253     const vector<char> parsed_frame_vector = parse_frame(frame);
00254     for(int i=0; i<parsed_frame_vector.size(); i++)
00255     {
00256         parsed_frame->content[i] = parsed_frame_vector.at(i);
00257     }
00258     parsed_frame->size = parsed_frame_vector.size();
00259     
00260     parsed_frames.put(parsed_frame);
00261 }
00262 
00263 vector<char> parse_frame(const vector<char>& frame)
00264 {   
00265     vector<char> parsed_frame;
00266     
00267     const char frame_type = frame.at(3);
00268     parsed_frame.push_back(frame_type);
00269   
00270     vector<char> parsed_frame_relevant_content;
00271   
00272     switch(frame_type)
00273     {
00274         case FRAME_TYPE_RECEIVE_PACKET: 
00275         {
00276             parsed_frame_relevant_content = parse_receive_packet(frame);
00277             break;
00278         }
00279         case FRAME_TYPE_TRANSMIT_STATUS: 
00280         {
00281             parsed_frame_relevant_content = parse_transmit_status(frame);
00282             break;
00283         }
00284         case FRAME_TYPE_AT_COMMAND_RESPONSE:
00285         {
00286             parsed_frame_relevant_content = parse_at_command_response(frame);
00287             break;
00288         }
00289         case FRAME_TYPE_REMOTE_COMMAND_RESPONSE:
00290         {
00291             parsed_frame_relevant_content = parse_remote_command_response(frame);
00292             break;
00293         }
00294         default:
00295             printf("Unsupported frame:\r\n");
00296             for(int i=0; i<frame.size(); i++)
00297             {
00298                 printf("Bit #%d: %d\r\n", i, frame.at(i));
00299             }
00300     }
00301     
00302     for(vector<char>::iterator it = parsed_frame_relevant_content.begin(); it < parsed_frame_relevant_content.end(); it++)
00303     {
00304         parsed_frame.push_back(*it);
00305     }
00306     
00307     return parsed_frame;
00308 }
00309 
00310 void parse_nerfus_message(const vector<char>& parsed_frame, void (*callback)(vector<uint8_t>, int*))
00311 {    
00312     if(parsed_frame[0] == FRAME_TYPE_RECEIVE_PACKET)
00313     {
00314         int address[8];
00315         for(int i=1; i<9; i++)
00316         {
00317             address[i-1] = parsed_frame[i];
00318         }
00319         vector<uint8_t> message;
00320         for(int i=9; i<13; i++)
00321         {
00322             message.push_back(parsed_frame[i]);
00323         }
00324         callback(message, address);
00325     }
00326 }
00327 
00328 void parsed_button_event_frame_to_string(const vector<char>& parsed_frame, char* readable_string_output)
00329 {
00330     const char button_state = parsed_frame[2];
00331     switch(button_state)
00332     {
00333         case BUTTON_RELEASED:
00334             strcpy(readable_string_output, "Button state: released");
00335             break;
00336             
00337         case BUTTON_PRESSED:
00338             strcpy(readable_string_output, "Button state: pressed");
00339             break;
00340             
00341         default:
00342             strcpy(readable_string_output, "Button state: invalid state");
00343             break;
00344     }
00345 }
00346 
00347 void parsed_accelerometer_event_frame_to_string(const vector<char>& parsed_frame, char* readable_string_output)
00348 {
00349     const uint8_t x = parsed_frame[2];
00350     const uint8_t y = parsed_frame[3];
00351     const uint8_t z = parsed_frame[4];
00352     sprintf(readable_string_output, "Accelerometer state: x=0x%X, y=0x%X, z=0x%X", x, y, z);
00353 }
00354 
00355 vector<string> read_file(string path)
00356 {
00357     LocalFileSystem local("local");  
00358     vector<string> result;
00359     char buffer[128] = "";
00360     FILE *fp = fopen(path.c_str(), "r");
00361     bool ret = (fgets(buffer, 64, fp)) ;
00362     
00363     string value(buffer);
00364     string first_value = "";
00365     string second_value = "";
00366     bool which_value = true;
00367     
00368     for(int i=0; i<value.size(); i++)
00369     {
00370         if(buffer[i] == ';')
00371         {
00372             which_value = false;
00373         }
00374         else
00375         {
00376             if(which_value)
00377             {
00378                 first_value += buffer[i];
00379             }
00380             else
00381             {
00382                 second_value += buffer[i];
00383             }
00384         }
00385     }
00386     result.push_back(first_value);
00387     result.push_back(second_value);
00388     return result;
00389 }
00390 
00391 char hexa_char_to_dec(char hexa_char)
00392 {
00393     if('0' <= hexa_char && hexa_char <= '9')
00394     {
00395         return hexa_char - 48;
00396     }
00397     if('A' <= hexa_char && hexa_char <= 'F')
00398     {
00399         return hexa_char - 55;
00400     }
00401     if('a' <= hexa_char && hexa_char <= 'f')
00402     {
00403         return hexa_char - 87;
00404     }
00405     assert(false && "Wtf");
00406     return hexa_char;
00407 }
00408 
00409 vector<char> string_to_data(string pan_id)
00410 {
00411     vector<char> result;
00412     
00413     for(int i=0; i < pan_id.size(); i += 2)
00414     {
00415         const char dec_val = ( hexa_char_to_dec(pan_id[i]) ) * 16 + hexa_char_to_dec(pan_id[i]);
00416         result.push_back(dec_val);
00417     }
00418     
00419     return result;
00420 }
00421 
00422 void set_pan_id(string pan_id)
00423 {
00424     const int pan_id_beginning[7] = {0x7E, 0x00, 0x06, 0x08, 0x01, 0x49, 0x44};
00425     unsigned char checksum = 0xFF;
00426     
00427     xbee.putc(pan_id_beginning[0]);
00428     xbee.putc(pan_id_beginning[1]);
00429     xbee.putc(pan_id_beginning[2]);
00430     
00431     for(int i=3; i<7; i++)
00432     {
00433         checksum -= pan_id_beginning[i];
00434         xbee.putc(pan_id_beginning[i]);
00435     }
00436     
00437     vector<char> pan_id_char = string_to_data(pan_id);
00438     for(int i=0; i<pan_id_char.size(); i++)
00439     {
00440         checksum -= pan_id_char.at(i);
00441         xbee.putc(pan_id_char.at(i));
00442     }
00443     
00444     xbee.putc(checksum);
00445 }