Colony

/**********************************************************/

/* Serial Bootloader for Atmel megaAVR Controllers        */

/*                                                        */

/* tested with ATmega8, ATmega128 and ATmega168           */

/* should work with other mega's, see code for details    */

/*                                                        */

/* ATmegaBOOT.c                                           */

/*                                                        */

/* build: 060610                                          */

/* date : 06.10.2006                                      */

/*                                                        */

/* Monitor and debug functions were added to the original */

/* code by Dr. Erik Lins, chip45.com. (See below)         */

/* 														  */

/* Borrowed and modified for Fun with Robots by bkirby    */

/*                                                        */

/* Thanks to Karl Pitrich for fixing a bootloader pin     */

/* problem and more informative LED blinking!             */

/*                                                        */

/* For the latest version see:                            */

/* http://www.chip45.com/                                 */

/*                                                        */

/* ------------------------------------------------------ */

/*                                                        */

/* based on stk500boot.c                                  */

/* Copyright (c) 2003, Jason P. Kyle                      */

/* All rights reserved.                                   */

/* see avr1.org for original file and information         */

/*                                                        */

/* This program is free software; you can redistribute it */

/* and/or modify it under the terms of the GNU General    */

/* Public License as published by the Free Software       */

/* Foundation; either version 2 of the License, or        */

/* (at your option) any later version.                    */

/*                                                        */

/* This program is distributed in the hope that it will   */

/* be useful, but WITHOUT ANY WARRANTY; without even the  */

/* implied warranty of MERCHANTABILITY or FITNESS FOR A   */

/* PARTICULAR PURPOSE.  See the GNU General Public        */

/* License for more details.                              */

/*                                                        */

/* You should have received a copy of the GNU General     */

/* Public License along with this program; if not, write  */

/* to the Free Software Foundation, Inc.,                 */

/* 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA */

/*                                                        */

/* Licence can be viewed at                               */

/* http://www.fsf.org/licenses/gpl.txt                    */

/*                                                        */

/* Target = Atmel AVR m128,m64,m32,m16,m8,m162,m163,m169, */

/* m8515,m8535. ATmega161 has a very small boot block so  */

/* isn't supported.                                       */

/*                                                        */

/* Tested with m128,m8,m163 - feel free to let me know    */

/* how/if it works for you.                               */

/*                                                        */

/**********************************************************/

/* some includes */

#include <inttypes.h>

#include <avr/io.h>

#include <avr/pgmspace.h>

#include <avr/interrupt.h>

#include <avr/wdt.h>

#include <avr/eeprom.h>

#define F_CPU     8000000

#include <util/delay.h>

/* set the UART baud rate */

#define BAUD_RATE 57600

/* SW_MAJOR and MINOR needs to be updated from time to time to avoid warning message from AVR Studio */

/* never allow AVR Studio to do an update !!!! */

#define HW_VER	 0x02

#define SW_MAJOR 0x01

#define SW_MINOR 0x0f

/* Adjust to suit whatever pin your hardware uses to enter the bootloader */

/* ATmega128 has two UARTS so two pins are used to enter bootloader and select UART */

/* BL0... means UART0, BL1... means UART1 */

#define BL_DDR  DDRA

#define BL_PORT PORTA

#define BL_PIN  PINA

#define BL      PINA7

/* red and green channels of the tricolor*/

#define LED_DDR  DDRD

#define LED_PORT PORTD

#define LED_PIN  PIND

#define LED1     PIND4	//red

#define LED2     PIND6	//green

/* define various device id's */

/* manufacturer byte is always the same */

#define SIG1	0x1E	// Yep, Atmel is the only manufacturer of AVR micros.  Single source :(

#define SIG2	0x94

#define SIG3	0x0A

#define PAGE_SIZE	0x40U	//64 words

/* function prototypes */

void putch(char);

void putst(char *);

char getch(void);

void getNch(uint8_t);

void byte_response(uint8_t);

void nothing_response(void);

char gethex(void);

void puthex(char);

void flash_led(uint8_t);

/* some variables */

union address_union {

    uint16_t word;

    uint8_t  byte[2];

} address;

union length_union {

    uint16_t word;

    uint8_t  byte[2];

} length;

struct flags_struct {

    unsigned eeprom : 1;

    unsigned rampz  : 1;

} flags;

