can_interface.c

#include "can_interface.h"

enum Can_Bootloader_State can_bootloader_state = AWAITING_REQUEST;

uint8_t active_data_buffer_offset = 0;

uint8_t active_data_buffer = 0;

char data_buffer[2][44];

uint8_t data_buffer_length = 0;

uint8_t active_page_buffer = 0;

char page_buffer[2][SPM_PAGESIZE];

uint32_t page_count = 1;

uint8_t page_count_flag = 0;

void switch_active_data_buffer(){

  if(active_data_buffer == 0){active_data_buffer=1;}else{active_data_buffer=0;}

}

void switch_active_page_buffer(){

  if(active_page_buffer == 0){active_page_buffer=1;}else{active_page_buffer=0;}

}

int8_t buffer_can_message_data(uint8_t length, char *data){

  uint8_t len = length;

  int8_t return_value = -1;

  for(uint8_t i=1;i<len;i++){

    char tmp = *(data+i);

    if((tmp == ':') && (active_data_buffer_offset!=0)){

      return_value = active_data_buffer;

      switch_active_data_buffer();

      data_buffer_length = active_data_buffer_offset;

      active_data_buffer_offset=0;

    }

    data_buffer[active_data_buffer][active_data_buffer_offset] = tmp;

    active_data_buffer_offset++;

  }

  return return_value;

}

int8_t buffer_page_data(uint8_t length, char *data){

  static uint8_t offset = 0;

  uint8_t len = length;

  int8_t return_value = -1;

  for(uint8_t i=1;i<len;i++){

    char tmp = *(data+i);

    if(offset == (SPM_PAGESIZE-1)){

      return_value = active_data_buffer;

      switch_active_page_buffer();

      offset=0;  

    }

    data_buffer[active_page_buffer][offset] = tmp;

    offset++;

  }

  return return_value;

}

void write_bootloader_message_buffered_to_can(uint16_t length, char *input){

  static uint16_t offset = 0;

  uint8_t loops = (length / 7)+1;

  for(uint8_t i=0;i<loops;i++){

    uint8_t len = 7;

    if(i+1 == loops){

      len = length % 7;

    }

    char *data = malloc(sizeof(char)*(len+1));

    memcpy(data+1,input+offset, (size_t)len);

    data[0] = BOOTLOADER_MESSAGE;

    offset += len;

    write_message_to_can(DEVICE_ID,len+1,data);

    free(data);

    uint8_t escape_flag = 0;

    while(escape_flag == 0){

      if((PIND & (1<<PD7)) == 0){

        Message *message;

        handle_interrupt(message);

        //escape_flag = 1;

        if((message->id == 1) && (message->data[0] == BOOTLOADER_MESSAGE_CLEAR_TO_SEND)){

          escape_flag = 1;

        }

      }

    }

  }

  offset = 0;

}

static uint16_t hex2num (const uint8_t * ascii, uint8_t offset, uint8_t len)

{

    uint8_t  i;

    uint16_t val = 0;

    for (i=0; i<len; i++)

    {

        uint8_t c = *(ascii+offset+i);

        /* Hex-Ziffer auf ihren Wert abbilden */

        if (c >= '0' && c <= '9')            c -= '0';  

        else if (c >= 'A' && c <= 'F')       c -= 'A' - 10;

        else if (c >= 'a' && c <= 'f')       c -= 'a' - 10;

        val = 16 * val + c;

    }

    return val;  

}

uint8_t handle_can_message(Message *message){

  if(message->id != 1){

    return -1;

  }

  /*  switch(can_bootloader_state){

  case AWAITING_REQUEST:

    handle_can_request(message);

    break;

  case AWAITING_DATA:

    handle_can_data(message);

    break;

  }*/

  switch(message->data[0]){

  case FLASH_REQUEST:

    handle_can_request(message);

    break;

  case FLASH_DATA:

    handle_can_data(message);

    break;

  case FLASH_COMPLETE:

    handle_can_flash_complete(message);

    break;

  }

  return 0;

}

void handle_can_request(Message *message){

  if(message->data[1] == DEVICE_ID){

    char data[1] = {FLASH_REQUEST_CONFIRM};

    can_bootloader_state = WRITING_TO_CAN;

    write_message_to_can(DEVICE_ID,1,data);

    can_bootloader_state = AWAITING_DATA;

  }

}

void handle_can_data(Message *message){

  int8_t buffer = buffer_can_message_data(message->length,message->data);

  if(buffer != -1){

    /*switch(parse_hex_line(buffer)){

    case FLASH_COMPLETE:

      write_message_to_can(4,

    }*/

    write_bootloader_message_buffered_to_can(data_buffer_length,data_buffer[buffer]);

  }

  char tmp[1] = {FLASH_DATA_CLEAR_TO_SEND};

  write_message_to_can(DEVICE_ID,1,tmp);

}

void handle_can_flash_complete(Message *message){

  data_buffer[active_data_buffer][11] = '\n';

  write_bootloader_message_buffered_to_can(12,data_buffer[active_data_buffer]);

  char data[1] = {FLASH_COMPLETE_CONFIRM};

  write_message_to_can(DEVICE_ID, 1, data);

}

uint8_t parse_hex_line(uint8_t buffer){

  int hex_checksum = 0;

  uint8_t byte_count = (uint8_t)hex2num(data_buffer[buffer],1,2);

  uint16_t address = hex2num(data_buffer[buffer],3,4);

  uint8_t type = (uint8_t)hex2num(data_buffer[buffer],7,2);

  if(page_count_flag){

    page_count = address - (address % SPM_PAGESIZE);

    page_count_flag = 0;

  }

  if(type == 2){

    return FLASHED_LINE_SUCCESSFUL;

  }

  hex_checksum += byte_count;

  hex_checksum += type;

  hex_checksum += (uint8_t)address;

  hex_checksum += (uint8_t)(address >> 8);

  char *tmp_buffer = malloc(sizeof(char)*byte_count);

  for(uint8_t i=0;i<byte_count;i++){

    tmp_buffer[i] = (char)hex2num(data_buffer[buffer],9+(i*2),2);

    hex_checksum += tmp_buffer[i];

  }

  uint8_t hex_checksum_byte = hex2num(data_buffer[buffer],9+byte_count*2,2);

  hex_checksum += hex_checksum_byte;

  hex_checksum &= 0x00FF;

  if(hex_checksum != 0){

    return CHECKSUM_FAILURE;

  }

  int8_t status = buffer_page_data(byte_count,tmp_buffer);

  free(tmp_buffer);

  if(status != -1){

    //program_page((uint16_t)page_count,page_buffer[status]);

    memset(page_buffer[status], 0xFF, sizeof(page_buffer[status]));

    page_count_flag = 1;

  }

  if(type == 1){

    //program_page((uint16_t)page_count,page_buffer[active_data_buffer]);

    return FLASH_COMPLETE;

  }

  return 1;

}