File content as of revision 5:cd3c79853dc8:

#include "xbee.h"
#include <cassert>

DigitalOut led_1(LED1);
Mail<vector<char>, 30> parsed_frames;
RawSerial xbee(p13, p14);
const int FRAME_SPECIFIC_DATA_BEGIN[14] = {0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFE, 0x00, 0x00};
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};
const char LED_COMMAND_POWER_ON = 0x05;
const char LED_COMMAND_POWER_OFF = 0x04;
const int RECEIVE_PACKET_MESSAGE_START_INDEX = 15;

const char START_DELIMITER = 0x7E;

void send_message_via_xbee(const char* message, const int length)
{
    const vector<char> transmit_request = generate_transmit_request(message, length);
    
    for(int i=0; i<transmit_request.size(); i++)
    {
        xbee.putc(transmit_request[i]);
    }
}

vector<char> generate_transmit_request(const char* message, const int length)
{
    vector<char> request;
    
    unsigned char checksum = 0xFF;
    
    request.push_back(START_DELIMITER);
    
    const uint16_t frame_length = 0x0E + length;
    const uint8_t frame_length_msb = frame_length >> 8;
    const uint8_t frame_length_lsb = (frame_length << 8) >> 8;
    request.push_back(frame_length_msb);
    request.push_back(frame_length_lsb);
    
    for(int i=0; i<14; i++)
    {
        request.push_back(FRAME_SPECIFIC_DATA_BEGIN[i]);
        checksum -= FRAME_SPECIFIC_DATA_BEGIN[i];
    }
    
    for(int i=0; i<length; i++)
    {
        request.push_back(message[i]);
        checksum -= message[i];
    }
    
    request.push_back(checksum);
    
    return request;
}

vector<char> generate_led_command(const bool power_on)
{
    vector<char> request;
    
    unsigned char checksum = 0xFF;
    
    request.push_back(START_DELIMITER);
    
    const uint16_t frame_length = 0x10;
    const uint8_t frame_length_msb = frame_length >> 8;
    const uint8_t frame_length_lsb = (frame_length << 8) >> 8;
    request.push_back(frame_length_msb);
    request.push_back(frame_length_lsb);
    
    for(int i=0; i<15; i++)
    {
        request.push_back(AT_COMMAND_LED_FRAME_SPECIFIC_DATA_BEGIN[i]);
        checksum -= AT_COMMAND_LED_FRAME_SPECIFIC_DATA_BEGIN[i];
    }
    
    const char led_power_state = power_on ? LED_COMMAND_POWER_ON : LED_COMMAND_POWER_OFF;
    request.push_back(led_power_state);
    checksum -= led_power_state;
    
    request.push_back(checksum);
    
    return request;
}

void read_frame()
{
    while(true)
    {
        while(xbee.getc() != 0x7E);
        
        vector<char> frame;
        
        frame.push_back(0x7E);
        
        const uint8_t frame_size_msb = xbee.getc();
        const uint8_t frame_size_lsb = xbee.getc();
        frame.push_back(frame_size_msb);
        frame.push_back(frame_size_lsb);
        const uint16_t frame_size = (frame_size_msb << 8) + frame_size_lsb;
        
        for(int i=0; i<frame_size + 1; i++)
        {
            frame.push_back(xbee.getc());
        }
        
        handle_frame(frame);
    }
}

vector<char> parse_receive_packet(const vector<char>& frame)
{    
    vector<char>::const_iterator first = frame.begin() + RECEIVE_PACKET_MESSAGE_START_INDEX;
    vector<char>::const_iterator last = frame.end() - 1;
    vector<char> message(first, last);
    return message;
}

vector<char> parse_transmit_status(const vector<char>& frame)
{    
    vector<char> relevant_content;

    const char delivery_status = frame.at(8);    
    relevant_content.push_back(delivery_status);
    
    return relevant_content;
}

vector<char> parse_at_command_response(const vector<char>& frame)
{    
    vector<char> relevant_content;

    const char command_status = frame.at(7);    
    relevant_content.push_back(command_status);
    
    return relevant_content;
}

void handle_parsed_frames_from_mailbox()
{
    while(true)
    {
        osEvent event = parsed_frames.get();
        assert(event.status == osEventMail);
        
        vector<char> *message = (vector<char>*)event.value.p;
        
        const char parsed_frame_type = message->at(0);
        printf("Handling parsed frame. Type: %d\r\n", parsed_frame_type);
        
        printf("Relevant content: ");
        for(int i=1; i<message->size(); i++)
        {
            printf("%d\r\n", message->at(i));
        }

        parsed_frames.free(message);
    }
}

void handle_frame(const vector<char>& frame)
{
    vector<char> *parsed_frame = parsed_frames.alloc();
    *parsed_frame = parse_frame(frame);
    parsed_frames.put(parsed_frame);
}

vector<char> parse_frame(const vector<char>& frame)
{   
    vector<char> parsed_frame;
    
    const char frame_type = frame.at(3);
    parsed_frame.push_back(frame_type);
  
    vector<char> parsed_frame_relevant_content;
  
    switch(frame_type)
    {
        case FRAME_TYPE_RECEIVE_PACKET: 
        {
            parsed_frame_relevant_content = parse_receive_packet(frame);
            break;
        }
        case FRAME_TYPE_TRANSMIT_STATUS: 
        {
            parsed_frame_relevant_content = parse_transmit_status(frame);
            break;
        }
        case FRAME_TYPE_AT_COMMAND_RESPONSE:
        {
            parsed_frame_relevant_content = parse_at_command_response(frame);
            break;
        }
        default: assert(false && "Unsupported frame type");
    }
    
    for(vector<char>::iterator it = parsed_frame_relevant_content.begin(); it < parsed_frame_relevant_content.end(); it++)
    {
        parsed_frame.push_back(*it);
    }
    
    return parsed_frame;
}