uint8_t buff[256];

uint8_t address_high;

uint8_t pagesz=0x80;

uint8_t i;

uint8_t bootuart = 0;

void (*app_start)(void) = 0x0000;

/* main program starts here */

int main(void) {

    uint8_t ch,ch2;

    uint16_t w;

    asm volatile("nop\n\t");

    /* set pin direction for bootloader pin and enable pullup */

    BL_DDR &= ~_BV(BL);

    BL_PORT |= _BV(BL);

    /* check if flash is programmed already, if not start bootloader anyway */

    if(pgm_read_byte_near(0x0000) != 0xFF) {

		/* run program if the button is not pressed */

		if(bit_is_set(BL_PIN, BL))

			  app_start();

    }

    /* initialize UART */

    UBRR0 = 16;

    UCSR0A = _BV(U2X0);

    UCSR0B = _BV(TXEN0)|_BV(RXEN0);

    UCSR0C = 0x06;

    /* set LED pins as output */

    LED_PORT |= _BV(LED1) | _BV(LED2);

    LED_DDR |= _BV(LED1) | _BV(LED2);

    /* flash onboard LED to signal entering of bootloader */

    flash_led(3);

    putch('\0');

    /* forever loop */

    for (;;) {

		/* get character from UART */

		ch = getch();

		/* A bunch of if...else if... gives smaller code than switch...case ! */

		/* Hello is anyone home ? */ 

		if(ch=='0') {

			nothing_response();

		}

		/* Request programmer ID */

		/* Not using PROGMEM string due to boot block in m128 being beyond 64kB boundry  */

		/* Would need to selectively manipulate RAMPZ, and it's only 9 characters anyway so who cares.  */

		else if(ch=='1') {

			if (getch() == ' ') {

			putch(0x14);

			putch('A'); putch('V'); putch('R'); putch(' ');

			putch('I'); putch('S'); putch('P'); putch(0x10);

			}

		}

		/* AVR ISP/STK500 board commands  DON'T CARE so default nothing_response */

		else if(ch=='@') {

			ch2 = getch();

			if (ch2>0x85) getch();

			nothing_response();

		}

		/* AVR ISP/STK500 board requests */

		else if(ch=='A') {

			ch2 = getch();

			if(ch2==0x80) byte_response(HW_VER);		// Hardware version

			else if(ch2==0x81) byte_response(SW_MAJOR);	// Software major version

			else if(ch2==0x82) byte_response(SW_MINOR);	// Software minor version

			else if(ch2==0x98) byte_response(0x03);		// Unknown but seems to be required by avr studio 3.56

			else byte_response(0x00);				// Covers various unnecessary responses we don't care about

		}

		/* Device Parameters  DON'T CARE, DEVICE IS FIXED  */

		else if(ch=='B') {

			getNch(20);

			nothing_response();

		}

		/* Parallel programming stuff  DON'T CARE  */

		else if(ch=='E') {

			getNch(5);

			nothing_response();

		}

		/* Enter programming mode  */

		else if(ch=='P') {

			nothing_response();

		}

		/* Leave programming mode  */

		else if(ch=='Q') {

			nothing_response();

		}

		/* Erase device, don't care as we will erase one page at a time anyway.  */

		else if(ch=='R') {

			nothing_response();

		}

		/* Set address, little endian. EEPROM in bytes, FLASH in words  */

		/* Perhaps extra address bytes may be added in future to support > 128kB FLASH.  */

		/* This might explain why little endian was used here, big endian used everywhere else.  */

		else if(ch=='U') {

			address.byte[0] = getch();

			address.byte[1] = getch();

			nothing_response();

		}

		/* Universal SPI programming command, disabled.  Would be used for fuses and lock bits.  */

		else if(ch=='V') {

			getNch(4);

			byte_response(0x00);

		}

		/* Write memory, length is big endian and is in bytes  */

		else if(ch=='d') {

			length.byte[1] = getch();

			length.byte[0] = getch();

			flags.eeprom = 0;

			if (getch() == 'E') flags.eeprom = 1;

			for (w=0;w<length.word;w++) {

				buff[w] = getch();	  // Store data in buffer, can't keep up with serial data stream whilst programming pages

			}

			if (getch() == ' ') {

				if (flags.eeprom) { //Write to EEPROM one byte at a time

					for(w=0;w<length.word;w++) {

						eeprom_write_byte((void *)address.word,buff[w]);

						address.word++;

					}			

				}

				else {	//Write to FLASH one page at a time

					if (address.byte[1]>127) address_high = 0x01;	//Only possible with m128, m256 will need 3rd address byte. FIXME

					else address_high = 0x00;

					address.word = address.word << 1;  //address * 2 -> byte location

					if ((length.byte[0] & 0x01)) length.word++;	//Even up an odd number of bytes

					cli();	//Disable interrupts, just to be sure

					while(bit_is_set(EECR,EEPE));	//Wait for previous EEPROM writes to complete

					asm volatile(

						 "clr	r17		\n\t"	//page_word_count

						 "lds	r30,address	\n\t"	//Address of FLASH location (in bytes)

						 "lds	r31,address+1	\n\t"

						 "ldi	r28,lo8(buff)	\n\t"	//Start of buffer array in RAM

						 "ldi	r29,hi8(buff)	\n\t"

						 "lds	r24,length	\n\t"	//Length of data to be written (in bytes)

						 "lds	r25,length+1	\n\t"

						 "length_loop:		\n\t"	//Main loop, repeat for number of words in block							 							 

						 "cpi	r17,0x00	\n\t"	//If page_word_count=0 then erase page

						 "brne	no_page_erase	\n\t"						 

						 "wait_spm1:		\n\t"

						 "lds	r16,%0		\n\t"	//Wait for previous spm to complete

						 "andi	r16,1           \n\t"

						 "cpi	r16,1           \n\t"

						 "breq	wait_spm1       \n\t"

						 "ldi	r16,0x03	\n\t"	//Erase page pointed to by Z

						 "sts	%0,r16		\n\t"

						 "spm			\n\t"							 

						 "wait_spm2:		\n\t"

						 "lds	r16,%0		\n\t"	//Wait for previous spm to complete

						 "andi	r16,1           \n\t"

						 "cpi	r16,1           \n\t"

						 "breq	wait_spm2       \n\t"									 

						 "ldi	r16,0x11	\n\t"	//Re-enable RWW section

						 "sts	%0,r16		\n\t"						 			 

						 "spm			\n\t"

						 "no_page_erase:		\n\t"							 

						 "ld	r0,Y+		\n\t"	//Write 2 bytes into page buffer

						 "ld	r1,Y+		\n\t"							 

						 "wait_spm3:		\n\t"

						 "lds	r16,%0		\n\t"	//Wait for previous spm to complete

						 "andi	r16,1           \n\t"

						 "cpi	r16,1           \n\t"

						 "breq	wait_spm3       \n\t"

						 "ldi	r16,0x01	\n\t"	//Load r0,r1 into FLASH page buffer

						 "sts	%0,r16		\n\t"

						 "spm			\n\t"

						 "inc	r17		\n\t"	//page_word_count++

						 "cpi r17,%1	        \n\t"

						 "brlo	same_page	\n\t"	//Still same page in FLASH

						 "write_page:		\n\t"

						 "clr	r17		\n\t"	//New page, write current one first

						 "wait_spm4:		\n\t"

						 "lds	r16,%0		\n\t"	//Wait for previous spm to complete

						 "andi	r16,1           \n\t"

						 "cpi	r16,1           \n\t"

						 "breq	wait_spm4       \n\t"						 							 

						 "ldi	r16,0x05	\n\t"	//Write page pointed to by Z

						 "sts	%0,r16		\n\t"

						 "spm			\n\t"

						 "wait_spm5:		\n\t"

						 "lds	r16,%0		\n\t"	//Wait for previous spm to complete

						 "andi	r16,1           \n\t"

						 "cpi	r16,1           \n\t"

						 "breq	wait_spm5       \n\t"									 

						 "ldi	r16,0x11	\n\t"	//Re-enable RWW section

						 "sts	%0,r16		\n\t"						 			 

						 "spm			\n\t"					 		 

						 "same_page:		\n\t"							 

						 "adiw	r30,2		\n\t"	//Next word in FLASH

						 "sbiw	r24,2		\n\t"	//length-2

						 "breq	final_write	\n\t"	//Finished

						 "rjmp	length_loop	\n\t"

						 "final_write:		\n\t"

						 "cpi	r17,0		\n\t"

						 "breq	block_done	\n\t"

						 "adiw	r24,2		\n\t"	//length+2, fool above check on length after short page write

						 "rjmp	write_page	\n\t"

						 "block_done:		\n\t"

						 "clr	__zero_reg__	\n\t"	//restore zero register

						 : "=m" (SPMCSR) : "M" (PAGE_SIZE) : "r0","r16","r17","r24","r25","r28","r29","r30","r31"

						 );

					/* Should really add a wait for RWW section to be enabled, don't actually need it since we never */

					/* exit the bootloader without a power cycle anyhow */

				}

			putch(0x14);

			putch(0x10);

			}		

		}

			/* Read memory block mode, length is big endian.  */

			else if(ch=='t') {

			length.byte[1] = getch();

			length.byte[0] = getch();

			if (getch() == 'E') flags.eeprom = 1;

			else {

			flags.eeprom = 0;

			address.word = address.word << 1;	        // address * 2 -> byte location

			}

			if (getch() == ' ') {		                // Command terminator

			putch(0x14);

			for (w=0;w < length.word;w++) {		        // Can handle odd and even lengths okay

				if (flags.eeprom) {	                        // Byte access EEPROM read

				putch(eeprom_read_byte((void *)address.word));

				address.word++;

				}

				else {

				if (!flags.rampz) putch(pgm_read_byte_near(address.word));

				address.word++;

				}

			}

			putch(0x10);

			}

		}

			/* Get device signature bytes  */

			else if(ch=='u') {

			if (getch() == ' ') {

			putch(0x14);

			putch(SIG1);

			putch(SIG2);

			putch(SIG3);

			putch(0x10);

			}

		}

			/* Read oscillator calibration byte */

			else if(ch=='v') {

			byte_response(0x00);

		}

    }

    /* end of forever loop */

}

