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

Revision 156

Added a packet parser and ack generator to the bootloader. Also added the new mesages to the tooltron.h file

     /*
 -24-09
         Copyright Spark Fun Electronics? 2009
         Nathan Seidle
         Wireless bootloader for the ATmega168 and XBee Series 1 modules
     	This is a small (728 byte) serial bootloader designed to be a robust solution for remote reset and wireless
     	booloading. It's not extremely fast, but is very hardy.
     	The remote unit (the AVR usually) broadcasts the non-visible character ASCII(6). It then waits for a response
     	over the serial link for the non-visible character ASCII(5). If received, the remote unit enters bootloading mode.
     	If the correct character 5 is not received, the remote unit jumps to the beginning of the regular program code.
     	Bootloading includes checksum calculation, and timeouts. Timeouts is most important because a wireless
     	link does not always deliver segments of the serial stream in a deterministic fashion - a good wireless unit
     	will buffer all sorts of stuff, making the connection stream irregular in throughput.
     	This bootloader accepts a pure binary stream (not an intel hex file format). All file parsing is done on the
     	base side (usually a beefy computer with lots of extra processing ability).
     	Things I learned from testing:
     	XBee series 2.5 units have their uses, but not here. I beat my head against the wall trying to form a sensible link and failed.
     	Ultimately, plugging series 1 in, it worked wonderfully. If you need point-to-point, series 1 is wonderful. If you really
     	need true mesh node networking, Series 2.5 is good.
     	XBee Series 2.5 ships with CTS enabled! That's why the AT commands through hyperterminal were not working. Grr.
     	To get a Series 2.5 link to work, you must configure device on XBee Explorer as Coordinator, and the device in your arduino board as the end device.
     	Trying to use Series 2.5 for a good point-to-point link:
     	With CTS Enabled, 19200bps, Packetization Timeout at 3 (default), still bit errors, even with 1ms delay between characters
     	With CTS Enabled, 19200bps, Packetization Timeout at 0, with 1ms delay between characters helps a lot, but will get character errors if there is RF interferance (units further than a few feet apart)
     	With CTS/RTS Enabled, 19200bps, Packet timeout at 0, no delay but with flow control, we have very solid link -> one way!
     	while( (PIND & (1<<CTS)) != 0); //Don't send anything to the XBee, it is thinking
     	You do not seem to need CTS/RTS/DTR to read or program an XBee.
     	With XB24-ZB unit, the end device can transmit all it wants, the coordinator seems to die after a few seconds. This
     	was the ultimate downfall of the series 2.5 for me. The link would work, but the coordinator would drop off after a few
     	seconds? Series 1 did not do this.
     	All of the following code works exceptionally well with Series 1 "XB24" "XBee 802.15.4" "v10CD" firmware
     	To configure the XBees, follow "Lady Ada wireless arduino" info
     	Series 1 module settings:
     	Baud: 19200
     	No flow control (CTS is left on as default)
     	No change to packetization timeout (default = 3?)
     	RTS on XBee board goes up and down with the com advanced trick NOT checked, and hardware control turned ON under terminal
     	In VB, turn handshaking off. When RTSEnable = True, the RTS pin goes low, resetting the AVR
     	Wireless:
 seconds to load 14500 code words (most of the space) at 38400 / 8MHz (internal osc)
 seconds to load 14500 code words (most of the space) at 19200 / 8MHz (internal osc)
     	Wired:
 seconds to load 14500 code words (most of the space) at 19200 / 8MHz (internal osc)
     	so you see, there is no benefit to a higher baud rate. The XBee protocol is the bottleneck
     	How to read the flash contents to file :
     	avrdude -c stk200 -p m168 -P lpt1 -Uflash:r:bl.hex:i
     	This will dump the current flash contents of an AVR to a read-able hex file called "bl.hex". This
     	was very helpful when testing whether flash writing was actually working.
     	Oh, and if you happen to be using an XBee with a UFL antenna connector (and don't have a UFL antenna sitting around)
     	you can convert it to a wire antenna simply by soldering in a short wire into the XBee. It may not be the best,
     	but it works.
     */
     #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
     //Status LED
-...
     char getch(void);
     typedef enum {
         sd,
         src,
         dest,
         comd,
         read,
         cs,
         ack
     } state_t;
     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
       while (1) {
         // Wait for the next byte
         while ((uart_get_byte(&r)) < 0);
         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_ack(void) {
         uart_send_byte(DELIM);
         uart_send_byte(ADDR);
         uart_send_byte(SERVER);
         uart_send_byte(TT_ACK);
         uart_send_byte(ACK_CRC);
+    }
     int main(void)
+    {
       uint8_t check_sum = 0;
-...
       //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)

Also available in: Unified diff

Project

General

Profile

Tooltron

Revision 156