Tooltron

#include <avr/io.h>

#include <util/delay.h>

#include <avr/boot.h>

#include "tooltron.h"

#include "uart.h"

#define TRUE        0

#define FALSE        1

#define ADDR    18

#define MAX_WAIT_IN_CYCLES 800000

#define MAX_TIMEOUT 60000        // Seconds to wait before exiting bootloader mode

#define MAIN_ADDR 0x400

//Status LED

#define LED_DDR  DDRB

#define LED_PORT PORTB

#define LED      PORTB1

//#define PAGE_SIZE 32

//Function prototypes

void flash_led(uint8_t);

void onboard_program_write(uint16_t page, uint8_t *buf);

void (*main_start)(void) = MAIN_ADDR;

//Variables

uint8_t incoming_page_data[PAGE_SIZE];

uint8_t page_length;

uint8_t retransmit_flag = FALSE;

uint8_t sec;

uint8_t min;

union page_address_union {

  uint16_t word;

  uint8_t  byte[2];

} page_address;

typedef enum {

    sd,

    src,

    dest,

    comd,

    read,

    cs,

    ack

} state_t;

void init_timer(void) {

    // Clear timmer on OCRA1 Compare match

    // No prescale

    TCCR1B |= _BV(WGM12) | _BV(CS12);

    // 1 second @ 8MHz clock

    OCR1AH =0x7A;

    OCR1AL =0x12;

    TIMSK = _BV(OCIE1A);

    sec = 0;

    min = 0;

}

void reset_timer(void) {

    sec = 0;

    min = 0;

}

ISR(TIMER1_COMPA_vect) {

    if (sec == 59) {

        sec = 0;

        min++;

    } else {

        sec++;

    }

}

char parse_packet(uint8_t *mbuf) {

  uint8_t r = 0;        // Byte from the network

  uint8_t crc = 0;      // Running checksum of the packet

  uint8_t cmd = 0;      // The command received

  uint8_t pos = 0;      // Position in the message buffer

  uint8_t lim = 0;      // Max number of bytes to read into the message buf

  state_t state = sd;    // State machine

    uint16_t count;

  //reset_timer();

  count = 0;

  while (1) {

    // Wait for the next byte

    while ((uart_get_byte(&r)) < 0) {

        if (count >= MAX_TIMEOUT) {

            return TT_BAD;

       }

    }

    switch (state) {

        case sd:

            if (r == DELIM) {

                state = src;

            }

            break;

        case src:

            if (r == DELIM) {

                state = src;

            } else {

                crc = r;

                state = dest;

            }

            break;

        case dest:

            if (r == DELIM) {

                state = src;

            } else if (r == ADDR) {

                crc ^= r;

                state = comd;

            } else {

                state = sd;

            }

            break;

        case comd:

            cmd = r;

            crc ^= r;

            if (r == DELIM) {

                state = src;

            } else if (r == TT_PROGM) {

                lim = PROGM_PACKET_SIZE;

                state = read;

            } else if (r == TT_PROGD) {

                lim = PROGD_PACKET_SIZE;

                state = read;

            } else {

                state = cs;

            }

            break;

        case read:

            mbuf[pos] = r;

            crc ^= r;

            pos++;

            if (pos == lim) {

                state = cs;

            }

            break;

        case cs:

            if (r == crc) {

                return cmd;

            } else {

                return TT_BAD;

            }

            break;

        default:

            return TT_BAD;

    }

  }

}

void send_packet(uint8_t cmd) {

    uart_send_byte(DELIM);

    uart_send_byte(ADDR);

    uart_send_byte(SERVER);

    uart_send_byte(cmd);

    uart_send_byte(ACK_CRC ^ cmd);

}

int main(void)

{

    uint8_t mbuf[PROGD_PACKET_SIZE];

  uint16_t caddr = MAIN_ADDR;

  uint8_t resp;

  uint16_t prog_len = 0;

  init_uart(51); //MAGIC NUMBER??

  init_timer();

  sei();

  //set LED pin as output

  LED_DDR |= 0x07;

  PORTB = 0x07;

  //Start bootloading process

  send_packet(TT_BOOT);

  resp = parse_packet(mbuf);

  if (resp == TT_PROGM) {

    prog_len = mbuf[0];

    prog_len |= mbuf[1] << 8;

  } else {

      //while(1) {

      //    flash_led(1);

      //}

      main_start();

  }

  send_packet(TT_ACK);

  while(1) {

      resp = parse_packet(mbuf);

      if (resp == TT_PROGD) {

          onboard_program_write(caddr, mbuf);

          caddr += PROGD_PACKET_SIZE;

      } else {

          while(1) {

              flash_led(1);

          }

      }

      send_packet(TT_ACK);

      if (prog_len <= PROGD_PACKET_SIZE) {

          send_packet(TT_ACK);

          //while(1) {

             PORTB = 0;

          //}

          main_start();

      } else { 

          prog_len -= PROGD_PACKET_SIZE;

      }

  }

}

//#define SPM_PAGESIZE 32

void onboard_program_write(uint16_t page, uint8_t *buf)

{

  uint16_t i;

  cli();

  //eeprom_busy_wait();

  boot_page_erase (page);

  boot_spm_busy_wait ();      // Wait until the memory is erased.

  for (i=0; i < SPM_PAGESIZE; i+=2){

    // Set up little-endian word.

    //uint16_t w = *buf++;

    //w += (*buf++) << 8;

    boot_page_fill (i, buf[i] | (buf[i+1] <<8));

  }

  boot_page_write (page);     // Store buffer in flash page.

  boot_spm_busy_wait();       // Wait until the memory is written.

  sei();

}

void flash_led(uint8_t count)

{

        uint8_t i;

        for (i = 0; i < count; ++i) {

                LED_PORT |= _BV(LED);

                _delay_ms(100);

                LED_PORT &= ~_BV(LED);

                _delay_ms(100);

        }

}