char gethex(void) {

    char ah,al;

    ah = getch(); putch(ah);

    al = getch(); putch(al);

    if(ah >= 'a') {

	ah = ah - 'a' + 0x0a;

    } else if(ah >= '0') {

	ah -= '0';

    }

    if(al >= 'a') {

	al = al - 'a' + 0x0a;

    } else if(al >= '0') {

	al -= '0';

    }

    return (ah << 4) + al;

}

void puthex(char ch) {

    char ah,al;

    ah = (ch & 0xf0) >> 4;

    if(ah >= 0x0a) {

	ah = ah - 0x0a + 'a';

    } else {

	ah += '0';

    }

    al = (ch & 0x0f);

    if(al >= 0x0a) {

	al = al - 0x0a + 'a';

    } else {

	al += '0';

    }

    putch(ah);

    putch(al);

}

void putch(char ch)

{

    while (!(UCSR0A & _BV(UDRE0)));

    UDR0 = ch;

}

char getch(void)

{

    while(!(UCSR0A & _BV(RXC0)));

    return UDR0;

}

void getNch(uint8_t count)

{

    uint8_t i;

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

	while(!(UCSR0A & _BV(RXC0)));

	UDR0;	

    }

}

void byte_response(uint8_t val)

{

    if (getch() == ' ') {

	putch(0x14);

	putch(val);

	putch(0x10);

    }

}

