/trunk/toolbox/bootloader/bootloader.c - Diff - Tooltron - Robotics Club

Revision 158

Bootloader state machine and rudimentary programming, can receive program but doesn't actually program

     #define MAX_WAIT_IN_CYCLES 800000
     #define MAX_TIMEOUT 60000        // Seconds to wait before exiting bootloader mode
     //Status LED
     #define LED_DDR  DDRB
-...
     //Function prototypes
     void flash_led(uint8_t);
     void onboard_program_write(uint32_t page, uint8_t *buf);
     void onboard_program_write(uint32_t page, uint8_t *buf, uint8_t offset);
     void (*main_start)(void) = 0x0000;
     //Variables
-...
     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];
-...
         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;
     char parse_packet(char *mbuf) {
       uint8_t r;        // Byte from the network
       uint8_t crc;      // Running checksum of the packet
       uint8_t cmd;      // The command received
       uint8_t pos;      // Position in the message buffer
       uint8_t lim;      // Max number of bytes to read into the message buf
       state_t state;    // State machine
         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);
         while ((uart_get_byte(&r)) < 0) {
             //if (count >= MAX_TIMEOUT) {
             //    return TT_BAD;
            //}
+        }
         switch (state) {
             case sd:
-...
+      }
+    }
     void send_ack(void) {
     void send_packet(uint8_t cmd) {
         uart_send_byte(DELIM);
         uart_send_byte(ADDR);
         uart_send_byte(SERVER);
         uart_send_byte(TT_ACK);
         uart_send_byte(ACK_CRC);
         uart_send_byte(cmd);
         uart_send_byte(ACK_CRC ^ cmd);
+    }
     int main(void)
+    {
         uint8_t mbuf[PROGD_PACKET_SIZE];
       uint8_t check_sum = 0;
       uint16_t i;
       uint8_t resp;
       uint16_t prog_len;
       init_uart(51); //MAGIC NUMBER??
       init_timer();
       sei();
       //set LED pin as output
       LED_DDR |= _BV(LED);
       PORTB |= _BV(LED);
       //flash onboard LED to signal entering of bootloader
       flash_led(1);
       //flash_led(1);
       //Start bootloading process
        uart_send_byte(5); //Tell the world we can be bootloaded
       send_packet(TT_BOOT);
       //Check to see if the computer responded
       uint32_t count = 0;
       uint8_t resp;
       while(uart_get_byte(&resp) == -1) {
         count++;
         if (count > MAX_WAIT_IN_CYCLES)
           //TODO: flash some leds or something
           main_start();
       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);
       /* If the computer did not respond correctly with a ACK, we jump to
        * user's program
        */
       if(resp != 6)
         main_start();
       while(1) {
         //Determine if the last received data was good or bad
         if (check_sum != 0) //If the check sum does not compute, tell computer to resend same line
         RESTART:
           uart_send_byte(7); //Ascii character BELL
         else
           uart_send_byte('T'); //Tell the computer that we are ready for the next line
         while(1) {//Wait for the computer to initiate transfer
           if (getch() == ':') break; //This is the "gimme the next chunk" command
           if (retransmit_flag == TRUE) goto RESTART;
+        }
           resp = parse_packet(mbuf);
         page_length = getch(); //Get the length of this block
         if (retransmit_flag == TRUE) goto RESTART;
         if(page_length > PAGE_SIZE) {
           while(1) {
     	flash_led(1);
+          }
+        }
         if (page_length == 'S') {//Check to see if we are done - this is the "all done" command
           //boot_rww_enable (); //Wait for any flash writes to complete?
           main_start();
+        }
         //Get the memory address at which to store this block of data
         page_address.byte[0] = getch(); if (retransmit_flag == TRUE) goto RESTART;
         page_address.byte[1] = getch(); if (retransmit_flag == TRUE) goto RESTART;
         check_sum = getch(); //Pick up the check sum for error dectection
         if (retransmit_flag == TRUE) goto RESTART;
         for(i = 0 ; i < page_length ; i++) {//Read the program data
           incoming_page_data[i] = getch();
           if (retransmit_flag == TRUE) goto RESTART;
+        }
         //Calculate the checksum
         for(i = 0 ; i < page_length ; i++)
           check_sum = check_sum + incoming_page_data[i];
         check_sum = check_sum + page_length;
         check_sum = check_sum + page_address.byte[0];
         check_sum = check_sum + page_address.byte[1];
         if(check_sum == 0) //If we have a good transmission, put it in ink
           onboard_program_write((uint32_t)page_address.word, incoming_page_data);
           //if (resp == TT_PROGD) {
           //    onboard_program_write((uint32_t)page_address.word, incoming_page_data);
           //}
           send_packet(TT_ACK);
+      }
+    }
     //#define SPM_PAGESIZE 128
     void onboard_program_write(uint32_t page, uint8_t *buf)
     void onboard_program_write(uint32_t page, uint8_t *buf, uint8_t offset)
+    {
       uint16_t i;
     	//uint8_t sreg;
     	// Disable interrupts.
     	//sreg = SREG;
     	//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){
       for (i=offset; i < SPM_PAGESIZE; i+=2){
         // Set up little-endian word.
         uint16_t w = *buf++;
-...
       boot_page_write (page);     // Store buffer in flash page.
       boot_spm_busy_wait();       // Wait until the memory is written.
     	// Reenable RWW-section again. We need this if we want to jump back
     	// to the application after bootloading.
     	//boot_rww_enable ();
     	// Re-enable interrupts (if they were ever enabled).
     	//SREG = sreg;
+    }
     char getch(void) {

Also available in: Unified diff

Project

General

Profile

Tooltron

Revision 158