void nothing_response(void)

{

    if (getch() == ' ') {

	putch(0x14);

	putch(0x10);

    }

}

void flash_led(uint8_t count)

{

    /* flash onboard LED three times to signal entering of bootloader */

    uint32_t l;

	int i;

    if (count == 0) {

      count = 3;

    }

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

	  LED_PORT |= _BV(LED1);

	  LED_PORT &= ~_BV(LED2);

	  for(l = 0; l < (15); ++l)

			_delay_ms(10);

	  LED_PORT &= ~_BV(LED1);

	  LED_PORT |= _BV(LED2);

	  for(l = 0; l < (15); ++l)

			_delay_ms(10);

    }

}

/* end of file ATmegaBOOT.c */

:103800000C943E1C0C94591C0C94591C0C94591C7F

:103810000C94591C0C94591C0C94591C0C94591C54

:103820000C94591C0C94591C0C94591C0C94591C44

:103830000C94591C0C94591C0C94591C0C94591C34

:103840000C94591C0C94591C0C94591C0C94591C24

:103850000C94591C0C94591C0C94591C0C94591C14

:103860000C94591C0C94591C0C94591C0C94591C04

:103870000C94591C0C94591C0C94591C11241FBEF7

:10388000CFEFD4E0DEBFCDBF11E0A0E0B1E0EEE8C5

:10389000FEE302C005900D92A230B107D9F712E005

:1038A000A2E0B1E001C01D92AC30B107E1F70C9489

:1038B000DB1C0C94001CEF92FF920F931F93CF938D

:1038C000DF93882309F483E060E070E0E82FFF27AE

:1038D0001E161F066CF580E2E82E8EE4F82E012DF0

:1038E000112D5C9A5E982EE030E040E050E0C70178

:1038F0000197F1F7215030404040504057FFF7CF3B

:103900005C985E9AA0E2BEE4C0E0D0E02EE030E039

:1039100040E050E0CD010197F1F7215030404040A8

:10392000504057FFF7CF6F5F7F4F6E177F07CCF286

:10393000DF91CF911F910F91FF90EF900895982FF5

:103940008091C00085FFFCCF9093C60008958091C0

:10395000C0008823E4F78091C600992787FD9095E1

:1039600008950E94A71C803209F0089584E10E9406

:103970009F1C80E10E949F1C0895CF93C82F0E9436

:10398000A71C803249F484E10E949F1C8C2F0E9466

:103990009F1C80E10E949F1CCF910895282F90E0EA

:1039A00007C08091C0008823E4F78091C6009F5F24

:1039B0009217B8F30895CFEFD4E0DEBFCDBF00007B

:1039C0000F98179AE0E0F0E084918F3F11F007998B

:1039D000E1C180E190E09093C5008093C40082E053

:1039E0008093C00088E18093C10086E08093C2008C

:1039F0008BB180658BB98AB180658AB983E00E94FA

:103A00005B1C80E00E949F1C0E94A71C803361F118

:103A1000813369F1803409F449C0813409F44FC01D

:103A2000823409F45DC0853409F460C08035E1F06A

:103A30008135D1F08235C1F0853509F45BC086351A

:103A400009F463C0843609F465C0843709F4BDC045

:103A5000853709F412C18637B9F680E00E94BD1C93

:103A60000E94A71C8033A1F60E94B11CCDCF0E94FA

:103A7000A71CC82F803241F684E10E949F1C81E47C

:103A80000E949F1C86E50E949F1C82E50E949F1C4D

:103A90008C2F0E949F1C89E40E949F1C83E50E943A

:103AA0009F1C80E50E949F1C80E1ACCF0E94A71C58

:103AB0008638D0F20E94A71C0E94B11CA5CF0E949C

:103AC000A71C803809F46CC1813809F46DC18238B3

:103AD00009F46EC1883909F683E00E94BD1CC0CF8D

:103AE00084E10E94CE1C0E94B11C8ECF85E00E9412

:103AF000CE1CF9CF0E94A71C809305010E94A71C31

:103B0000809306010E94B11C7FCF84E00E94CE1CEE

:103B100080E0A4CF0E94A71C809308020E94A71CEB

:103B20008093070280910B028E7F80930B020E948C

:103B3000A71C853409F4B3C000E010E080910702AF

:103B4000909108021816190670F4C7E0D1E00E949F

:103B5000A71C89930F5F1F4F809107029091080265

:103B600008171907A0F30E94A71C803209F04CCF58

:103B700080910B0280FF9FC000E010E0809107025F

:103B80009091080218161906E0F4A0910501B09171

:103B90000601E7E0F1E08191082E0E943B1FA09111

:103BA0000501B09106011196B0930601A09305019D

:103BB0000F5F1F4F809107029091080208171907A5

:103BC00050F384E10E949F1C6FCF0E94A71C80933A

:103BD00008020E94A71C809307020E94A71C85343C

:103BE00009F463C080910B028E7F80930B02809159

:103BF000050190910601880F991F9093060180930B

:103C000005010E94A71C803209F0FECE84E10E94CB

:103C10009F1C00E010E0209107023091080212166C

:103C2000130608F041CFA0910501B09106010EC026

:103C3000869580FFC1C01196B0930601A09305013F

:103C40000F5F1F4F0217130708F02ECF80910B0252

:103C500080FFEECF0E94331F802D0E949F1CA091F9

:103C60000501B09106011196B0930601A0930501DC

:103C70002091070230910802E3CF0E94A71C8032F6

:103C800009F0C2CE84E10E949F1C8EE10E949F1C1D

:103C900084E90E949F1C8AE00E949F1C05CF8091AE

:103CA0000B02816080930B0247CF80910B028160F1

:103CB00080930B02A6CF8091060187FD67C010920A

:103CC0000A028091050190910601880F991F909337

:103CD0000601809305018091070280FF09C0809151

:103CE00007029091080201969093080280930702C0

:103CF000F894F999FECF1127E0910501F0910601A2

:103D0000C7E0D1E08091070290910802103091F451

:103D10000091570001700130D9F303E00093570080

:103D2000E8950091570001700130D9F301E100934B

:103D30005700E895099019900091570001700130E3

:103D4000D9F301E000935700E8951395103498F0EB

:103D500011270091570001700130D9F305E000935D

:103D60005700E8950091570001700130D9F301E147

:103D700000935700E8953296029709F0C7CF1030AC

:103D800011F00296E5CF112484E11CCF81E08093ED

:103D90000A0297CFE0910201F0910301099519CE33

:103DA00082E00E94BD1C5CCE81E00E94BD1C58CE0A

:103DB0008FE00E94BD1C54CEFD0184910E949F1C87

:103DC0002091070230910802A0910501B0910601EF

:103DD00032CF1F93CF930E94A71CC82F0E949F1C15

:103DE0000E94A71C182F0E949F1CC1362CF0C7559B

:103DF00011363CF0175508C0C033D4F3C053113608

:103E0000CCF710330CF01053C295C07FC10F8C2F2C

:103E1000992787FD9095CF911F910895CF93282FD3

:103E2000992787FD9095807F9070959587959595BA

:103E3000879595958795959587958A303CF0895A11

:103E4000C22FCF70CA303CF0C95A06C0805DC22F65

:103E5000CF70CA30CCF7C05D0E949F1C8C2F0E948F

:103E60009F1CCF910895F999FECFB2BDA1BDF89ADC

:103E7000119600B40895F999FECFB2BDA1BD00BC62

:0E3E800011960FB6F894FA9AF99A0FBE0895AB

:023E8E008000B2

:0400000300003800C1

:00000001FF

# Makefile for ATmegaBOOT

# E.Lins, 18.7.2005

# version  // year month day

BUILD      = 080322

# program name should not be changed...

PROGRAM    = bayboardBOOT

# enter the product name for which you want to build the bootloader/monitor

#PRODUCT    = CRUMB8

#PRODUCT    = CRUMB128

#PRODUCT    = CRUMB168

#PRODUCT    = PROBOMEGA128

#PRODUCT    = SAVVY128

#PRODUCT    = AVRELLUM2

#PRODUCT    = FWRBOARD

#PRODUCT	= DRAGONFLY_128

PRODUCT	   = BAYBOARD

# enter the target CPU frequency

#AVR_FREQ   = F3686400

#AVR_FREQ   = F7372800

AVR_FREQ   = F8000000

#AVR_FREQ   = F14745600

#AVR_FREQ   = F16000000

#AVR_FREQ   = F20000000

# enter the parameters for the UISP isp tool

# for an stk500 at com1

ISPTOOL	   = avrisp

ISPPORT	   = usb

ISPSPEED   = -b 115200

# or an stk200 at lpt1

#ISPTOOL    = stk200

#ISPPORT    = lpt1

#ISPSPEED   = 

############################################################

# You should not have to change anything below here.

############################################################

ifeq ($(PRODUCT),CRUMB8)

MCU_TARGET = atmega8

LDSECTION  = --section-start=.text=0x1800

ISPFUSES    = avrdude -c $(ISPTOOL) -p m8 -P $(ISPPORT) $(ISPSPEED) -u -U hfuse:w:0xc8:m -U lfuse:w:0xdf:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m8 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),FWRBOARD)

MCU_TARGET = atmega168

LDSECTION  = --section-start=.text=0x3800

ISPFUSES    = ./avrdude -c $(ISPTOOL) -p m168 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xf8:m -U hfuse:w:0xdf:m -U lfuse:w:0xef:m

ISPFLASH    = ./avrdude -c $(ISPTOOL) -p m168 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM).hex

endif

ifeq ($(PRODUCT),CRUMB168)

MCU_TARGET = atmega168

LDSECTION  = --section-start=.text=0x3800

ISPFUSES    = avrdude -c $(ISPTOOL) -p m168 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xf8:m -U hfuse:w:0xd7:m -U lfuse:w:0xaf:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m168 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),AVRELLUM2)

MCU_TARGET = atmega128

LDSECTION  = --section-start=.text=0x1E000

ISPFUSES    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xff:m -U hfuse:w:0xc8:m -U lfuse:w:0xdf:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),DRAGONFLY_v3)

MCU_TARGET = atmega1281

LDSECTION  = --section-start=.text=0x1E000

ISPFUSES    = avrdude -c $(ISPTOOL) -p m1281 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xff:m -U hfuse:w:0xc8:m -U lfuse:w:0xdf:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m1281 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),DRAGONFLY_128)

MCU_TARGET = atmega128

LDSECTION  = --section-start=.text=0x1E000

ISPFUSES    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xff:m -U hfuse:w:0xc8:m -U lfuse:w:0xdf:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),CRUMB128)

MCU_TARGET = atmega128

LDSECTION  = --section-start=.text=0x1E000

ISPFUSES    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xff:m -U hfuse:w:0xc8:m -U lfuse:w:0xdf:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),PROBOMEGA128)

MCU_TARGET = atmega128

LDSECTION  = --section-start=.text=0x1E000

ISPFUSES    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xff:m -U hfuse:w:0xc8:m -U lfuse:w:0xdf:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),SAVVY128)

MCU_TARGET = atmega128

LDSECTION  = --section-start=.text=0x1E000

ISPFUSES    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xff:m -U hfuse:w:0xd8:m -U lfuse:w:0xe4:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m128 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

ifeq ($(PRODUCT),BAYBOARD)

MCU_TARGET = atmega164p

LDSECTION  = --section-start=.text=0x3800

ISPFUSES    = avrdude -c $(ISPTOOL) -p m164 -P $(ISPPORT) $(ISPSPEED) -u -U efuse:w:0xff:m -U hfuse:w:0x98:m -U lfuse:w:0xff:m

ISPFLASH    = avrdude -c $(ISPTOOL) -p m164 -P $(ISPPORT) $(ISPSPEED) -V -U flash:w:$(PROGRAM)_$(PRODUCT)_$(BUILD).hex

endif

OBJ        = $(PROGRAM).o

OPTIMIZE   = -O2

DEFS       =

LIBS       =

CC         = avr-gcc

# Override is only needed by avr-lib build system.

override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) -D$(PRODUCT) -D$(AVR_FREQ) $(DEFS)

override LDFLAGS       = -Wl,-Map,$(PROGRAM).map,$(LDSECTION)

OBJCOPY        = avr-objcopy

OBJDUMP        = avr-objdump

all: $(PROGRAM).elf lst text

isp: $(PROGRAM).hex

	$(ISPFUSES)

	$(ISPFLASH)

$(PROGRAM).elf: $(OBJ)

	$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)

clean:

	rm -rf *.o *.elf *.lst *.map *.sym *.lss *.eep

	rm -rf $(PROGRAM).hex $(PROGRAM).srec $(PROGRAM).bin

lst:  $(PROGRAM).lst

%.lst: %.elf

	$(OBJDUMP) -h -S $< > $@

# Rules for building the .text rom images

text: hex bin srec

hex:  $(PROGRAM).hex

bin:  $(PROGRAM).bin

srec: $(PROGRAM).srec

%.hex: %.elf

	$(OBJCOPY) -j .text -j .data -O ihex $< $@

	cp $@ $(PROGRAM)_$(PRODUCT)_$(AVR_FREQ)_$(BUILD).hex

%.srec: %.elf

	$(OBJCOPY) -j .text -j .data -O srec $< $@

	cp $@ $(PROGRAM)_$(PRODUCT)_$(AVR_FREQ)_$(BUILD).srec

%.bin: %.elf

	$(OBJCOPY) -j .text -j .data -O binary $< $@

	cp $@ $(PROGRAM)_$(PRODUCT)_$(AVR_FREQ)_$(BUILD).bin