WarL0ck/hardware
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'Rmodule'

Browse Source
This commit is contained in:
WarL0ck 2013-12-09 21:03:40 +07:00
commit 0e7e27b644
46 changed files with 5642 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
README.md Normal file → Executable file
View File

1
Rmodule/Rmodule.aps Executable file
View File

@ -0,0 +1 @@
<AVRStudio><MANAGEMENT><ProjectName>Rmodule</ProjectName><Created>14-Nov-2013 11:48:57</Created><LastEdit>18-Nov-2013 21:18:20</LastEdit><ICON>241</ICON><ProjectType>0</ProjectType><Created>14-Nov-2013 11:48:57</Created><Version>4</Version><Build>4, 19, 0, 730</Build><ProjectTypeName>AVR GCC</ProjectTypeName></MANAGEMENT><CODE_CREATION><ObjectFile>default\Rmodule.elf</ObjectFile><EntryFile></EntryFile><SaveFolder>c:\Hard\Rmodule\</SaveFolder></CODE_CREATION><DEBUG_TARGET><CURRENT_TARGET>AVR Simulator</CURRENT_TARGET><CURRENT_PART>ATmega8.xml</CURRENT_PART><BREAKPOINTS></BREAKPOINTS><IO_EXPAND><HIDE>false</HIDE></IO_EXPAND><REGISTERNAMES><Register>R00</Register><Register>R01</Register><Register>R02</Register><Register>R03</Register><Register>R04</Register><Register>R05</Register><Register>R06</Register><Register>R07</Register><Register>R08</Register><Register>R09</Register><Register>R10</Register><Register>R11</Register><Register>R12</Register><Register>R13</Register><Register>R14</Register><Register>R15</Register><Register>R16</Register><Register>R17</Register><Register>R18</Register><Register>R19</Register><Register>R20</Register><Register>R21</Register><Register>R22</Register><Register>R23</Register><Register>R24</Register><Register>R25</Register><Register>R26</Register><Register>R27</Register><Register>R28</Register><Register>R29</Register><Register>R30</Register><Register>R31</Register></REGISTERNAMES><COM>Auto</COM><COMType>0</COMType><WATCHNUM>0</WATCHNUM><WATCHNAMES><Pane0></Pane0><Pane1></Pane1><Pane2></Pane2><Pane3></Pane3></WATCHNAMES><BreakOnTrcaeFull>0</BreakOnTrcaeFull></DEBUG_TARGET><Debugger><Triggers></Triggers></Debugger><AVRGCCPLUGIN><FILES><SOURCEFILE>main.c</SOURCEFILE><SOURCEFILE>uart\uart.c</SOURCEFILE><SOURCEFILE>onewire\onewire.c</SOURCEFILE><SOURCEFILE>C:\Hard\Git\Rmodule\uart\uart_addon.c</SOURCEFILE><HEADERFILE>uart\uart.h</HEADERFILE><HEADERFILE>res\strings.h</HEADERFILE><HEADERFILE>onewire\onewire.h</HEADERFILE><HEADERFILE>C:\Hard\Git\Rmodule\uart\uart_addon.h</HEADERFILE><OTHERFILE>default\Rmodule.lss</OTHERFILE><OTHERFILE>default\Rmodule.map</OTHERFILE></FILES><CONFIGS><CONFIG><NAME>default</NAME><USESEXTERNALMAKEFILE>NO</USESEXTERNALMAKEFILE><EXTERNALMAKEFILE></EXTERNALMAKEFILE><PART>atmega8</PART><HEX>1</HEX><LIST>1</LIST><MAP>1</MAP><OUTPUTFILENAME>Rmodule.elf</OUTPUTFILENAME><OUTPUTDIR>default\</OUTPUTDIR><ISDIRTY>1</ISDIRTY><OPTIONS><OPTION><FILE>main.c</FILE><OPTIONLIST></OPTIONLIST></OPTION></OPTIONS><INCDIRS/><LIBDIRS/><LIBS/><LINKOBJECTS/><OPTIONSFORALL>-Wall -gdwarf-2 -std=gnu99 -DF_CPU=8000000UL -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums</OPTIONSFORALL><LINKEROPTIONS></LINKEROPTIONS><SEGMENTS/></CONFIG></CONFIGS><LASTCONFIG>default</LASTCONFIG><USES_WINAVR>1</USES_WINAVR><GCC_LOC>C:\Program Files\Atmel\AVR Tools\AVR Toolchain\bin\avr-gcc.exe</GCC_LOC><MAKE_LOC>C:\Program Files\Atmel\AVR Tools\AVR Toolchain\bin\make.exe</MAKE_LOC></AVRGCCPLUGIN><ProjectFiles><Files><Name>c:\Hard\Rmodule\uart\uart.h</Name><Name>c:\Hard\Rmodule\res\strings.h</Name><Name>c:\Hard\Rmodule\onewire\onewire.h</Name><Name>C:\Hard\Git\Rmodule\uart\uart_addon.h</Name><Name>c:\Hard\Rmodule\main.c</Name><Name>c:\Hard\Rmodule\uart\uart.c</Name><Name>c:\Hard\Rmodule\onewire\onewire.c</Name><Name>C:\Hard\Git\Rmodule\uart\uart_addon.c</Name></Files></ProjectFiles><IOView><usergroups/><sort sorted="0" column="0" ordername="0" orderaddress="0" ordergroup="0"/></IOView><Files><File00000><FileId>00000</FileId><FileName>main.c</FileName><Status>1</Status></File00000><File00001><FileId>00001</FileId><FileName>res\strings.h</FileName><Status>1</Status></File00001></Files><Events><Bookmarks></Bookmarks></Events><Trace><Filters></Filters></Trace></AVRStudio>

86
Rmodule/default/Makefile Executable file
View File

@ -0,0 +1,86 @@
###############################################################################
# Makefile for the project Rmodule
###############################################################################
## General Flags
PROJECT = Rmodule
MCU = atmega8
TARGET = Rmodule.elf
CC = avr-gcc
CPP = avr-g++
## Options common to compile, link and assembly rules
COMMON = -mmcu=$(MCU)
## Compile options common for all C compilation units.
CFLAGS = $(COMMON)
CFLAGS += -Wall -gdwarf-2 -std=gnu99 -DF_CPU=8000000UL -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
CFLAGS += -MD -MP -MT $(*F).o -MF dep/$(@F).d
## Assembly specific flags
ASMFLAGS = $(COMMON)
ASMFLAGS += $(CFLAGS)
ASMFLAGS += -x assembler-with-cpp -Wa,-gdwarf2
## Linker flags
LDFLAGS = $(COMMON)
LDFLAGS += -Wl,-Map=Rmodule.map
## Intel Hex file production flags
HEX_FLASH_FLAGS = -R .eeprom -R .fuse -R .lock -R .signature
HEX_EEPROM_FLAGS = -j .eeprom
HEX_EEPROM_FLAGS += --set-section-flags=.eeprom="alloc,load"
HEX_EEPROM_FLAGS += --change-section-lma .eeprom=0 --no-change-warnings
## Objects that must be built in order to link
OBJECTS = main.o uart.o onewire.o uart_addon.o
## Objects explicitly added by the user
LINKONLYOBJECTS =
## Build
all: $(TARGET) Rmodule.hex Rmodule.eep Rmodule.lss size
## Compile
main.o: ../main.c
$(CC) $(INCLUDES) $(CFLAGS) -c $<
uart.o: ../uart/uart.c
$(CC) $(INCLUDES) $(CFLAGS) -c $<
onewire.o: ../onewire/onewire.c
$(CC) $(INCLUDES) $(CFLAGS) -c $<
uart_addon.o: ../../Git/Rmodule/uart/uart_addon.c
$(CC) $(INCLUDES) $(CFLAGS) -c $<
##Link
$(TARGET): $(OBJECTS)
$(CC) $(LDFLAGS) $(OBJECTS) $(LINKONLYOBJECTS) $(LIBDIRS) $(LIBS) -o $(TARGET)
%.hex: $(TARGET)
avr-objcopy -O ihex $(HEX_FLASH_FLAGS) $< $@
%.eep: $(TARGET)
-avr-objcopy $(HEX_EEPROM_FLAGS) -O ihex $< $@ || exit 0
%.lss: $(TARGET)
avr-objdump -h -S $< > $@
size: ${TARGET}
@echo
@avr-size -C --mcu=${MCU} ${TARGET}
## Clean target
.PHONY: clean
clean:
-rm -rf $(OBJECTS) Rmodule.elf dep/* Rmodule.hex Rmodule.eep Rmodule.lss Rmodule.map
## Other dependencies
-include $(shell mkdir dep 2>NUL) $(wildcard dep/*)

83
Rmodule/main.c Executable file
View File

@ -0,0 +1,83 @@
// Ïðîøèâêà äëÿ óäàëåííîãî ðàäèîìîäóëÿ
#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include "uart/uart.h"
#include "uart/uart_addon.h"
#include "onewire/onewire.h"
#include "res/strings.h"
#define UART_BAUD_RATE 19200
unsigned char get_uart_char(void){
unsigned int res;
do{
res = uart_getc();
} while(res & UART_NO_DATA);
return (unsigned char) res;
}
static int get_uart_line(char *pbuf, int len_ln){
int i = 0;
unsigned char c;
len_ln=len_ln-1;
while((c=get_uart_char()) != 0x0D && i<len_ln){
uart_putc(c);
pbuf[i] = c;
i=i+1;
}
pbuf[i] = '\0';
return i;
}
void getListDevices(void){
uint8_t i;
uint8_t id[OW_ROMCODE_SIZE];
uint8_t diff, nSensors;
uart_puts_p(ScanStr);
ow_reset();
nSensors = 0;
diff = OW_SEARCH_FIRST;
while ( diff != OW_LAST_DEVICE) {
diff = ow_rom_search( diff, &id[0] );
if ( diff != OW_PRESENCE_ERR && diff != OW_DATA_ERR) {
for ( i=0; i < OW_ROMCODE_SIZE; i++ ){
uart_puthex_byte(id[i]);
uart_putc(' ');
}
uart_puts(CRLF);
}
nSensors++;
}
uart_put_int(nSensors);
}
int main(void){
uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU));
#ifndef OW_ONE_BUS
ow_set_bus(&PIND,&PORTD,&DDRD,PD6);
#endif
sei();
char cmd[5];
unsigned int len_line=0;
while(1){
uart_puts_p(CmdPrompt);
len_line=get_uart_line(&cmd[0],sizeof(cmd));
if (len_line>0){
if (strcmp_P(cmd, CmdLD)==0){
getListDevices();
}
if (strcmp_P(cmd, CmdHelp)==0){
uart_puts_p(HelpTitle);
uart_puts_p(HelpItem1);
uart_puts_p(HelpItem2);
}
}
}
}

63
Rmodule/onewire/crc8.c Executable file
View File

@ -0,0 +1,63 @@
/* please read copyright-notice at EOF */
#include <stdint.h>
#define CRC8INIT 0x00
#define CRC8POLY 0x18 //0X18 = X^8+X^5+X^4+X^0
uint8_t crc8( uint8_t *data, uint16_t number_of_bytes_in_data )
{
uint8_t crc;
uint16_t loop_count;
uint8_t bit_counter;
uint8_t b;
uint8_t feedback_bit;
crc = CRC8INIT;
for (loop_count = 0; loop_count != number_of_bytes_in_data; loop_count++)
{
b = data[loop_count];
bit_counter = 8;
do {
feedback_bit = (crc ^ b) & 0x01;
if ( feedback_bit == 0x01 ) {
crc = crc ^ CRC8POLY;
}
crc = (crc >> 1) & 0x7F;
if ( feedback_bit == 0x01 ) {
crc = crc | 0x80;
}
b = b >> 1;
bit_counter--;
} while (bit_counter > 0);
}
return crc;
}
/*
This code is from Colin O'Flynn - Copyright (c) 2002
only minor changes by M.Thomas 9/2004
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

40
Rmodule/onewire/crc8.h Executable file
View File

@ -0,0 +1,40 @@
#ifndef CRC8_H_
#define CRC8_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
uint8_t crc8( uint8_t* data, uint16_t number_of_bytes_in_data );
#ifdef __cplusplus
}
#endif
#endif
/*
This is based on code from :
Copyright (c) 2002 Colin O'Flynn
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

287
Rmodule/onewire/onewire.c Executable file
View File

@ -0,0 +1,287 @@
/*
Access Dallas 1-Wire Devices with ATMEL AVRs
Author of the initial code: Peter Dannegger (danni(at)specs.de)
modified by Martin Thomas (mthomas(at)rhrk.uni-kl.de)
9/2004 - use of delay.h, optional bus configuration at runtime
10/2009 - additional delay in ow_bit_io for recovery
5/2010 - timing modifcations, additonal config-values and comments,
use of atomic.h macros, internal pull-up support
7/2010 - added method to skip recovery time after last bit transfered
via ow_command_skip_last_recovery
*/
#include <avr/io.h>
#include <util/delay.h>
#include <util/atomic.h>
#include "onewire.h"
#ifdef OW_ONE_BUS
#define OW_GET_IN() ( OW_IN & (1<<OW_PIN))
#define OW_OUT_LOW() ( OW_OUT &= (~(1 << OW_PIN)) )
#define OW_OUT_HIGH() ( OW_OUT |= (1 << OW_PIN) )
#define OW_DIR_IN() ( OW_DDR &= (~(1 << OW_PIN )) )
#define OW_DIR_OUT() ( OW_DDR |= (1 << OW_PIN) )
#else
/* set bus-config with ow_set_bus() */
uint8_t OW_PIN_MASK;
volatile uint8_t* OW_IN;
volatile uint8_t* OW_OUT;
volatile uint8_t* OW_DDR;
#define OW_GET_IN() ( *OW_IN & OW_PIN_MASK )
#define OW_OUT_LOW() ( *OW_OUT &= (uint8_t) ~OW_PIN_MASK )
#define OW_OUT_HIGH() ( *OW_OUT |= (uint8_t) OW_PIN_MASK )
#define OW_DIR_IN() ( *OW_DDR &= (uint8_t) ~OW_PIN_MASK )
#define OW_DIR_OUT() ( *OW_DDR |= (uint8_t) OW_PIN_MASK )
void ow_set_bus(volatile uint8_t* in,
volatile uint8_t* out,
volatile uint8_t* ddr,
uint8_t pin)
{
OW_DDR=ddr;
OW_OUT=out;
OW_IN=in;
OW_PIN_MASK = (1 << pin);
ow_reset();
}
#endif
uint8_t ow_input_pin_state()
{
return OW_GET_IN();
}
void ow_parasite_enable(void)
{
OW_OUT_HIGH();
OW_DIR_OUT();
}
void ow_parasite_disable(void)
{
OW_DIR_IN();
#if (!OW_USE_INTERNAL_PULLUP)
OW_OUT_LOW();
#endif
}
uint8_t ow_reset(void)
{
uint8_t err;
OW_OUT_LOW();
OW_DIR_OUT(); // pull OW-Pin low for 480us
_delay_us(480);
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
// set Pin as input - wait for clients to pull low
OW_DIR_IN(); // input
#if OW_USE_INTERNAL_PULLUP
OW_OUT_HIGH();
#endif
_delay_us(64); // was 66
err = OW_GET_IN(); // no presence detect
// if err!=0: nobody pulled to low, still high
}
// after a delay the clients should release the line
// and input-pin gets back to high by pull-up-resistor
_delay_us(480 - 64); // was 480-66
if( OW_GET_IN() == 0 ) {
err = 1; // short circuit, expected low but got high
}
return err;
}
/* Timing issue when using runtime-bus-selection (!OW_ONE_BUS):
The master should sample at the end of the 15-slot after initiating
the read-time-slot. The variable bus-settings need more
cycles than the constant ones so the delays had to be shortened
to achive a 15uS overall delay
Setting/clearing a bit in I/O Register needs 1 cyle in OW_ONE_BUS
but around 14 cyles in configureable bus (us-Delay is 4 cyles per uS) */
static uint8_t ow_bit_io_intern( uint8_t b, uint8_t with_parasite_enable )
{
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
#if OW_USE_INTERNAL_PULLUP
OW_OUT_LOW();
#endif
OW_DIR_OUT(); // drive bus low
_delay_us(2); // T_INT > 1usec accoding to timing-diagramm
if ( b ) {
OW_DIR_IN(); // to write "1" release bus, resistor pulls high
#if OW_USE_INTERNAL_PULLUP
OW_OUT_HIGH();
#endif
}
// "Output data from the DS18B20 is valid for 15usec after the falling
// edge that initiated the read time slot. Therefore, the master must
// release the bus and then sample the bus state within 15ussec from
// the start of the slot."
_delay_us(15-2-OW_CONF_DELAYOFFSET);
if( OW_GET_IN() == 0 ) {
b = 0; // sample at end of read-timeslot
}
_delay_us(60-15-2+OW_CONF_DELAYOFFSET);
#if OW_USE_INTERNAL_PULLUP
OW_OUT_HIGH();
#endif
OW_DIR_IN();
if ( with_parasite_enable ) {
ow_parasite_enable();
}
} /* ATOMIC_BLOCK */
_delay_us(OW_RECOVERY_TIME); // may be increased for longer wires
return b;
}
uint8_t ow_bit_io( uint8_t b )
{
return ow_bit_io_intern( b & 1, 0 );
}
uint8_t ow_byte_wr( uint8_t b )
{
uint8_t i = 8, j;
do {
j = ow_bit_io( b & 1 );
b >>= 1;
if( j ) {
b |= 0x80;
}
} while( --i );
return b;
}
uint8_t ow_byte_wr_with_parasite_enable( uint8_t b )
{
uint8_t i = 8, j;
do {
if ( i != 1 ) {
j = ow_bit_io_intern( b & 1, 0 );
} else {
j = ow_bit_io_intern( b & 1, 1 );
}
b >>= 1;
if( j ) {
b |= 0x80;
}
} while( --i );
return b;
}
uint8_t ow_byte_rd( void )
{
// read by sending only "1"s, so bus gets released
// after the init low-pulse in every slot
return ow_byte_wr( 0xFF );
}
uint8_t ow_rom_search( uint8_t diff, uint8_t *id )
{
uint8_t i, j, next_diff;
uint8_t b;
if( ow_reset() ) {
return OW_PRESENCE_ERR; // error, no device found <--- early exit!
}
ow_byte_wr( OW_SEARCH_ROM ); // ROM search command
next_diff = OW_LAST_DEVICE; // unchanged on last device
i = OW_ROMCODE_SIZE * 8; // 8 bytes
do {
j = 8; // 8 bits
do {
b = ow_bit_io( 1 ); // read bit
if( ow_bit_io( 1 ) ) { // read complement bit
if( b ) { // 0b11
return OW_DATA_ERR; // data error <--- early exit!
}
}
else {
if( !b ) { // 0b00 = 2 devices
if( diff > i || ((*id & 1) && diff != i) ) {
b = 1; // now 1
next_diff = i; // next pass 0
}
}
}
ow_bit_io( b ); // write bit
*id >>= 1;
if( b ) {
*id |= 0x80; // store bit
}
i--;
} while( --j );
id++; // next byte
} while( i );
return next_diff; // to continue search
}
static void ow_command_intern( uint8_t command, uint8_t *id, uint8_t with_parasite_enable )
{
uint8_t i;
ow_reset();
if( id ) {
ow_byte_wr( OW_MATCH_ROM ); // to a single device
i = OW_ROMCODE_SIZE;
do {
ow_byte_wr( *id );
id++;
} while( --i );
}
else {
ow_byte_wr( OW_SKIP_ROM ); // to all devices
}
if ( with_parasite_enable ) {
ow_byte_wr_with_parasite_enable( command );
} else {
ow_byte_wr( command );
}
}
void ow_command( uint8_t command, uint8_t *id )
{
ow_command_intern( command, id, 0);
}
void ow_command_with_parasite_enable( uint8_t command, uint8_t *id )
{
ow_command_intern( command, id, 1 );
}

93
Rmodule/onewire/onewire.h Executable file
View File

@ -0,0 +1,93 @@
#ifndef ONEWIRE_H_
#define ONEWIRE_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
/*******************************************/
/* Hardware connection */
/*******************************************/
/* Define OW_ONE_BUS if only one 1-Wire-Bus is used
in the application -> shorter code.
If not defined make sure to call ow_set_bus() before using
a bus. Runtime bus-select increases code size by around 300
bytes so use OW_ONE_BUS if possible */
// #define OW_ONE_BUS
#ifdef OW_ONE_BUS
#define OW_PIN PD6
#define OW_IN PIND
#define OW_OUT PORTD
#define OW_DDR DDRD
#define OW_CONF_DELAYOFFSET 0
#else
#if ( F_CPU < 1843200 )
#warning | Experimental multi-bus-mode is not tested for
#warning | frequencies below 1,84MHz. Use OW_ONE_WIRE or
#warning | faster clock-source (i.e. internal 2MHz R/C-Osc.).
#endif
#define OW_CONF_CYCLESPERACCESS 13
#define OW_CONF_DELAYOFFSET ( (uint16_t)( ((OW_CONF_CYCLESPERACCESS) * 1000000L) / F_CPU ) )
#endif
// Recovery time (T_Rec) minimum 1usec - increase for long lines
// 5 usecs is a value give in some Maxim AppNotes
// 30u secs seem to be reliable for longer lines
//#define OW_RECOVERY_TIME 5 /* usec */
//#define OW_RECOVERY_TIME 300 /* usec */
#define OW_RECOVERY_TIME 10 /* usec */
// Use AVR's internal pull-up resistor instead of external 4,7k resistor.
// Based on information from Sascha Schade. Experimental but worked in tests
// with one DS18B20 and one DS18S20 on a rather short bus (60cm), where both
// sensores have been parasite-powered.
#define OW_USE_INTERNAL_PULLUP 1 /* 0=external, 1=internal */
/*******************************************/
#define OW_MATCH_ROM 0x55
#define OW_SKIP_ROM 0xCC
#define OW_SEARCH_ROM 0xF0
#define OW_SEARCH_FIRST 0xFF // start new search
#define OW_PRESENCE_ERR 0xFF
#define OW_DATA_ERR 0xFE
#define OW_LAST_DEVICE 0x00 // last device found
// rom-code size including CRC
#define OW_ROMCODE_SIZE 8
extern uint8_t ow_reset(void);
extern uint8_t ow_bit_io( uint8_t b );
extern uint8_t ow_byte_wr( uint8_t b );
extern uint8_t ow_byte_rd( void );
extern uint8_t ow_rom_search( uint8_t diff, uint8_t *id );
extern void ow_command( uint8_t command, uint8_t *id );
extern void ow_command_with_parasite_enable( uint8_t command, uint8_t *id );
extern void ow_parasite_enable( void );
extern void ow_parasite_disable( void );
extern uint8_t ow_input_pin_state( void );
#ifndef OW_ONE_BUS
extern void ow_set_bus( volatile uint8_t* in,
volatile uint8_t* out,
volatile uint8_t* ddr,
uint8_t pin );
#endif
#ifdef __cplusplus
}
#endif
#endif

17
Rmodule/res/strings.h Executable file
View File

@ -0,0 +1,17 @@
#include <avr/pgmspace.h>
#define CRLF "\r\n"
//
const char CmdLD[] PROGMEM = "ld";
const char CmdHelp[] PROGMEM = "h";
// Ñïèñîê êîìàíä
const char HelpTitle[] PROGMEM = CRLF "Command list:";
const char HelpItem1[] PROGMEM = CRLF "ld - List devices";
const char HelpItem2[] PROGMEM = CRLF "h - Show this help";
const char CmdPrompt[] PROGMEM = CRLF "$ ";
// Ðàçíûå íóæíûå ñòðîêè
const char ScanStr[] PROGMEM = CRLF "Scanning 1-wire bus" CRLF;

1
Rmodule/rmodule.aws Executable file
View File

@ -0,0 +1 @@
<AVRWorkspace><IOSettings><CurrentRegisters/></IOSettings><part name="ATMEGA8"/><Files><File00000 Name="c:\Hard\Rmodule\main.c" Position="262 96 1079 803" LineCol="18 1" State="Maximized"/><File00001 Name="c:\Hard\Rmodule\res\strings.h" Position="288 145 895 613" LineCol="12 40" State="Maximized"/></Files></AVRWorkspace>

663
Rmodule/uart/uart.c Executable file
View File

@ -0,0 +1,663 @@
/*************************************************************************
Title: Interrupt UART library with receive/transmit circular buffers
Author: Peter Fleury <pfleury@gmx.ch> http://jump.to/fleury
File: $Id: uart.c,v 1.10 2013/06/02 07:27:04 peter Exp $
Software: AVR-GCC 4.1, AVR Libc 1.4.6 or higher
Hardware: any AVR with built-in UART,
License: GNU General Public License
DESCRIPTION:
An interrupt is generated when the UART has finished transmitting or
receiving a byte. The interrupt handling routines use circular buffers
for buffering received and transmitted data.
The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE variables define
the buffer size in bytes. Note that these variables must be a
power of 2.
USAGE:
Refere to the header file uart.h for a description of the routines.
See also example test_uart.c.
NOTES:
Based on Atmel Application Note AVR306
LICENSE:
Copyright (C) 2006 Peter Fleury
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
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.
*************************************************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include "uart.h"
/*
* constants and macros
*/
/* size of RX/TX buffers */
#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1)
#define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1)
#if ( UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK )
#error RX buffer size is not a power of 2
#endif
#if ( UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK )
#error TX buffer size is not a power of 2
#endif
#if defined(__AVR_AT90S2313__) \
|| defined(__AVR_AT90S4414__) || defined(__AVR_AT90S4434__) \
|| defined(__AVR_AT90S8515__) || defined(__AVR_AT90S8535__) \
|| defined(__AVR_ATmega103__)
/* old AVR classic or ATmega103 with one UART */
#define AT90_UART
#define UART0_RECEIVE_INTERRUPT UART_RX_vect
#define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect
#define UART0_STATUS USR
#define UART0_CONTROL UCR
#define UART0_DATA UDR
#define UART0_UDRIE UDRIE
#elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__)
/* old AVR classic with one UART */
#define AT90_UART
#define UART0_RECEIVE_INTERRUPT UART_RX_vect
#define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect
#define UART0_STATUS UCSRA
#define UART0_CONTROL UCSRB
#define UART0_DATA UDR
#define UART0_UDRIE UDRIE
#elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \
|| defined(__AVR_ATmega323__)
/* ATmega with one USART */
#define ATMEGA_USART
#define UART0_RECEIVE_INTERRUPT USART_RXC_vect
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_STATUS UCSRA
#define UART0_CONTROL UCSRB
#define UART0_DATA UDR
#define UART0_UDRIE UDRIE
#elif defined (__AVR_ATmega8515__) || defined(__AVR_ATmega8535__)
#define ATMEGA_USART
#define UART0_RECEIVE_INTERRUPT USART_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_STATUS UCSRA
#define UART0_CONTROL UCSRB
#define UART0_DATA UDR
#define UART0_UDRIE UDRIE
#elif defined(__AVR_ATmega163__)
/* ATmega163 with one UART */
#define ATMEGA_UART
#define UART0_RECEIVE_INTERRUPT UART_RX_vect
#define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect
#define UART0_STATUS UCSRA
#define UART0_CONTROL UCSRB
#define UART0_DATA UDR
#define UART0_UDRIE UDRIE
#elif defined(__AVR_ATmega162__)
/* ATmega with two USART */
#define ATMEGA_USART0
#define ATMEGA_USART1
#define UART0_RECEIVE_INTERRUPT USART0_RXC_vect
#define UART1_RECEIVE_INTERRUPT USART1_RXC_vect
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect
#define UART0_STATUS UCSR0A
#define UART0_CONTROL UCSR0B
#define UART0_DATA UDR0
#define UART0_UDRIE UDRIE0
#define UART1_STATUS UCSR1A
#define UART1_CONTROL UCSR1B
#define UART1_DATA UDR1
#define UART1_UDRIE UDRIE1
#elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__)
/* ATmega with two USART */
#define ATMEGA_USART0
#define ATMEGA_USART1
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART1_RECEIVE_INTERRUPT USART1_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect
#define UART0_STATUS UCSR0A
#define UART0_CONTROL UCSR0B
#define UART0_DATA UDR0
#define UART0_UDRIE UDRIE0
#define UART1_STATUS UCSR1A
#define UART1_CONTROL UCSR1B
#define UART1_DATA UDR1
#define UART1_UDRIE UDRIE1
#elif defined(__AVR_ATmega161__)
/* ATmega with UART */
#error "AVR ATmega161 currently not supported by this libaray !"
#elif defined(__AVR_ATmega169__)
/* ATmega with one USART */
#define ATMEGA_USART
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART0_STATUS UCSRA
#define UART0_CONTROL UCSRB
#define UART0_DATA UDR
#define UART0_UDRIE UDRIE
#elif defined(__AVR_ATmega48__) || defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega48P__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__) \
|| defined(__AVR_ATmega3250__) || defined(__AVR_ATmega3290__) ||defined(__AVR_ATmega6450__) || defined(__AVR_ATmega6490__)
/* ATmega with one USART */
#define ATMEGA_USART0
#define UART0_RECEIVE_INTERRUPT USART_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_STATUS UCSR0A
#define UART0_CONTROL UCSR0B
#define UART0_DATA UDR0
#define UART0_UDRIE UDRIE0
#elif defined(__AVR_ATtiny2313__)
#define ATMEGA_USART
#define UART0_RECEIVE_INTERRUPT USART_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_STATUS UCSRA
#define UART0_CONTROL UCSRB
#define UART0_DATA UDR
#define UART0_UDRIE UDRIE
#elif defined(__AVR_ATmega329__) || \
defined(__AVR_ATmega649__) || \
defined(__AVR_ATmega325__) || \
defined(__AVR_ATmega645__)
/* ATmega with one USART */
#define ATMEGA_USART0
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART0_STATUS UCSR0A
#define UART0_CONTROL UCSR0B
#define UART0_DATA UDR0
#define UART0_UDRIE UDRIE0
#elif defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega640__)
/* ATmega with two USART */
#define ATMEGA_USART0
#define ATMEGA_USART1
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART1_RECEIVE_INTERRUPT USART1_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect
#define UART0_STATUS UCSR0A
#define UART0_CONTROL UCSR0B
#define UART0_DATA UDR0
#define UART0_UDRIE UDRIE0
#define UART1_STATUS UCSR1A
#define UART1_CONTROL UCSR1B
#define UART1_DATA UDR1
#define UART1_UDRIE UDRIE1
#elif defined(__AVR_ATmega644__)
/* ATmega with one USART */
#define ATMEGA_USART0
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART0_STATUS UCSR0A
#define UART0_CONTROL UCSR0B
#define UART0_DATA UDR0
#define UART0_UDRIE UDRIE0
#elif defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__)
/* ATmega with two USART */
#define ATMEGA_USART0
#define ATMEGA_USART1
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART1_RECEIVE_INTERRUPT USART1_RX_vect
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect
#define UART0_STATUS UCSR0A
#define UART0_CONTROL UCSR0B
#define UART0_DATA UDR0
#define UART0_UDRIE UDRIE0
#define UART1_STATUS UCSR1A
#define UART1_CONTROL UCSR1B
#define UART1_DATA UDR1
#define UART1_UDRIE UDRIE1
#else
#error "no UART definition for MCU available"
#endif
/*
* module global variables
*/
static volatile unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE];
static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];
static volatile unsigned char UART_TxHead;
static volatile unsigned char UART_TxTail;
static volatile unsigned char UART_RxHead;
static volatile unsigned char UART_RxTail;
static volatile unsigned char UART_LastRxError;
#if defined( ATMEGA_USART1 )
static volatile unsigned char UART1_TxBuf[UART_TX_BUFFER_SIZE];
static volatile unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE];
static volatile unsigned char UART1_TxHead;
static volatile unsigned char UART1_TxTail;
static volatile unsigned char UART1_RxHead;
static volatile unsigned char UART1_RxTail;
static volatile unsigned char UART1_LastRxError;
#endif
ISR (UART0_RECEIVE_INTERRUPT)
/*************************************************************************
Function: UART Receive Complete interrupt
Purpose: called when the UART has received a character
**************************************************************************/
{
unsigned char tmphead;
unsigned char data;
unsigned char usr;
unsigned char lastRxError;
/* read UART status register and UART data register */
usr = UART0_STATUS;
data = UART0_DATA;
/* */
#if defined( AT90_UART )
lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
#elif defined( ATMEGA_USART )
lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
#elif defined( ATMEGA_USART0 )
lastRxError = (usr & (_BV(FE0)|_BV(DOR0)) );
#elif defined ( ATMEGA_UART )
lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
#endif
/* calculate buffer index */
tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK;
if ( tmphead == UART_RxTail ) {
/* error: receive buffer overflow */
lastRxError = UART_BUFFER_OVERFLOW >> 8;
}else{
/* store new index */
UART_RxHead = tmphead;
/* store received data in buffer */
UART_RxBuf[tmphead] = data;
}
UART_LastRxError |= lastRxError;
}
ISR (UART0_TRANSMIT_INTERRUPT)
/*************************************************************************
Function: UART Data Register Empty interrupt
Purpose: called when the UART is ready to transmit the next byte
**************************************************************************/
{
unsigned char tmptail;
if ( UART_TxHead != UART_TxTail) {
/* calculate and store new buffer index */
tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;
UART_TxTail = tmptail;
/* get one byte from buffer and write it to UART */
UART0_DATA = UART_TxBuf[tmptail]; /* start transmission */
}else{
/* tx buffer empty, disable UDRE interrupt */
UART0_CONTROL &= ~_BV(UART0_UDRIE);
}
}
/*************************************************************************
Function: uart_init()
Purpose: initialize UART and set baudrate
Input: baudrate using macro UART_BAUD_SELECT()
Returns: none
**************************************************************************/
void uart_init(unsigned int baudrate)
{
UART_TxHead = 0;
UART_TxTail = 0;
UART_RxHead = 0;
UART_RxTail = 0;
#if defined( AT90_UART )
/* set baud rate */
UBRR = (unsigned char)baudrate;
/* enable UART receiver and transmmitter and receive complete interrupt */
UART0_CONTROL = _BV(RXCIE)|_BV(RXEN)|_BV(TXEN);
#elif defined (ATMEGA_USART)
/* Set baud rate */
if ( baudrate & 0x8000 )
{
UART0_STATUS = (1<<U2X); //Enable 2x speed
baudrate &= ~0x8000;
}
UBRRH = (unsigned char)(baudrate>>8);
UBRRL = (unsigned char) baudrate;
/* Enable USART receiver and transmitter and receive complete interrupt */
UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
/* Set frame format: asynchronous, 8data, no parity, 1stop bit */
#ifdef URSEL
UCSRC = (1<<URSEL)|(3<<UCSZ0);
#else
UCSRC = (3<<UCSZ0);
#endif
#elif defined (ATMEGA_USART0 )
/* Set baud rate */
if ( baudrate & 0x8000 )
{
UART0_STATUS = (1<<U2X0); //Enable 2x speed
baudrate &= ~0x8000;
}
UBRR0H = (unsigned char)(baudrate>>8);
UBRR0L = (unsigned char) baudrate;
/* Enable USART receiver and transmitter and receive complete interrupt */
UART0_CONTROL = _BV(RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
/* Set frame format: asynchronous, 8data, no parity, 1stop bit */
#ifdef URSEL0
UCSR0C = (1<<URSEL0)|(3<<UCSZ00);
#else
UCSR0C = (3<<UCSZ00);
#endif
#elif defined ( ATMEGA_UART )
/* set baud rate */
if ( baudrate & 0x8000 )
{
UART0_STATUS = (1<<U2X); //Enable 2x speed
baudrate &= ~0x8000;
}
UBRRHI = (unsigned char)(baudrate>>8);
UBRR = (unsigned char) baudrate;
/* Enable UART receiver and transmitter and receive complete interrupt */
UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
#endif
}/* uart_init */
/*************************************************************************
Function: uart_getc()
Purpose: return byte from ringbuffer
Returns: lower byte: received byte from ringbuffer
higher byte: last receive error
**************************************************************************/
unsigned int uart_getc(void)
{
unsigned char tmptail;
unsigned char data;
if ( UART_RxHead == UART_RxTail ) {
return UART_NO_DATA; /* no data available */
}
/* calculate /store buffer index */
tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;
UART_RxTail = tmptail;
/* get data from receive buffer */
data = UART_RxBuf[tmptail];
data = (UART_LastRxError << 8) + data;
UART_LastRxError = 0;
return data;
}/* uart_getc */
/*************************************************************************
Function: uart_putc()
Purpose: write byte to ringbuffer for transmitting via UART
Input: byte to be transmitted
Returns: none
**************************************************************************/
void uart_putc(unsigned char data)
{
unsigned char tmphead;
tmphead = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;
while ( tmphead == UART_TxTail ){
;/* wait for free space in buffer */
}
UART_TxBuf[tmphead] = data;
UART_TxHead = tmphead;
/* enable UDRE interrupt */
UART0_CONTROL |= _BV(UART0_UDRIE);
}/* uart_putc */
/*************************************************************************
Function: uart_puts()
Purpose: transmit string to UART
Input: string to be transmitted
Returns: none
**************************************************************************/
void uart_puts(const char *s )
{
while (*s)
uart_putc(*s++);
}/* uart_puts */
/*************************************************************************
Function: uart_puts_p()
Purpose: transmit string from program memory to UART
Input: program memory string to be transmitted
Returns: none
**************************************************************************/
void uart_puts_p(const char *progmem_s )
{
register char c;
while ( (c = pgm_read_byte(progmem_s++)) )
uart_putc(c);
}/* uart_puts_p */
/*
* these functions are only for ATmegas with two USART
*/
#if defined( ATMEGA_USART1 )
ISR(UART1_RECEIVE_INTERRUPT)
/*************************************************************************
Function: UART1 Receive Complete interrupt
Purpose: called when the UART1 has received a character
**************************************************************************/
{
unsigned char tmphead;
unsigned char data;
unsigned char usr;
unsigned char lastRxError;
/* read UART status register and UART data register */
usr = UART1_STATUS;
data = UART1_DATA;
/* */
lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) );
/* calculate buffer index */
tmphead = ( UART1_RxHead + 1) & UART_RX_BUFFER_MASK;
if ( tmphead == UART1_RxTail ) {
/* error: receive buffer overflow */
lastRxError = UART_BUFFER_OVERFLOW >> 8;
}else{
/* store new index */
UART1_RxHead = tmphead;
/* store received data in buffer */
UART1_RxBuf[tmphead] = data;
}
UART1_LastRxError |= lastRxError;
}
ISR(UART1_TRANSMIT_INTERRUPT)
/*************************************************************************
Function: UART1 Data Register Empty interrupt
Purpose: called when the UART1 is ready to transmit the next byte
**************************************************************************/
{
unsigned char tmptail;
if ( UART1_TxHead != UART1_TxTail) {
/* calculate and store new buffer index */
tmptail = (UART1_TxTail + 1) & UART_TX_BUFFER_MASK;
UART1_TxTail = tmptail;
/* get one byte from buffer and write it to UART */
UART1_DATA = UART1_TxBuf[tmptail]; /* start transmission */
}else{
/* tx buffer empty, disable UDRE interrupt */
UART1_CONTROL &= ~_BV(UART1_UDRIE);
}
}
/*************************************************************************
Function: uart1_init()
Purpose: initialize UART1 and set baudrate
Input: baudrate using macro UART_BAUD_SELECT()
Returns: none
**************************************************************************/
void uart1_init(unsigned int baudrate)
{
UART1_TxHead = 0;
UART1_TxTail = 0;
UART1_RxHead = 0;
UART1_RxTail = 0;
/* Set baud rate */
if ( baudrate & 0x8000 )
{
UART1_STATUS = (1<<U2X1); //Enable 2x speed
baudrate &= ~0x8000;
}
UBRR1H = (unsigned char)(baudrate>>8);
UBRR1L = (unsigned char) baudrate;
/* Enable USART receiver and transmitter and receive complete interrupt */
UART1_CONTROL = _BV(RXCIE1)|(1<<RXEN1)|(1<<TXEN1);
/* Set frame format: asynchronous, 8data, no parity, 1stop bit */
#ifdef URSEL1
UCSR1C = (1<<URSEL1)|(3<<UCSZ10);
#else
UCSR1C = (3<<UCSZ10);
#endif
}/* uart_init */
/*************************************************************************
Function: uart1_getc()
Purpose: return byte from ringbuffer
Returns: lower byte: received byte from ringbuffer
higher byte: last receive error
**************************************************************************/
unsigned int uart1_getc(void)
{
unsigned char tmptail;
unsigned char data;
if ( UART1_RxHead == UART1_RxTail ) {
return UART_NO_DATA; /* no data available */
}
/* calculate /store buffer index */
tmptail = (UART1_RxTail + 1) & UART_RX_BUFFER_MASK;
UART1_RxTail = tmptail;
/* get data from receive buffer */
data = UART1_RxBuf[tmptail];
data = (UART1_LastRxError << 8) + data;
UART1_LastRxError = 0;
return data;
}/* uart1_getc */
/*************************************************************************
Function: uart1_putc()
Purpose: write byte to ringbuffer for transmitting via UART
Input: byte to be transmitted
Returns: none
**************************************************************************/
void uart1_putc(unsigned char data)
{
unsigned char tmphead;
tmphead = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK;
while ( tmphead == UART1_TxTail ){
;/* wait for free space in buffer */
}
UART1_TxBuf[tmphead] = data;
UART1_TxHead = tmphead;
/* enable UDRE interrupt */
UART1_CONTROL |= _BV(UART1_UDRIE);
}/* uart1_putc */
/*************************************************************************
Function: uart1_puts()
Purpose: transmit string to UART1
Input: string to be transmitted
Returns: none
**************************************************************************/
void uart1_puts(const char *s )
{
while (*s)
uart1_putc(*s++);
}/* uart1_puts */
/*************************************************************************
Function: uart1_puts_p()
Purpose: transmit string from program memory to UART1
Input: program memory string to be transmitted
Returns: none
**************************************************************************/
void uart1_puts_p(const char *progmem_s )
{
register char c;
while ( (c = pgm_read_byte(progmem_s++)) )
uart1_putc(c);
}/* uart1_puts_p */
#endif

195
Rmodule/uart/uart.h Executable file
View File

@ -0,0 +1,195 @@
#ifndef UART_H
#define UART_H
/************************************************************************
Title: Interrupt UART library with receive/transmit circular buffers
Author: Peter Fleury <pfleury@gmx.ch> http://jump.to/fleury
File: $Id: uart.h,v 1.12 2012/11/19 19:52:27 peter Exp $
Software: AVR-GCC 4.1, AVR Libc 1.4
Hardware: any AVR with built-in UART, tested on AT90S8515 & ATmega8 at 4 Mhz
License: GNU General Public License
Usage: see Doxygen manual
LICENSE:
Copyright (C) 2006 Peter Fleury
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
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.
************************************************************************/
/**
* @defgroup pfleury_uart UART Library
* @code #include <uart.h> @endcode
*
* @brief Interrupt UART library using the built-in UART with transmit and receive circular buffers.
*
* This library can be used to transmit and receive data through the built in UART.
*
* An interrupt is generated when the UART has finished transmitting or
* receiving a byte. The interrupt handling routines use circular buffers
* for buffering received and transmitted data.
*
* The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE constants define
* the size of the circular buffers in bytes. Note that these constants must be a power of 2.
* You may need to adapt this constants to your target and your application by adding
* CDEFS += -DUART_RX_BUFFER_SIZE=nn -DUART_RX_BUFFER_SIZE=nn to your Makefile.
*
* @note Based on Atmel Application Note AVR306
* @author Peter Fleury pfleury@gmx.ch http://jump.to/fleury
*/
/**@{*/
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !"
#endif
/*
** constants and macros
*/
/** @brief UART Baudrate Expression
* @param xtalcpu system clock in Mhz, e.g. 4000000UL for 4Mhz
* @param baudrate baudrate in bps, e.g. 1200, 2400, 9600
*/
#define UART_BAUD_SELECT(baudRate,xtalCpu) (((xtalCpu) + 8UL * (baudRate)) / (16UL * (baudRate)) -1UL)
/** @brief UART Baudrate Expression for ATmega double speed mode
* @param xtalcpu system clock in Mhz, e.g. 4000000UL for 4Mhz
* @param baudrate baudrate in bps, e.g. 1200, 2400, 9600
*/
#define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate,xtalCpu) ( ((((xtalCpu) + 4UL * (baudRate)) / (8UL * (baudRate)) -1UL)) | 0x8000)
/** Size of the circular receive buffer, must be power of 2 */
#ifndef UART_RX_BUFFER_SIZE
#define UART_RX_BUFFER_SIZE 32
#endif
/** Size of the circular transmit buffer, must be power of 2 */
#ifndef UART_TX_BUFFER_SIZE
#define UART_TX_BUFFER_SIZE 32
#endif
/* test if the size of the circular buffers fits into SRAM */
#if ( (UART_RX_BUFFER_SIZE+UART_TX_BUFFER_SIZE) >= (RAMEND-0x60 ) )
#error "size of UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE larger than size of SRAM"
#endif
/*
** high byte error return code of uart_getc()
*/
#define UART_FRAME_ERROR 0x1000 /* Framing Error by UART */
#define UART_OVERRUN_ERROR 0x0800 /* Overrun condition by UART */
#define UART_PARITY_ERROR 0x0400 /* Parity Error by UART */
#define UART_BUFFER_OVERFLOW 0x0200 /* receive ringbuffer overflow */
#define UART_NO_DATA 0x0100 /* no receive data available */
/*
** function prototypes
*/
/**
@brief Initialize UART and set baudrate
@param baudrate Specify baudrate using macro UART_BAUD_SELECT()
@return none
*/
extern void uart_init(unsigned int baudrate);
/**
* @brief Get received byte from ringbuffer
*
* Returns in the lower byte the received character and in the
* higher byte the last receive error.
* UART_NO_DATA is returned when no data is available.
*
* @param void
* @return lower byte: received byte from ringbuffer
* @return higher byte: last receive status
* - \b 0 successfully received data from UART
* - \b UART_NO_DATA
* <br>no receive data available
* - \b UART_BUFFER_OVERFLOW
* <br>Receive ringbuffer overflow.
* We are not reading the receive buffer fast enough,
* one or more received character have been dropped
* - \b UART_OVERRUN_ERROR
* <br>Overrun condition by UART.
* A character already present in the UART UDR register was
* not read by the interrupt handler before the next character arrived,
* one or more received characters have been dropped.
* - \b UART_FRAME_ERROR
* <br>Framing Error by UART
*/
extern unsigned int uart_getc(void);
/**
* @brief Put byte to ringbuffer for transmitting via UART
* @param data byte to be transmitted
* @return none
*/
extern void uart_putc(unsigned char data);
/**
* @brief Put string to ringbuffer for transmitting via UART
*
* The string is buffered by the uart library in a circular buffer
* and one character at a time is transmitted to the UART using interrupts.
* Blocks if it can not write the whole string into the circular buffer.
*
* @param s string to be transmitted
* @return none
*/
extern void uart_puts(const char *s );
/**
* @brief Put string from program memory to ringbuffer for transmitting via UART.
*
* The string is buffered by the uart library in a circular buffer
* and one character at a time is transmitted to the UART using interrupts.
* Blocks if it can not write the whole string into the circular buffer.
*
* @param s program memory string to be transmitted
* @return none
* @see uart_puts_P
*/
extern void uart_puts_p(const char *s );
/**
* @brief Macro to automatically put a string constant into program memory
*/
#define uart_puts_P(__s) uart_puts_p(PSTR(__s))
/** @brief Initialize USART1 (only available on selected ATmegas) @see uart_init */
extern void uart1_init(unsigned int baudrate);
/** @brief Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */
extern unsigned int uart1_getc(void);
/** @brief Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */
extern void uart1_putc(unsigned char data);
/** @brief Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */
extern void uart1_puts(const char *s );
/** @brief Put string from program memory to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts_p */
extern void uart1_puts_p(const char *s );
/** @brief Macro to automatically put a string constant into program memory */
#define uart1_puts_P(__s) uart1_puts_p(PSTR(__s))
/**@}*/
#endif // UART_H

118
Rmodule/uart/uart_addon.c Executable file
View File

@ -0,0 +1,118 @@
/*************************************************************************
Title: UART addon-library
Author: Martin Thomas <eversmith@heizung-thomas.de>
http://www.siwawi.arubi.uni-kl.de/avr_projects
Software: AVR-GCC 3.3/3.4, Peter Fleury's UART-Library
DESCRIPTION:
USAGE:
Refere to the header file uart_addon.h for a description of the routines.
*************************************************************************/
#include <stdlib.h>
#include <avr/io.h>
#include "uart.h"
/*************************************************************************
Function: uart_put_int()
Purpose: transmit integer as ASCII to UART
Input: integer value
Returns: none
**************************************************************************/
void uart_put_int( const int val )
{
char buffer[10];
uart_puts( itoa( val, buffer, 10 ) );
} /* uart_puti */
/*************************************************************************
Function: uart_put_longint()
Purpose: transmit long integer as ASCII to UART
Input: integer value
Returns: none
**************************************************************************/
void uart_put_longint( const long int val )
{
char buffer[15];
uart_puts( ltoa( val, buffer, 10 ) );
} /* uart_puti */
/*************************************************************************
Function: uart_put_ulongint()
Purpose: transmit long integer as ASCII to UART
Input: integer value
Returns: none
**************************************************************************/
void uart_put_ulongint( const unsigned long int val )
{
char buffer[15];
uart_puts( utoa( val, buffer, 10 ) );
} /* uart_puti */
/*************************************************************************
Function: uart_puthex_nibble()
Purpose: transmit lower nibble as ASCII-hex to UART
Input: byte value
Returns: none
**************************************************************************/
void uart_puthex_nibble(const unsigned char b)
{
unsigned char c = b & 0x0f;
if ( c > 9 ) {
c += 'A'-10;
}
else {
c += '0';
}
uart_putc(c);
} /* uart_puthex_nibble */
/*************************************************************************
Function: uart_puthex_byte()
Purpose: transmit upper and lower nibble as ASCII-hex to UART
Input: byte value
Returns: none
**************************************************************************/
void uart_puthex_byte( const unsigned char b )
{
uart_puthex_nibble( b >> 4 );
uart_puthex_nibble( b );
} /* uart_puthex_byte */
/*************************************************************************
Function: uart_puthex_long()
Purpose: transmit unsigned long as ASCII-hex to UART
Input: uint32_t value
Returns: none
**************************************************************************/
void uart_puthex_long( const unsigned long l )
{
uart_puthex_byte( (unsigned char)( l >> 24 ) );
uart_puthex_byte( (unsigned char)( l >> 16 ) );
uart_puthex_byte( (unsigned char)( l >> 8 ) );
uart_puthex_byte( (unsigned char)( l ) );
} /* uart_puthex_byte */
/*************************************************************************
Function: uart_putbin_byte()
Purpose: transmit byte as ASCII-bin to UART
Input: byte value
Returns: none
**************************************************************************/
void uart_putbin_byte( const unsigned char b )
{
signed char i;
for ( i= 7;i >= 0;i-- ) {
if ( b & ( 1 << i ) ) {
uart_putc( '1' );
}
else {
uart_putc( '0' );
}
}
} /* uart_putbin_byte */

121
Rmodule/uart/uart_addon.h Executable file
View File

@ -0,0 +1,121 @@
#ifndef UART_ADDON_H
#define UART_ADDON_H
/************************************************************************
Title: UART addon-library
Author: Martin Thomas <eversmith@heizung-thomas.de>
http://www.siwawi.arubi.uni-kl.de/avr_projects
Software: AVR-GCC 3.3/3.4, Peter Fleury's UART-Library
************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif
/**
* @defgroup UART library-addon
* @code #include <uart_addon.h> @endcode
*
* @brief Additional functions for send numbers as decimal and hex to UART
*
* @note needs Peter Fleury's UART-Library http://jump.to/fleury
* @author Martin Thomas eversmith@heizung-thomas.de
*/
/*@{*/
/**
* @brief Put long integer to ringbuffer for transmitting via UART.
*
* The integer is converted to a string which is buffered by the uart
* library in a circular buffer and one character at a time is transmitted
* to the UART using interrupts.
*
* @param value to transfer
* @return none
* @see uart_puts_p
*/
extern void uart_put_longint( long int i );
/**
* @brief Put unsigned long integer to ringbuffer for transmitting via UART.
*
* The integer is converted to a string which is buffered by the uart
* library in a circular buffer and one character at a time is transmitted
* to the UART using interrupts.
*
* @param value to transfer
* @return none
* @see uart_puts_p
*/
extern void uart_put_ulongint( unsigned long int i );
/**
* @brief Put integer to ringbuffer for transmitting via UART.
*
* The integer is converted to a string which is buffered by the uart
* library in a circular buffer and one character at a time is transmitted
* to the UART using interrupts.
*
* @param value to transfer
* @return none
* @see uart_puts_p
*/
extern void uart_put_int( int i );
/**
* @brief Put nibble as hex to ringbuffer for transmit via UART.
*
* The lower nibble of the parameter is convertet to correspondig
* hex-char and put in a circular buffer and one character at a time
* is transmitted to the UART using interrupts.
*
* @param value to transfer (byte, only lower nibble converted)
* @return none
* @see uart_putc
*/
extern void uart_puthex_nibble( const unsigned char b );
/**
* @brief Put byte as hex to ringbuffer for transmit via UART.
*
* The upper and lower nibble of the parameter are convertet to
* correspondig hex-chars and put in a circular buffer and one
* character at a time is transmitted to the UART using interrupts.
*
* @param value to transfer
* @return none
* @see uart_puthex_nibble
*/
extern void uart_puthex_byte( const unsigned char b );
/**
* @brief Put unsigned long as ASCII to ringbuffer for transmit via UART.
*
* @param value to transfer
* @return none
* @see none
*/
extern void uart_puthex_long( unsigned long l );
/**
* @brief Put byte as bin to ringbuffer for transmit via UART.
*
* @param value to transfer
* @return none
* @see uart_putc
*/
extern void uart_putbin_byte( const unsigned char b );
/*@}*/
#ifdef __cplusplus
}
#endif
#endif /* UART_ADDON_H */

1
boot/avrprog_boot.pnproj Executable file
View File

@ -0,0 +1 @@
<Project name="avrprog_boot"><File path="chipdef.h"></File><File path="main.c"></File><File path="makefile"></File><File path="mega128.h"></File><File path="mega128can.h"></File><File path="mega16.h"></File><File path="mega169.h"></File><File path="mega32.h"></File><File path="mega8.h"></File><File path="readme.txt"></File><File path="ldscripts_no_vector\avr5.x"></File><File path="main.lss"></File><File path="main.map"></File><File path="ldscripts_no_vector\avr4.x"></File><File path="mega162.h"></File><File path="mega644.h"></File><File path="mega644p.h"></File><File path="megaxx4p.h"></File><File path="mega324p.h"></File></Project>

1
boot/avrprog_boot.pnps Executable file
View File

@ -0,0 +1 @@
<pd><ViewState><e p="avrprog_boot" x="true"></e></ViewState></pd>

1
boot/boot.aps Executable file
View File

@ -0,0 +1 @@
<AVRStudio><MANAGEMENT><ProjectName>boot</ProjectName><Created>12-Nov-2013 16:48:01</Created><LastEdit>14-Nov-2013 10:36:05</LastEdit><ICON>241</ICON><ProjectType>0</ProjectType><Created>12-Nov-2013 16:48:01</Created><Version>4</Version><Build>4, 19, 0, 730</Build><ProjectTypeName>AVR GCC</ProjectTypeName></MANAGEMENT><CODE_CREATION><ObjectFile></ObjectFile><EntryFile></EntryFile><SaveFolder>C:\Hard\boot\</SaveFolder></CODE_CREATION><DEBUG_TARGET><CURRENT_TARGET>AVR Simulator</CURRENT_TARGET><CURRENT_PART>ATmega8.xml</CURRENT_PART><BREAKPOINTS></BREAKPOINTS><IO_EXPAND><HIDE>false</HIDE></IO_EXPAND><REGISTERNAMES><Register>R00</Register><Register>R01</Register><Register>R02</Register><Register>R03</Register><Register>R04</Register><Register>R05</Register><Register>R06</Register><Register>R07</Register><Register>R08</Register><Register>R09</Register><Register>R10</Register><Register>R11</Register><Register>R12</Register><Register>R13</Register><Register>R14</Register><Register>R15</Register><Register>R16</Register><Register>R17</Register><Register>R18</Register><Register>R19</Register><Register>R20</Register><Register>R21</Register><Register>R22</Register><Register>R23</Register><Register>R24</Register><Register>R25</Register><Register>R26</Register><Register>R27</Register><Register>R28</Register><Register>R29</Register><Register>R30</Register><Register>R31</Register></REGISTERNAMES><COM>Auto</COM><COMType>0</COMType><WATCHNUM>0</WATCHNUM><WATCHNAMES><Pane0></Pane0><Pane1></Pane1><Pane2></Pane2><Pane3></Pane3></WATCHNAMES><BreakOnTrcaeFull>0</BreakOnTrcaeFull></DEBUG_TARGET><Debugger><Triggers></Triggers></Debugger><AVRGCCPLUGIN><FILES><SOURCEFILE>main.c</SOURCEFILE><OTHERFILE>makefile</OTHERFILE></FILES><CONFIGS><CONFIG><NAME>default</NAME><USESEXTERNALMAKEFILE>YES</USESEXTERNALMAKEFILE><EXTERNALMAKEFILE>makefile</EXTERNALMAKEFILE><PART>atmega8</PART><HEX>1</HEX><LIST>1</LIST><MAP>1</MAP><OUTPUTFILENAME>boot.elf</OUTPUTFILENAME><OUTPUTDIR>default\</OUTPUTDIR><ISDIRTY>0</ISDIRTY><OPTIONS><OPTION><FILE>main.c</FILE><OPTIONLIST></OPTIONLIST></OPTION></OPTIONS><INCDIRS/><LIBDIRS/><LIBS/><LINKOBJECTS/><OPTIONSFORALL>-Wall -gdwarf-2 -std=gnu99 -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums</OPTIONSFORALL><LINKEROPTIONS></LINKEROPTIONS><SEGMENTS/></CONFIG></CONFIGS><LASTCONFIG>default</LASTCONFIG><USES_WINAVR>0</USES_WINAVR><GCC_LOC>C:\Hard\WinAVR-20100110\bin\avr-gcc.exe</GCC_LOC><MAKE_LOC>C:\Hard\WinAVR-20100110\utils\bin\make.exe</MAKE_LOC></AVRGCCPLUGIN><ProjectFiles><Files><Name>C:\Hard\boot\main.c</Name></Files></ProjectFiles><IOView><usergroups/><sort sorted="0" column="0" ordername="0" orderaddress="0" ordergroup="0"/></IOView><Files><File00000><FileId>00000</FileId><FileName>main.c</FileName><Status>1</Status></File00000></Files><Events><Bookmarks></Bookmarks></Events><Trace><Filters></Filters></Trace></AVRStudio>

1
boot/boot.aws Executable file
View File

@ -0,0 +1 @@
<AVRWorkspace><IOSettings><CurrentRegisters/></IOSettings><part name="ATMEGA8"/><Files><File00000 Name="C:\Hard\boot\main.c" Position="262 71 1568 804" LineCol="137 0" State="Maximized"/></Files></AVRWorkspace>

59
boot/chipdef.h Executable file
View File

@ -0,0 +1,59 @@
#ifndef CHIPDEF_H
#define CHIPDEF_H
#include <avr/io.h>
#if defined (SPMCSR)
#define SPM_REG SPMCSR
#elif defined (SPMCR)
#define SPM_REG SPMCR
#else
#error "AVR processor does not provide bootloader support!"
#endif
#define APP_END (FLASHEND - (BOOTSIZE * 2))
#if (SPM_PAGESIZE > UINT8_MAX)
typedef uint16_t pagebuf_t;
#else
typedef uint8_t pagebuf_t;
#endif
#if defined(__AVR_ATmega169__)
#include "mega169.h"
#elif defined(__AVR_ATmega16__)
#include "mega16.h"
#elif defined(__AVR_ATmega162__)
#include "mega162.h"
#elif defined(__AVR_ATmega8__)
#include "mega8.h"
#elif defined(__AVR_ATmega32__)
#include "mega32.h"
#elif defined(__AVR_ATmega324P__)
#include "mega324p.h"
#elif defined(__AVR_ATmega64__)
#include "mega64.h"
#elif defined(__AVR_ATmega644__)
#include "mega644.h"
#elif defined(__AVR_ATmega644P__)
#include "mega644p.h"
#elif defined(__AVR_ATmega128__)
#include "mega128.h"
#elif defined(__AVR_AT90CAN128__)
#include "mega128can.h"
#else
#error "no definition for MCU available in chipdef.h"
#endif
#endif

75
boot/default/Makefile Executable file
View File

@ -0,0 +1,75 @@
###############################################################################
# Makefile for the project Bootloader
###############################################################################
## General Flags
PROJECT = Bootloader
MCU = atmega16
TARGET = Bootloader.elf
CC = avr-gcc
## Options common to compile, link and assembly rules
COMMON = -mmcu=$(MCU)
## Compile options common for all C compilation units.
CFLAGS = $(COMMON)
CFLAGS += -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
CFLAGS += -MD -MP -MT $(*F).o -MF dep/$(@F).d
## Assembly specific flags
ASMFLAGS = $(COMMON)
ASMFLAGS += $(CFLAGS)
ASMFLAGS += -x assembler-with-cpp -Wa,-gdwarf2
## Linker flags
LDFLAGS = $(COMMON)
LDFLAGS += -Wl,-Map=Bootloader.map
## Intel Hex file production flags
HEX_FLASH_FLAGS = -R .eeprom -R .fuse -R .lock -R .signature
HEX_EEPROM_FLAGS = -j .eeprom
HEX_EEPROM_FLAGS += --set-section-flags=.eeprom="alloc,load"
HEX_EEPROM_FLAGS += --change-section-lma .eeprom=0 --no-change-warnings
## Objects that must be built in order to link
OBJECTS = main.o
## Objects explicitly added by the user
LINKONLYOBJECTS =
## Build
all: $(TARGET) Bootloader.hex Bootloader.eep Bootloader.lss size
## Compile
main.o: ../main.c
$(CC) $(INCLUDES) $(CFLAGS) -c $<
##Link
$(TARGET): $(OBJECTS)
$(CC) $(LDFLAGS) $(OBJECTS) $(LINKONLYOBJECTS) $(LIBDIRS) $(LIBS) -o $(TARGET)
%.hex: $(TARGET)
avr-objcopy -O ihex $(HEX_FLASH_FLAGS) $< $@
%.eep: $(TARGET)
-avr-objcopy $(HEX_EEPROM_FLAGS) -O ihex $< $@ || exit 0
%.lss: $(TARGET)
avr-objdump -h -S $< > $@
size: ${TARGET}
@echo
@avr-size -C --mcu=${MCU} ${TARGET}
## Clean target
.PHONY: clean
clean:
-rm -rf $(OBJECTS) Bootloader.elf dep/* Bootloader.hex Bootloader.eep Bootloader.lss Bootloader.map
## Other dependencies
-include $(shell mkdir dep 2>/dev/null) $(wildcard dep/*)

62
boot/default/dep/main.o.d Executable file
View File

@ -0,0 +1,62 @@
main.o: ../main.c c:/winavr/lib/gcc/../../avr/include/stdint.h \
c:/winavr/lib/gcc/../../avr/include/avr/io.h \
c:/winavr/lib/gcc/../../avr/include/avr/sfr_defs.h \
c:/winavr/lib/gcc/../../avr/include/inttypes.h \
c:/winavr/lib/gcc/../../avr/include/avr/iom16.h \
c:/winavr/lib/gcc/../../avr/include/avr/portpins.h \
c:/winavr/lib/gcc/../../avr/include/avr/common.h \
c:/winavr/lib/gcc/../../avr/include/avr/version.h \
c:/winavr/lib/gcc/../../avr/include/avr/fuse.h \
c:/winavr/lib/gcc/../../avr/include/avr/lock.h \
c:/winavr/lib/gcc/../../avr/include/avr/wdt.h \
c:/winavr/lib/gcc/../../avr/include/avr/boot.h \
c:/winavr/lib/gcc/../../avr/include/avr/eeprom.h \
c:\winavr\bin\../lib/gcc/avr/4.3.2/include/stddef.h \
c:\winavr\bin\../lib/gcc/avr/4.3.2/include-fixed/limits.h \
c:/winavr/lib/gcc/../../avr/include/avr/pgmspace.h \
c:/winavr/lib/gcc/../../avr/include/avr/interrupt.h \
c:/winavr/lib/gcc/../../avr/include/util/delay.h \
c:/winavr/lib/gcc/../../avr/include/util/delay_basic.h ../chipdef.h \
../mega16.h
c:/winavr/lib/gcc/../../avr/include/stdint.h:
c:/winavr/lib/gcc/../../avr/include/avr/io.h:
c:/winavr/lib/gcc/../../avr/include/avr/sfr_defs.h:
c:/winavr/lib/gcc/../../avr/include/inttypes.h:
c:/winavr/lib/gcc/../../avr/include/avr/iom16.h:
c:/winavr/lib/gcc/../../avr/include/avr/portpins.h:
c:/winavr/lib/gcc/../../avr/include/avr/common.h:
c:/winavr/lib/gcc/../../avr/include/avr/version.h:
c:/winavr/lib/gcc/../../avr/include/avr/fuse.h:
c:/winavr/lib/gcc/../../avr/include/avr/lock.h:
c:/winavr/lib/gcc/../../avr/include/avr/wdt.h:
c:/winavr/lib/gcc/../../avr/include/avr/boot.h:
c:/winavr/lib/gcc/../../avr/include/avr/eeprom.h:
c:\winavr\bin\../lib/gcc/avr/4.3.2/include/stddef.h:
c:\winavr\bin\../lib/gcc/avr/4.3.2/include-fixed/limits.h:
c:/winavr/lib/gcc/../../avr/include/avr/pgmspace.h:
c:/winavr/lib/gcc/../../avr/include/avr/interrupt.h:
c:/winavr/lib/gcc/../../avr/include/util/delay.h:
c:/winavr/lib/gcc/../../avr/include/util/delay_basic.h:
../chipdef.h:
../mega16.h:

169
boot/ldscripts_no_vector/avr1.x Executable file
View File

@ -0,0 +1,169 @@
/* Default linker script, for normal executables */
OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
OUTPUT_ARCH(avr:1)
MEMORY
{
text (rx) : ORIGIN = 0, LENGTH = 8K
data (rw!x) : ORIGIN = 0x800060, LENGTH = 0
eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
}
SECTIONS
{
/* Read-only sections, merged into text segment: */
.hash : { *(.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rel.init : { *(.rel.init) }
.rela.init : { *(.rela.init) }
.rel.text :
{
*(.rel.text)
*(.rel.text.*)
*(.rel.gnu.linkonce.t*)
}
.rela.text :
{
*(.rela.text)
*(.rela.text.*)
*(.rela.gnu.linkonce.t*)
}
.rel.fini : { *(.rel.fini) }
.rela.fini : { *(.rela.fini) }
.rel.rodata :
{
*(.rel.rodata)
*(.rel.rodata.*)
*(.rel.gnu.linkonce.r*)
}
.rela.rodata :
{
*(.rela.rodata)
*(.rela.rodata.*)
*(.rela.gnu.linkonce.r*)
}
.rel.data :
{
*(.rel.data)
*(.rel.data.*)
*(.rel.gnu.linkonce.d*)
}
.rela.data :
{
*(.rela.data)
*(.rela.data.*)
*(.rela.gnu.linkonce.d*)
}
.rel.ctors : { *(.rel.ctors) }
.rela.ctors : { *(.rela.ctors) }
.rel.dtors : { *(.rel.dtors) }
.rela.dtors : { *(.rela.dtors) }
.rel.got : { *(.rel.got) }
.rela.got : { *(.rela.got) }
.rel.bss : { *(.rel.bss) }
.rela.bss : { *(.rela.bss) }
.rel.plt : { *(.rel.plt) }
.rela.plt : { *(.rela.plt) }
/* Internal text space or external memory */
/DISCARD/ : { *(.vectors); }
.text :
{
/* *(.vectors) */
__ctors_start = . ;
*(.ctors)
__ctors_end = . ;
__dtors_start = . ;
*(.dtors)
__dtors_end = . ;
*(.progmem.gcc*)
*(.progmem*)
. = ALIGN(2);
*(.init0) /* Start here after reset. */
*(.init1)
*(.init2) /* Clear __zero_reg__, set up stack pointer. */
*(.init3)
*(.init4) /* Initialize data and BSS. */
*(.init5)
*(.init6) /* C++ constructors. */
*(.init7)
*(.init8)
*(.init9) /* Call main(). */
*(.text)
. = ALIGN(2);
*(.text.*)
. = ALIGN(2);
*(.fini9) /* _exit() starts here. */
*(.fini8)
*(.fini7)
*(.fini6) /* C++ destructors. */
*(.fini5)
*(.fini4)
*(.fini3)
*(.fini2)
*(.fini1)
*(.fini0) /* Infinite loop after program termination. */
_etext = . ;
} > text
.data : AT (ADDR (.text) + SIZEOF (.text))
{
PROVIDE (__data_start = .) ;
*(.data)
*(.gnu.linkonce.d*)
. = ALIGN(2);
_edata = . ;
PROVIDE (__data_end = .) ;
} > data
.bss SIZEOF(.data) + ADDR(.data) :
{
PROVIDE (__bss_start = .) ;
*(.bss)
*(COMMON)
PROVIDE (__bss_end = .) ;
} > data
__data_load_start = LOADADDR(.data);
__data_load_end = __data_load_start + SIZEOF(.data);
/* Global data not cleared after reset. */
.noinit SIZEOF(.bss) + ADDR(.bss) :
{
PROVIDE (__noinit_start = .) ;
*(.noinit*)
PROVIDE (__noinit_end = .) ;
_end = . ;
PROVIDE (__heap_start = .) ;
} > data
.eeprom :
{
*(.eeprom*)
__eeprom_end = . ;
} > eeprom
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
}

169
boot/ldscripts_no_vector/avr2.x Executable file
View File

@ -0,0 +1,169 @@
/* Default linker script, for normal executables */
OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
OUTPUT_ARCH(avr:2)
MEMORY
{
text (rx) : ORIGIN = 0, LENGTH = 8K
data (rw!x) : ORIGIN = 0x800060, LENGTH = 0xffa0
eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
}
SECTIONS
{
/* Read-only sections, merged into text segment: */
.hash : { *(.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rel.init : { *(.rel.init) }
.rela.init : { *(.rela.init) }
.rel.text :
{
*(.rel.text)
*(.rel.text.*)
*(.rel.gnu.linkonce.t*)
}
.rela.text :
{
*(.rela.text)
*(.rela.text.*)
*(.rela.gnu.linkonce.t*)
}
.rel.fini : { *(.rel.fini) }
.rela.fini : { *(.rela.fini) }
.rel.rodata :
{
*(.rel.rodata)
*(.rel.rodata.*)
*(.rel.gnu.linkonce.r*)
}
.rela.rodata :
{
*(.rela.rodata)
*(.rela.rodata.*)
*(.rela.gnu.linkonce.r*)
}
.rel.data :
{
*(.rel.data)
*(.rel.data.*)
*(.rel.gnu.linkonce.d*)
}
.rela.data :
{
*(.rela.data)
*(.rela.data.*)
*(.rela.gnu.linkonce.d*)
}
.rel.ctors : { *(.rel.ctors) }
.rela.ctors : { *(.rela.ctors) }
.rel.dtors : { *(.rel.dtors) }
.rela.dtors : { *(.rela.dtors) }
.rel.got : { *(.rel.got) }
.rela.got : { *(.rela.got) }
.rel.bss : { *(.rel.bss) }
.rela.bss : { *(.rela.bss) }
.rel.plt : { *(.rel.plt) }
.rela.plt : { *(.rela.plt) }
/* Internal text space or external memory */
/DISCARD/ : { *(.vectors); }
.text :
{
/* *(.vectors) */
__ctors_start = . ;
*(.ctors)
__ctors_end = . ;
__dtors_start = . ;
*(.dtors)
__dtors_end = . ;
*(.progmem.gcc*)
*(.progmem*)
. = ALIGN(2);
*(.init0) /* Start here after reset. */
*(.init1)
*(.init2) /* Clear __zero_reg__, set up stack pointer. */
*(.init3)
*(.init4) /* Initialize data and BSS. */
*(.init5)
*(.init6) /* C++ constructors. */
*(.init7)
*(.init8)
*(.init9) /* Call main(). */
*(.text)
. = ALIGN(2);
*(.text.*)
. = ALIGN(2);
*(.fini9) /* _exit() starts here. */
*(.fini8)
*(.fini7)
*(.fini6) /* C++ destructors. */
*(.fini5)
*(.fini4)
*(.fini3)
*(.fini2)
*(.fini1)
*(.fini0) /* Infinite loop after program termination. */
_etext = . ;
} > text
.data : AT (ADDR (.text) + SIZEOF (.text))
{
PROVIDE (__data_start = .) ;
*(.data)
*(.gnu.linkonce.d*)
. = ALIGN(2);
_edata = . ;
PROVIDE (__data_end = .) ;
} > data
.bss SIZEOF(.data) + ADDR(.data) :
{
PROVIDE (__bss_start = .) ;
*(.bss)
*(COMMON)
PROVIDE (__bss_end = .) ;
} > data
__data_load_start = LOADADDR(.data);
__data_load_end = __data_load_start + SIZEOF(.data);
/* Global data not cleared after reset. */
.noinit SIZEOF(.bss) + ADDR(.bss) :
{
PROVIDE (__noinit_start = .) ;
*(.noinit*)
PROVIDE (__noinit_end = .) ;
_end = . ;
PROVIDE (__heap_start = .) ;
} > data
.eeprom :
{
*(.eeprom*)
__eeprom_end = . ;
} > eeprom
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
}

169
boot/ldscripts_no_vector/avr3.x Executable file
View File

@ -0,0 +1,169 @@
/* Default linker script, for normal executables */
OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
OUTPUT_ARCH(avr:3)
MEMORY
{
text (rx) : ORIGIN = 0, LENGTH = 128K
data (rw!x) : ORIGIN = 0x800060, LENGTH = 0xffa0
eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
}
SECTIONS
{
/* Read-only sections, merged into text segment: */
.hash : { *(.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rel.init : { *(.rel.init) }
.rela.init : { *(.rela.init) }
.rel.text :
{
*(.rel.text)
*(.rel.text.*)
*(.rel.gnu.linkonce.t*)
}
.rela.text :
{
*(.rela.text)
*(.rela.text.*)
*(.rela.gnu.linkonce.t*)
}
.rel.fini : { *(.rel.fini) }
.rela.fini : { *(.rela.fini) }
.rel.rodata :
{
*(.rel.rodata)
*(.rel.rodata.*)
*(.rel.gnu.linkonce.r*)
}
.rela.rodata :
{
*(.rela.rodata)
*(.rela.rodata.*)
*(.rela.gnu.linkonce.r*)
}
.rel.data :
{
*(.rel.data)
*(.rel.data.*)
*(.rel.gnu.linkonce.d*)
}
.rela.data :
{
*(.rela.data)
*(.rela.data.*)
*(.rela.gnu.linkonce.d*)
}
.rel.ctors : { *(.rel.ctors) }
.rela.ctors : { *(.rela.ctors) }
.rel.dtors : { *(.rel.dtors) }
.rela.dtors : { *(.rela.dtors) }
.rel.got : { *(.rel.got) }
.rela.got : { *(.rela.got) }
.rel.bss : { *(.rel.bss) }
.rela.bss : { *(.rela.bss) }
.rel.plt : { *(.rel.plt) }
.rela.plt : { *(.rela.plt) }
/* Internal text space or external memory */
/DISCARD/ : { *(.vectors); }
.text :
{
/* *(.vectors) */
__ctors_start = . ;
*(.ctors)
__ctors_end = . ;
__dtors_start = . ;
*(.dtors)
__dtors_end = . ;
*(.progmem.gcc*)
*(.progmem*)
. = ALIGN(2);
*(.init0) /* Start here after reset. */
*(.init1)
*(.init2) /* Clear __zero_reg__, set up stack pointer. */
*(.init3)
*(.init4) /* Initialize data and BSS. */
*(.init5)
*(.init6) /* C++ constructors. */
*(.init7)
*(.init8)
*(.init9) /* Call main(). */
*(.text)
. = ALIGN(2);
*(.text.*)
. = ALIGN(2);
*(.fini9) /* _exit() starts here. */
*(.fini8)
*(.fini7)
*(.fini6) /* C++ destructors. */
*(.fini5)
*(.fini4)
*(.fini3)
*(.fini2)
*(.fini1)
*(.fini0) /* Infinite loop after program termination. */
_etext = . ;
} > text
.data : AT (ADDR (.text) + SIZEOF (.text))
{
PROVIDE (__data_start = .) ;
*(.data)
*(.gnu.linkonce.d*)
. = ALIGN(2);
_edata = . ;
PROVIDE (__data_end = .) ;
} > data
.bss SIZEOF(.data) + ADDR(.data) :
{
PROVIDE (__bss_start = .) ;
*(.bss)
*(COMMON)
PROVIDE (__bss_end = .) ;
} > data
__data_load_start = LOADADDR(.data);
__data_load_end = __data_load_start + SIZEOF(.data);
/* Global data not cleared after reset. */
.noinit SIZEOF(.bss) + ADDR(.bss) :
{
PROVIDE (__noinit_start = .) ;
*(.noinit*)
PROVIDE (__noinit_end = .) ;
_end = . ;
PROVIDE (__heap_start = .) ;
} > data
.eeprom :
{
*(.eeprom*)
__eeprom_end = . ;
} > eeprom
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
}

169
boot/ldscripts_no_vector/avr4.x Executable file
View File

@ -0,0 +1,169 @@
/* MODIFIED LINKER SCRIPT - BOOTLOADER: without .vectors */
OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
OUTPUT_ARCH(avr:4)
MEMORY
{
text (rx) : ORIGIN = 0, LENGTH = 8K
data (rw!x) : ORIGIN = 0x800060, LENGTH = 0xffa0
eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
}
SECTIONS
{
/* Read-only sections, merged into text segment: */
.hash : { *(.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rel.init : { *(.rel.init) }
.rela.init : { *(.rela.init) }
.rel.text :
{
*(.rel.text)
*(.rel.text.*)
*(.rel.gnu.linkonce.t*)
}
.rela.text :
{
*(.rela.text)
*(.rela.text.*)
*(.rela.gnu.linkonce.t*)
}
.rel.fini : { *(.rel.fini) }
.rela.fini : { *(.rela.fini) }
.rel.rodata :
{
*(.rel.rodata)
*(.rel.rodata.*)
*(.rel.gnu.linkonce.r*)
}
.rela.rodata :
{
*(.rela.rodata)
*(.rela.rodata.*)
*(.rela.gnu.linkonce.r*)
}
.rel.data :
{
*(.rel.data)
*(.rel.data.*)
*(.rel.gnu.linkonce.d*)
}
.rela.data :
{
*(.rela.data)
*(.rela.data.*)
*(.rela.gnu.linkonce.d*)
}
.rel.ctors : { *(.rel.ctors) }
.rela.ctors : { *(.rela.ctors) }
.rel.dtors : { *(.rel.dtors) }
.rela.dtors : { *(.rela.dtors) }
.rel.got : { *(.rel.got) }
.rela.got : { *(.rela.got) }
.rel.bss : { *(.rel.bss) }
.rela.bss : { *(.rela.bss) }
.rel.plt : { *(.rel.plt) }
.rela.plt : { *(.rela.plt) }
/* Internal text space or external memory */
/DISCARD/ : { *(.vectors); }
.text :
{
/* *(.vectors) */
__ctors_start = . ;
*(.ctors)
__ctors_end = . ;
__dtors_start = . ;
*(.dtors)
__dtors_end = . ;
*(.progmem.gcc*)
*(.progmem*)
. = ALIGN(2);
*(.init0) /* Start here after reset. */
*(.init1)
*(.init2) /* Clear __zero_reg__, set up stack pointer. */
*(.init3)
*(.init4) /* Initialize data and BSS. */
*(.init5)
*(.init6) /* C++ constructors. */
*(.init7)
*(.init8)
*(.init9) /* Call main(). */
*(.text)
. = ALIGN(2);
*(.text.*)
. = ALIGN(2);
*(.fini9) /* _exit() starts here. */
*(.fini8)
*(.fini7)
*(.fini6) /* C++ destructors. */
*(.fini5)
*(.fini4)
*(.fini3)
*(.fini2)
*(.fini1)
*(.fini0) /* Infinite loop after program termination. */
_etext = . ;
} > text
.data : AT (ADDR (.text) + SIZEOF (.text))
{
PROVIDE (__data_start = .) ;
*(.data)
*(.gnu.linkonce.d*)
. = ALIGN(2);
_edata = . ;
PROVIDE (__data_end = .) ;
} > data
.bss SIZEOF(.data) + ADDR(.data) :
{
PROVIDE (__bss_start = .) ;
*(.bss)
*(COMMON)
PROVIDE (__bss_end = .) ;
} > data
__data_load_start = LOADADDR(.data);
__data_load_end = __data_load_start + SIZEOF(.data);
/* Global data not cleared after reset. */
.noinit SIZEOF(.bss) + ADDR(.bss) :
{
PROVIDE (__noinit_start = .) ;
*(.noinit*)
PROVIDE (__noinit_end = .) ;
_end = . ;
PROVIDE (__heap_start = .) ;
} > data
.eeprom :
{
*(.eeprom*)
__eeprom_end = . ;
} > eeprom
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
}

172
boot/ldscripts_no_vector/avr5.x Executable file
View File

@ -0,0 +1,172 @@
/* MODIFIED LINKER SCRIPT - BOOTLOADER: without .vectors */
OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")
OUTPUT_ARCH(avr:5)
MEMORY
{
text (rx) : ORIGIN = 0, LENGTH = 128K
data (rw!x) : ORIGIN = 0x800060, LENGTH = 0xffa0
eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 64K
}
SECTIONS
{
/* Read-only sections, merged into text segment: */
.hash : { *(.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rel.init : { *(.rel.init) }
.rela.init : { *(.rela.init) }
.rel.text :
{
*(.rel.text)
*(.rel.text.*)
*(.rel.gnu.linkonce.t*)
}
.rela.text :
{
*(.rela.text)
*(.rela.text.*)
*(.rela.gnu.linkonce.t*)
}
.rel.fini : { *(.rel.fini) }
.rela.fini : { *(.rela.fini) }
.rel.rodata :
{
*(.rel.rodata)
*(.rel.rodata.*)
*(.rel.gnu.linkonce.r*)
}
.rela.rodata :
{
*(.rela.rodata)
*(.rela.rodata.*)
*(.rela.gnu.linkonce.r*)
}
.rel.data :
{
*(.rel.data)
*(.rel.data.*)
*(.rel.gnu.linkonce.d*)
}
.rela.data :
{
*(.rela.data)
*(.rela.data.*)
*(.rela.gnu.linkonce.d*)
}
.rel.ctors : { *(.rel.ctors) }
.rela.ctors : { *(.rela.ctors) }
.rel.dtors : { *(.rel.dtors) }
.rela.dtors : { *(.rela.dtors) }
.rel.got : { *(.rel.got) }
.rela.got : { *(.rela.got) }
.rel.bss : { *(.rel.bss) }
.rela.bss : { *(.rela.bss) }
.rel.plt : { *(.rel.plt) }
.rela.plt : { *(.rela.plt) }
/* Internal text space or external memory */
/* BOOTLOADER-MODIFICATION - not interrupt-vectors */
/DISCARD/ : { *(.vectors) }
.text :
{
/* *(.vectors) */ /* BOOTLOADER-MODIFICATION ! */
__ctors_start = . ;
*(.ctors)
__ctors_end = . ;
__dtors_start = . ;
*(.dtors)
__dtors_end = . ;
*(.progmem.gcc*)
*(.progmem*)
. = ALIGN(2);
*(.init0) /* Start here after reset. */
*(.init1)
*(.init2) /* Clear __zero_reg__, set up stack pointer. */
*(.init3)
*(.init4) /* Initialize data and BSS. */
*(.init5)
*(.init6) /* C++ constructors. */
*(.init7)
*(.init8)
*(.init9) /* Call main(). */
*(.text)
. = ALIGN(2);
*(.text.*)
. = ALIGN(2);
*(.fini9) /* _exit() starts here. */
*(.fini8)
*(.fini7)
*(.fini6) /* C++ destructors. */
*(.fini5)
*(.fini4)
*(.fini3)
*(.fini2)
*(.fini1)
*(.fini0) /* Infinite loop after program termination. */
_etext = . ;
} > text
.data : AT (ADDR (.text) + SIZEOF (.text))
{
PROVIDE (__data_start = .) ;
*(.data)
*(.gnu.linkonce.d*)
. = ALIGN(2);
_edata = . ;
PROVIDE (__data_end = .) ;
} > data
.bss SIZEOF(.data) + ADDR(.data) :
{
PROVIDE (__bss_start = .) ;
*(.bss)
*(COMMON)
PROVIDE (__bss_end = .) ;
} > data
__data_load_start = LOADADDR(.data);
__data_load_end = __data_load_start + SIZEOF(.data);
/* Global data not cleared after reset. */
.noinit SIZEOF(.bss) + ADDR(.bss) :
{
PROVIDE (__noinit_start = .) ;
*(.noinit*)
PROVIDE (__noinit_end = .) ;
_end = . ;
PROVIDE (__heap_start = .) ;
} > data
.eeprom :
{
*(.eeprom*)
__eeprom_end = . ;
} > eeprom
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
}

BIN
boot/main Executable file
View File

Binary file not shown.

686
boot/main.c Executable file
View File

@ -0,0 +1,686 @@
/*****************************************************************************
*
* AVRPROG compatible boot-loader
* Version : 0.85 (Dec. 2008)
* Compiler : avr-gcc 4.1.2 / avr-libc 1.4.6
* size : depends on features and startup ( minmal features < 512 words)
* by : Martin Thomas, Kaiserslautern, Germany
* eversmith@heizung-thomas.de
* Additional code and improvements contributed by:
* - Uwe Bonnes
* - Bjoern Riemer
* - Olaf Rempel
*
* License : Copyright (c) 2006-2008 M. Thomas, U. Bonnes, O. Rempel
* Free to use. You have to mention the copyright
* owners in source-code and documentation of derived
* work. No warranty! (Yes, you can insert the BSD
* license here)
*
* Tested with ATmega8, ATmega16, ATmega162, ATmega32, ATmega324P,
* ATmega644, ATmega644P, ATmega128, AT90CAN128
*
* - Initial versions have been based on the Butterfly bootloader-code
* by Atmel Corporation (Authors: BBrandal, PKastnes, ARodland, LHM)
*
****************************************************************************
*
* See the makefile and readme.txt for information on how to adapt
* the linker-settings to the selected Boot Size (BOOTSIZE=xxxx) and
* the MCU-type. Other configurations futher down in this file.
*
* With BOOT_SIMPLE, minimal features and discarded int-vectors
* this bootloader has should fit into a a 512 word (1024, 0x400 bytes)
* bootloader-section.
*
****************************************************************************/
/* ×àñòîòà êîíòðîëëåðà (êâàðöà) */
#ifndef F_CPU
// #define F_CPU 7372800
//#define F_CPU (7372800/2)
#define F_CPU 8000000
#endif
/* UART Ñêîðîñòü UART îïòèìàëüíî 19200 */
//#define BAUDRATE 9600
#define BAUDRATE 19200
//#define BAUDRATE 115200
/* Ðåæèì äâîéíîé ñêîðîñòè UART (áèò U2C)*/
//#define UART_DOUBLESPEED
/* Èñïîëüçóåòñÿ âòîðîé UART íà mega128 / can128 / mega162 / mega324p / mega644p */
//#define UART_USE_SECOND
/* Òèï óñòðîéñòâà:
Äëÿ AVRProg âûáèðàòü BOOT
Ýòî êîððåêòíîå çíà÷åíèå äëÿ bootloader.
avrdude ìîæåò îïðåäåëèòü òîëüêî part-code äëÿ ISP */
#define DEVTYPE DEVTYPE_BOOT
// #define DEVTYPE DEVTYPE_ISP
/*
* Âûáîð ïîðòà äëÿ êíîïêè âõîäà â çàãðóç÷èê
* ×òîáû âîéòè â çàãðóç÷èê íàäî ÷òîáû ïðè çàïóñêå ýòà êíîïêà çàìûêàëà ïèí íà çåìëþ
*/
#define BLPORT PORTD
#define BLDDR DDRD
#define BLPIN PIND
#define BLPNUM PIND7
/*
* Âûáîð ïîðòà äëÿ èíäèêàòîðà ðàáîòû çàãðóç÷èêà
* Ñâåòîäèîä ãîðèò - ìû â çàãðóç÷èêå
*/
#define ENABLE_BOOT_LED
#define BIPORT PORTD
#define BIDDR DDRD
#define BIPIN PIND
#define BIPNUM PIND5
/*
* Âûêëþ÷èòü Ñîáà÷èé òàéìåð íà âðåìÿ çàãðóç÷èêà
*/
#define DISABLE_WDT_AT_STARTUP
/*
* Watchdog-reset is issued at exit
* define the timeout-value here (see avr-libc manual)
*/
#define EXIT_WDT_TIME WDTO_250MS
/*
* Âûáîð ðåæèìà çàãðóç÷èêà
* SIMPLE-Mode - Çàãðóç÷èê ñòàðòóåò êîãäà íàæàòà åãî êíîïêà
* ïåðåõîä ê îñíîâíîé ïðîãðàììå îñóùåñòâëÿåòñÿ ïîñëå ñáðîñà
* (êíîïêà äîëæíà áûòü îòæàòà) ëèáî ïî êîìàíäå îò ïðîãðàììàòîðà
* Ïðè ýòîì ðåæèìå âûâîä íà êíîïêó êîíôèãóðèðóåòñÿ êàê âõîä-ñ ïîäòÿãîì,
* íî ïðè âûõîäå èç çàãðóç÷èêà âñå âûñòàâëÿåòñÿ ïî óìîë÷àíèþ
* POWERSAVE-Mode - Startup is separated in two loops
* which makes power-saving a little easier if no firmware
* is on the chip. Needs more memory
* BOOTICE-Mode - äëÿ çàøèâêè JTAGICE ôàéëà upgrade.ebn â Ìåãó16.
* ÷òî ïðåâðàùàåò åå â JTAG îòëàä÷èê. Ðàçóìååòñÿ íóæíî äîáàâèòü âåñü íåîáõîäèìûé
* îáâÿç íà êðèñòàëë äëÿ ýòîãî. È ÷àñòîòà äîëæíà áûòü âåçäå ïðîïèñàíà êàê 7372800
* â F_CPU Äëÿ ñîâìåñòèìîñòè ñ ðîäíîé ïðîøèâêîé JTAG ICE
* WAIT-mode Bootloader îæèäàåò êîìàíäû íà âõîä, åñëè åå íå áûëî â òå÷åíèè ïðîìåæóòêà âðåìåíè
* (êîòîðûé íàñòðàèâàåòñÿ) òî ïðîèõñîäèò ïåðåõîä ê îñíîâíîé ïðîãðàììå.
*/
//#define START_SIMPLE
#define START_WAIT
//#define START_POWERSAVE
//#define START_BOOTICE
/* Êîìàíäà äëÿ âõîäà â çàãðóç÷èê â START_WAIT */
#define START_WAIT_UARTCHAR 'S'
/* Âûäåðæêà äëÿ START_WAIT mode ( t = WAIT_TIME * 10ms ) */
#define WAIT_VALUE 300 /* ñåé÷àñ: 300*10ms = 3000ms = 3sec */
/*
* enable/disable readout of fuse and lock-bits
* (AVRPROG has to detect the AVR correctly by device-code
* to show the correct information).
*/
//#define ENABLEREADFUSELOCK
/* enable/disable write of lock-bits
* WARNING: lock-bits can not be reseted by bootloader (as far as I know)
* Only protection no unprotection, "chip erase" from bootloader only
* clears the flash but does no real "chip erase" (this is not possible
* with a bootloader as far as I know)
* Keep this undefined!
*/
//#define WRITELOCKBITS
/*
* define the following if the bootloader should not output
* itself at flash read (will fake an empty boot-section)
*/
//#define READ_PROTECT_BOOTLOADER
#define VERSION_HIGH '0'
#define VERSION_LOW '8'
#define GET_LOCK_BITS 0x0001
#define GET_LOW_FUSE_BITS 0x0000
#define GET_HIGH_FUSE_BITS 0x0003
#define GET_EXTENDED_FUSE_BITS 0x0002
/* Ðàñ÷åò äåëèòåëÿ ÷àñòîòû äëÿ USART*/
#ifdef UART_DOUBLESPEED
#define UART_CALC_BAUDRATE(baudRate) ((uint32_t)((F_CPU) + ((uint32_t)baudRate * 4UL)) / ((uint32_t)(baudRate) * 8UL) - 1)
#else
#define UART_CALC_BAUDRATE(baudRate) ((uint32_t)((F_CPU) + ((uint32_t)baudRate * 8UL)) / ((uint32_t)(baudRate) * 16UL) - 1)
#endif
#include <stdint.h>
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/boot.h>
#include <avr/pgmspace.h>
#include <avr/eeprom.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "chipdef.h"
uint8_t gBuffer[SPM_PAGESIZE];
#if defined(BOOTLOADERHASNOVECTORS)
#warning "This Bootloader does not link interrupt vectors - see makefile"
/* make the linker happy - it wants to see __vector_default */
// void __vector_default(void) { ; }
void __vector_default(void) { ; }
#endif
static void sendchar(uint8_t data)
{
while (!(UART_STATUS & (1<<UART_TXREADY)));
UART_DATA = data;
}
static uint8_t recvchar(void)
{
while (!(UART_STATUS & (1<<UART_RXREADY)));
return UART_DATA;
}
static inline void eraseFlash(void)
{
// erase only main section (bootloader protection)
uint32_t addr = 0;
while (APP_END > addr)
{
boot_page_erase(addr); // Perform page erase
boot_spm_busy_wait(); // Wait until the memory is erased.
addr += SPM_PAGESIZE;
}
boot_rww_enable();
}
static inline void recvBuffer(pagebuf_t size)
{
pagebuf_t cnt;
uint8_t *tmp = gBuffer;
for (cnt = 0; cnt < sizeof(gBuffer); cnt++)
{
*tmp++ = (cnt < size) ? recvchar() : 0xFF;
}
}
static inline uint16_t writeFlashPage(uint16_t waddr, pagebuf_t size)
{
uint32_t pagestart = (uint32_t)waddr<<1;
uint32_t baddr = pagestart;
uint16_t data;
uint8_t *tmp = gBuffer;
do
{
data = *tmp++;
data |= *tmp++ << 8;
boot_page_fill(baddr, data); // call asm routine.
baddr += 2; // Select next word in memory
size -= 2; // Reduce number of bytes to write by two
}
while (size); // Loop until all bytes written
boot_page_write(pagestart);
boot_spm_busy_wait();
boot_rww_enable(); // Re-enable the RWW section
return baddr>>1;
}
static inline uint16_t writeEEpromPage(uint16_t address, pagebuf_t size)
{
uint8_t *tmp = gBuffer;
do
{
eeprom_write_byte( (uint8_t*)address, *tmp++ );
address++; // Select next byte
size--; // Decreas number of bytes to write
}
while (size); // Loop until all bytes written
// eeprom_busy_wait();
return address;
}
static inline uint16_t readFlashPage(uint16_t waddr, pagebuf_t size)
{
uint32_t baddr = (uint32_t)waddr<<1;
uint16_t data;
do
{
#ifndef READ_PROTECT_BOOTLOADER
#warning "Bootloader not read-protected"
#if defined(RAMPZ)
data = pgm_read_word_far(baddr);
#else
data = pgm_read_word_near(baddr);
#endif
#else
// don't read bootloader
if ( baddr < APP_END )
{
#if defined(RAMPZ)
data = pgm_read_word_far(baddr);
#else
data = pgm_read_word_near(baddr);
#endif
}
else
{
data = 0xFFFF; // fake empty
}
#endif
sendchar(data); // send LSB
sendchar((data >> 8)); // send MSB
baddr += 2; // Select next word in memory
size -= 2; // Subtract two bytes from number of bytes to read
}
while (size); // Repeat until block has been read
return baddr>>1;
}
static inline uint16_t readEEpromPage(uint16_t address, pagebuf_t size)
{
do
{
sendchar( eeprom_read_byte( (uint8_t*)address ) );
address++;
size--; // Decrease number of bytes to read
}
while (size); // Repeat until block has been read
return address;
}
#if defined(ENABLEREADFUSELOCK)
static uint8_t read_fuse_lock(uint16_t addr)
{
uint8_t mode = (1<<BLBSET) | (1<<SPMEN);
uint8_t retval;
asm volatile
(
"movw r30, %3\n\t" /* Z to addr */ \
"sts %0, %2\n\t" /* set mode in SPM_REG */ \
"lpm\n\t" /* load fuse/lock value into r0 */ \
"mov %1,r0\n\t" /* save return value */ \
: "=m" (SPM_REG),
"=r" (retval)
: "r" (mode),
"r" (addr)
: "r30", "r31", "r0"
);
return retval;
}
#endif
static void send_boot(void)
{
sendchar('A');
sendchar('V');
sendchar('R');
sendchar('B');
sendchar('O');
sendchar('O');
sendchar('T');
}
static void (*jump_to_app)(void) = 0x0000;
int main(void)
{
uint16_t address = 0;
uint8_t device = 0, val;
#ifdef ENABLE_BOOT_LED // LED ON
BIPORT |= (1<<BIPNUM);
BIDDR |= (1<<BIPNUM);
#endif
#ifdef DISABLE_WDT_AT_STARTUP
#ifdef WDT_OFF_SPECIAL
#warning "using target specific watchdog_off"
bootloader_wdt_off();
#else
cli();
wdt_reset();
wdt_disable();
#endif
#endif
#ifdef START_POWERSAVE
uint8_t OK = 1;
#endif
BLDDR &= ~(1<<BLPNUM); // set as Input
BLPORT |= (1<<BLPNUM); // Enable pullup
// Set baud rate
UART_BAUD_HIGH = (UART_CALC_BAUDRATE(BAUDRATE)>>8) & 0xFF;
UART_BAUD_LOW = (UART_CALC_BAUDRATE(BAUDRATE) & 0xFF);
#ifdef UART_DOUBLESPEED
UART_STATUS = ( 1<<UART_DOUBLE );
#endif
UART_CTRL = UART_CTRL_DATA;
UART_CTRL2 = UART_CTRL2_DATA;
#if defined(START_POWERSAVE)
/*
This is an adoption of the Butterfly Bootloader startup-sequence.
It may look a little strange but separating the login-loop from
the main parser-loop gives a lot a possibilities (timeout, sleep-modes
etc.).
*/
for(;OK;)
{
if ((BLPIN & (1<<BLPNUM)))
{
// jump to main app if pin is not grounded
BLPORT &= ~(1<<BLPNUM); // set to default
#ifdef UART_DOUBLESPEED
UART_STATUS &= ~( 1<<UART_DOUBLE );
#endif
#ifdef ENABLE_BOOT_LED // LED OFF
BIPORT &= ~(1<<BIPNUM);
BIDDR &= ~(1<<BIPNUM);
#endif
jump_to_app(); // Jump to application sector
}
else
{
val = recvchar();
/* ESC */
if (val == 0x1B)
{
// AVRPROG connection
// Wait for signon
while (val != 'S')
val = recvchar();
send_boot(); // Report signon
OK = 0;
}
else
{
sendchar('?');
}
}
// Power-Save code here
}
#elif defined(START_SIMPLE)
if ((BLPIN & (1<<BLPNUM))) {
// jump to main app if pin is not grounded
BLPORT &= ~(1<<BLPNUM); // set to default
#ifdef UART_DOUBLESPEED
UART_STATUS &= ~( 1<<UART_DOUBLE );
#endif
#ifdef ENABLE_BOOT_LED // LED OFF
BIPORT &= ~(1<<BIPNUM);
BIDDR &= ~(1<<BIPNUM);
#endif
jump_to_app(); // Jump to application sector
}
#elif defined(START_WAIT)
uint16_t cnt = 0;
while (1) {
if (UART_STATUS & (1<<UART_RXREADY))
if (UART_DATA == START_WAIT_UARTCHAR)
break;
if (cnt++ >= WAIT_VALUE) {
BLPORT &= ~(1<<BLPNUM); // set to default
#ifdef ENABLE_BOOT_LED // LED OFF
BIPORT &= ~(1<<BIPNUM);
BIDDR &= ~(1<<BIPNUM);
#endif
jump_to_app(); // Jump to application sector
}
_delay_ms(10);
}
send_boot();
#elif defined(START_BOOTICE)
#warning "BOOTICE mode - no startup-condition"
#else
#error "Select START_ condition for bootloader in main.c"
#endif
for(;;)
{
val = recvchar();
// Autoincrement?
if (val == 'a')
{
sendchar('Y'); // Autoincrement is quicker
//write address
}
else if (val == 'A')
{
address = recvchar(); //read address 8 MSB
address = (address<<8) | recvchar();
sendchar('\r');
// Buffer load support
}
else if (val == 'b')
{
sendchar('Y'); // Report buffer load supported
sendchar((sizeof(gBuffer) >> 8) & 0xFF); // Report buffer size in bytes
sendchar(sizeof(gBuffer) & 0xFF);
// Start buffer load
}
else if (val == 'B')
{
pagebuf_t size;
size = recvchar() << 8; // Load high byte of buffersize
size |= recvchar(); // Load low byte of buffersize
val = recvchar(); // Load memory type ('E' or 'F')
recvBuffer(size);
if (device == DEVTYPE)
{
if (val == 'F')
{
address = writeFlashPage(address, size);
}
else if (val == 'E')
{
address = writeEEpromPage(address, size);
}
sendchar('\r');
}
else
{
sendchar(0);
}
// Block read
}
else if (val == 'g')
{
pagebuf_t size;
size = recvchar() << 8; // Load high byte of buffersize
size |= recvchar(); // Load low byte of buffersize
val = recvchar(); // Get memtype
if (val == 'F')
{
address = readFlashPage(address, size);
}
else if (val == 'E')
{
address = readEEpromPage(address, size);
}
// Chip erase
}
else if (val == 'e')
{
if (device == DEVTYPE)
{
eraseFlash();
}
sendchar('\r');
// Exit upgrade
}
else if (val == 'E')
{
wdt_enable(EXIT_WDT_TIME); // Enable Watchdog Timer to give reset
sendchar('\r');
#ifdef WRITELOCKBITS
#warning "Extension 'WriteLockBits' enabled"
// TODO: does not work reliably
// write lockbits
}
else if (val == 'l')
{
if (device == DEVTYPE)
{
// write_lock_bits(recvchar());
boot_lock_bits_set(recvchar()); // boot.h takes care of mask
boot_spm_busy_wait();
}
sendchar('\r');
#endif
// Enter programming mode
}
else if (val == 'P')
{
sendchar('\r');
// Leave programming mode
}
else if (val == 'L')
{
sendchar('\r');
// return programmer type
}
else if (val == 'p')
{
sendchar('S'); // always serial programmer
#ifdef ENABLEREADFUSELOCK
#warning "Extension 'ReadFuseLock' enabled"
// read "low" fuse bits
}
else if (val == 'F')
{
sendchar(read_fuse_lock(GET_LOW_FUSE_BITS));
// read lock bits
}
else if (val == 'r')
{
sendchar(read_fuse_lock(GET_LOCK_BITS));
// read high fuse bits
}
else if (val == 'N')
{
sendchar(read_fuse_lock(GET_HIGH_FUSE_BITS));
// read extended fuse bits
}
else if (val == 'Q')
{
sendchar(read_fuse_lock(GET_EXTENDED_FUSE_BITS));
#endif
// Return device type
}
else if (val == 't')
{
sendchar(DEVTYPE);
sendchar(0);
// clear and set LED ignored
}
else if ((val == 'x') || (val == 'y'))
{
recvchar();
sendchar('\r');
// set device
}
else if (val == 'T')
{
device = recvchar();
sendchar('\r');
// Return software identifier
}
else if (val == 'S')
{
send_boot();
// Return Software Version
}
else if (val == 'V') {
sendchar(VERSION_HIGH);
sendchar(VERSION_LOW);
// Return Signature Bytes (it seems that
// AVRProg expects the "Atmel-byte" 0x1E last
// but shows it first in the dialog-window)
}
else if (val == 's')
{
sendchar(SIG_BYTE3);
sendchar(SIG_BYTE2);
sendchar(SIG_BYTE1);
/* ESC */
}
else if(val != 0x1b)
{
sendchar('?');
}
}
return 0;
}

669
boot/makefile Executable file
View File

@ -0,0 +1,669 @@
# Hey Emacs, this is a -*- makefile -*-
#
# Makefile for the AVRProg-compatible Bootloader
#
# based on the
# WinAVR Sample makefile written by Eric B. Weddington, Jörg Wunsch, et al.
# Released to the Public Domain
# Please read the make user manual!
#
# Additional material for this makefile was submitted by:
# Tim Henigan
# Peter Fleury
# Reiner Patommel
# Sander Pool
# Frederik Rouleau
# Markus Pfaff
#
# On command line:
#
# make all = Make software.
#
# make clean = Clean out built project files.
#
# make coff = Convert ELF to AVR COFF (for use with AVR Studio 3.x or VMLAB).
#
# make extcoff = Convert ELF to AVR Extended COFF (for use with AVR Studio
# 4.07 or greater).
#
# make program = Download the hex file to the device, using avrdude. Please
# customize the avrdude settings below first!
#
# make filename.s = Just compile filename.c into the assembler code only
#
# To rebuild project do "make clean" then "make all".
#
# user defined values
# MCU name
MCU = atmega8
##MCU = atmega16
## MCU = atmega162
## MCU = atmega169
## MCU = atmega32
## MCU = atmega324p
## MCU = atmega64
## MCU = atmega644
## MCU = atmega644p
## MCU = atmega128
## MCU = at90can128
################## BOOTLOADER ######################
# mt: Boot loader support. So far not done with a separate section
# to get the interrupt vector into the bootloader area (for BOOTINTVEC=yes).
# Bootloader address in datasheet and stk500 is given as
# "word", gcc toolchain needs "byte"-address
# (see LDFLAGS further down)
#/* Select Boot Size in Words (select one, comment out the others) */
## NO! BOOTSIZE=128
## NO! BOOTSIZE=256
BOOTSIZE=512
## BOOTSIZE=1024
## BOOTSIZE=2048
# /* Select if bootloader should include the inverrupt-vectors
# when selecting 'no' here, the bootloader must not use
# any interrupts and the modified linker-scripts are used. */
##BOOTINTVEC=yes
BOOTINTVEC=no
##
ifeq ($(MCU), atmega8)
BFD_MACH=avr4
ifeq ($(BOOTSIZE), 128)
MT_BOOTLOADER_ADDRESS = 0x1F00
endif
ifeq ($(BOOTSIZE), 256)
MT_BOOTLOADER_ADDRESS = 0x1E00
endif
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x1C00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x1800
endif
endif
##
ifeq ($(MCU), atmega16)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 128)
MT_BOOTLOADER_ADDRESS = 0x3F00
endif
ifeq ($(BOOTSIZE), 256)
MT_BOOTLOADER_ADDRESS = 0x3E00
endif
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x3C00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x3800
endif
endif
##
ifeq ($(MCU), atmega162)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 128)
MT_BOOTLOADER_ADDRESS = 0x3F00
endif
ifeq ($(BOOTSIZE), 256)
MT_BOOTLOADER_ADDRESS = 0x3E00
endif
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x3C00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x3800
endif
endif
##
ifeq ($(MCU), atmega169)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 128)
MT_BOOTLOADER_ADDRESS = 0x3F00
endif
ifeq ($(BOOTSIZE), 256)
MT_BOOTLOADER_ADDRESS = 0x3E00
endif
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x3C00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x3800
endif
endif
##
ifeq ($(MCU), atmega32)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 256)
MT_BOOTLOADER_ADDRESS = 0x7E00
endif
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x7C00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x7800
endif
ifeq ($(BOOTSIZE), 2048)
MT_BOOTLOADER_ADDRESS = 0x7000
endif
endif
##
ifeq ($(MCU), atmega324p)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 256)
MT_BOOTLOADER_ADDRESS = 0x7E00
endif
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x7C00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x7800
endif
ifeq ($(BOOTSIZE), 2048)
MT_BOOTLOADER_ADDRESS = 0x7000
endif
endif
##
ifeq ($(MCU), atmega64)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0xFC00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0xF800
endif
ifeq ($(BOOTSIZE), 2048)
MT_BOOTLOADER_ADDRESS = 0xF000
endif
ifeq ($(BOOTSIZE), 4096)
MT_BOOTLOADER_ADDRESS = 0xE000
endif
endif
##
ifeq ($(MCU), atmega644)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0xFC00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0xF800
endif
ifeq ($(BOOTSIZE), 2048)
MT_BOOTLOADER_ADDRESS = 0xF000
endif
ifeq ($(BOOTSIZE), 4096)
MT_BOOTLOADER_ADDRESS = 0xE000
endif
endif
##
ifeq ($(MCU), atmega644p)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0xFC00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0xF800
endif
ifeq ($(BOOTSIZE), 2048)
MT_BOOTLOADER_ADDRESS = 0xF000
endif
ifeq ($(BOOTSIZE), 4096)
MT_BOOTLOADER_ADDRESS = 0xE000
endif
endif
##
ifeq ($(MCU), atmega128)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x1FC00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x1F800
endif
ifeq ($(BOOTSIZE), 2048)
MT_BOOTLOADER_ADDRESS = 0x1F000
endif
ifeq ($(BOOTSIZE), 4096)
MT_BOOTLOADER_ADDRESS = 0x1E000
endif
endif
##
ifeq ($(MCU), at90can128)
BFD_MACH=avr5
ifeq ($(BOOTSIZE), 512)
MT_BOOTLOADER_ADDRESS = 0x1FC00
endif
ifeq ($(BOOTSIZE), 1024)
MT_BOOTLOADER_ADDRESS = 0x1F800
endif
ifeq ($(BOOTSIZE), 2048)
MT_BOOTLOADER_ADDRESS = 0x1F000
endif
ifeq ($(BOOTSIZE), 4096)
MT_BOOTLOADER_ADDRESS = 0x1E000
endif
endif
# Output format. (can be srec, ihex, binary)
FORMAT = ihex
#FORMAT = srec
# Target file name (without extension).
TARGET = main
# List C source files here. (C dependencies are automatically generated.)
SRC = $(TARGET).c
# List Assembler source files here.
# Make them always end in a capital .S. Files ending in a lowercase .s
# will not be considered source files but generated files (assembler
# output from the compiler), and will be deleted upon "make clean"!
# Even though the DOS/Win* filesystem matches both .s and .S the same,
# it will preserve the spelling of the filenames, and gcc itself does
# care about how the name is spelled on its command-line.
ASRC =
# Optimization level, can be [0, 1, 2, 3, s].
# 0 = turn off optimization. s = optimize for size.
# (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
OPT = s
# Debugging format.
# Native formats for AVR-GCC's -g are stabs [default], or dwarf-2.
# AVR (extended) COFF requires stabs, plus an avr-objcopy run.
DEBUG = stabs
# List any extra directories to look for include files here.
# Each directory must be seperated by a space.
EXTRAINCDIRS =
# Compiler flag to set the C Standard level.
# c89 - "ANSI" C
# gnu89 - c89 plus GCC extensions
# c99 - ISO C99 standard (not yet fully implemented)
# gnu99 - c99 plus GCC extensions
CSTANDARD = -std=gnu99
# Place -D or -U options here
CDEFS = -DBOOTSIZE=$(BOOTSIZE)
# Place -I options here
CINCS =
# Compiler flags.
# -g*: generate debugging information
# -O*: optimization level
# -f...: tuning, see GCC manual and avr-libc documentation
# -Wall...: warning level
# -Wa,...: tell GCC to pass this to the assembler.
# -adhlns...: create assembler listing
CFLAGS = -g$(DEBUG)
CFLAGS += $(CDEFS) $(CINCS)
CFLAGS += -O$(OPT)
CFLAGS += -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums
CFLAGS += -Wall -Wstrict-prototypes
CFLAGS += -Wa,-adhlns=$(<:.c=.lst)
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
CFLAGS += $(CSTANDARD)
# Assembler flags.
# -Wa,...: tell GCC to pass this to the assembler.
# -ahlms: create listing
# -gstabs: have the assembler create line number information; note that
# for use in COFF files, additional information about filenames
# and function names needs to be present in the assembler source
# files -- see avr-libc docs [FIXME: not yet described there]
ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs
#Additional libraries.
# Minimalistic printf version
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min
# Floating point printf version (requires MATH_LIB = -lm below)
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt
PRINTF_LIB =
# Minimalistic scanf version
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min
# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt
SCANF_LIB =
MATH_LIB = -lm
# External memory options
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# used for variables (.data/.bss) and heap (malloc()).
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# only used for heap (malloc()).
#EXTMEMOPTS = -Wl,--defsym=__heap_start=0x801100,--defsym=__heap_end=0x80ffff
EXTMEMOPTS =
# Linker flags.
# -Wl,...: tell GCC to pass this to linker.
# -Map: create map file
# --cref: add cross reference to map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
################## BOOTLOADER ######################
# MT_BOOTLOADER_ADDRESS (=Start of Boot Loader section
# in bytes - not words) as defined above.
LDFLAGS += -Wl,--section-start=.text=$(MT_BOOTLOADER_ADDRESS)
# check if linker-scripts without interrupt-vectors should
# be used and set linker-option, announce to C-code by define
ifeq ($(BOOTINTVEC), no)
LDFLAGS += -T./ldscripts_no_vector/$(BFD_MACH).x
CFLAGS += -DBOOTLOADERHASNOVECTORS
endif
# Programming support using avrdude. Settings and variables.
# Programming hardware: alf avr910 avrisp bascom bsd
# dt006 pavr picoweb pony-stk200 sp12 stk200 stk500
#
# Type: avrdude -c ?
# to get a full listing.
#
AVRDUDE_PROGRAMMER = stk500v2
# com1 = serial port. Use lpt1 to connect to parallel port.
AVRDUDE_PORT = com1 # programmer connected to serial device
#AVRDUDE_PORT = /dev/ttyS0 # programmer connected to serial device
AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
# Uncomment the following if you want avrdude's erase cycle counter.
# Note that this counter needs to be initialized first using -Yn,
# see avrdude manual.
#AVRDUDE_ERASE_COUNTER = -y
# Uncomment the following if you do /not/ wish a verification to be
# performed after programming the device.
#AVRDUDE_NO_VERIFY = -V
# Increase verbosity level. Please use this when submitting bug
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude>
# to submit bug reports.
#AVRDUDE_VERBOSE = -v -v
AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)
# ---------------------------------------------------------------------------
# Define directories, if needed.
DIRAVR = c:/Hard/WinAVR-20100110
DIRAVRBIN = $(DIRAVR)/bin
DIRAVRUTILS = $(DIRAVR)/utils/bin
DIRINC = .
DIRLIB = $(DIRAVR)/avr/lib
# Define programs and commands.
#SHELL = $(DIRAVRUTILS)/sh
#NM = $(DIRAVRBIN)/avr-nm
#CC = $(DIRAVRBIN)/avr-gcc
#OBJCOPY = $(DIRAVRBIN)/avr-objcopy
#OBJDUMP= $(DIRAVRBIN)/avr-objdump
#SIZE = $(DIRAVRBIN)/avr-size
#AVRDUDE = $(DIRAVRBIN)/avrdude.sh
#REMOVE = rm -f
#COPY = cp
# Define programs and commands.
SHELL = sh
CC = avr-gcc
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
SIZE = avr-size
NM = avr-nm
AVRDUDE = avrdude
REMOVE = rm -f
COPY = cp
WINSHELL = cmd
# Define Messages
# English
MSG_ERRORS_NONE = Errors: none
MSG_BEGIN = -------- begin --------
MSG_END = -------- end --------
MSG_SIZE_BEFORE = Size before:
MSG_SIZE_AFTER = Size after:
MSG_COFF = Converting to AVR COFF:
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
MSG_FLASH = Creating load file for Flash:
MSG_EEPROM = Creating load file for EEPROM:
MSG_EXTENDED_LISTING = Creating Extended Listing:
MSG_SYMBOL_TABLE = Creating Symbol Table:
MSG_LINKING = Linking:
MSG_COMPILING = Compiling:
MSG_ASSEMBLING = Assembling:
MSG_CLEANING = Cleaning project:
# Define all object files.
OBJ = $(SRC:.c=.o) $(ASRC:.S=.o)
# Define all listing files.
LST = $(ASRC:.S=.lst) $(SRC:.c=.lst)
# Compiler flags to generate dependency files.
### GENDEPFLAGS = -Wp,-M,-MP,-MT,$(*F).o,-MF,.dep/$(@F).d
GENDEPFLAGS = -MD -MP -MF .dep/$(@F).d
# Combine all necessary flags and optional flags.
# Add target processor to flags.
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
# Default target.
all: begin gccversion sizebefore build sizeafter finished end
build: elf hex eep lss sym
elf: $(TARGET).elf
hex: $(TARGET).hex
eep: $(TARGET).eep
lss: $(TARGET).lss
sym: $(TARGET).sym
# Eye candy.
# AVR Studio 3.x does not check make's exit code but relies on
# the following magic strings to be generated by the compile job.
begin:
@echo
@echo $(MSG_BEGIN)
finished:
@echo $(MSG_ERRORS_NONE)
end:
@echo $(MSG_END)
@echo
# Display size of file.
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
ELFSIZE = $(SIZE) -x -A $(TARGET).elf
sizebefore:
@if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); echo; fi
sizeafter:
@if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); echo; fi
# Display compiler version information.
gccversion :
@$(CC) --version
# Program the device.
program: $(TARGET).hex $(TARGET).eep
$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)
# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
COFFCONVERT=$(OBJCOPY) --debugging \
--change-section-address .data-0x800000 \
--change-section-address .bss-0x800000 \
--change-section-address .noinit-0x800000 \
--change-section-address .eeprom-0x810000
coff: $(TARGET).elf
@echo
@echo $(MSG_COFF) $(TARGET).cof
$(COFFCONVERT) -O coff-avr $< $(TARGET).cof
extcoff: $(TARGET).elf
@echo
@echo $(MSG_EXTENDED_COFF) $(TARGET).cof
$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
# Create final output files (.hex, .eep) from ELF output file.
%.hex: %.elf
@echo
@echo $(MSG_FLASH) $@
$(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@
%.eep: %.elf
@echo
@echo $(MSG_EEPROM) $@
-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
--change-section-lma .eeprom=0 -O $(FORMAT) $< $@
# Create extended listing file from ELF output file.
%.lss: %.elf
@echo
@echo $(MSG_EXTENDED_LISTING) $@
$(OBJDUMP) -h -S $< > $@
# Create a symbol table from ELF output file.
%.sym: %.elf
@echo
@echo $(MSG_SYMBOL_TABLE) $@
$(NM) -n $< > $@
# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
@echo
@echo $(MSG_LINKING) $@
$(CC) $(ALL_CFLAGS) $(OBJ) --output $@ $(LDFLAGS)
# Compile: create object files from C source files.
%.o : %.c
@echo
@echo $(MSG_COMPILING) $<
$(CC) -c $(ALL_CFLAGS) $< -o $@
# Compile: create assembler files from C source files.
%.s : %.c
$(CC) -S $(ALL_CFLAGS) $< -o $@
# Assemble: create object files from assembler source files.
%.o : %.S
@echo
@echo $(MSG_ASSEMBLING) $<
$(CC) -c $(ALL_ASFLAGS) $< -o $@
# Target: clean project.
clean: begin clean_list finished end
clean_list :
@echo
@echo $(MSG_CLEANING)
$(REMOVE) $(TARGET).hex
$(REMOVE) $(TARGET).eep
$(REMOVE) $(TARGET).obj
$(REMOVE) $(TARGET).cof
$(REMOVE) $(TARGET).elf
$(REMOVE) $(TARGET).map
$(REMOVE) $(TARGET).obj
$(REMOVE) $(TARGET).a90
$(REMOVE) $(TARGET).sym
$(REMOVE) $(TARGET).lnk
$(REMOVE) $(TARGET).lss
$(REMOVE) $(OBJ)
$(REMOVE) $(LST)
$(REMOVE) $(SRC:.c=.s)
$(REMOVE) $(SRC:.c=.d)
$(REMOVE) .dep/*
# Include the dependency files.
-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)
# Listing of phony targets.
.PHONY : all begin finish end sizebefore sizeafter gccversion \
build elf hex eep lss sym coff extcoff \
clean clean_list program

39
boot/mega128.h Executable file
View File

@ -0,0 +1,39 @@
#ifndef _MEGA128_H_
#define _MEGA128_H_
/* Part-Code ISP */
#define DEVTYPE_ISP 0x43
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x44
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x97
#define SIG_BYTE3 0x02
#ifndef UART_USE_SECOND
#define UART_BAUD_HIGH UBRR0H
#define UART_BAUD_LOW UBRR0L
#define UART_STATUS UCSR0A
#define UART_TXREADY UDRE0
#define UART_RXREADY RXC0
#define UART_DOUBLE U2X0
#define UART_CTRL UCSR0B
#define UART_CTRL_DATA ((1<<TXEN0) | (1<<RXEN0))
#define UART_CTRL2 UCSR0C
#define UART_CTRL2_DATA ((1<<UCSZ01) | (1<<UCSZ00))
#define UART_DATA UDR0
#else
#define UART_BAUD_HIGH UBRR1H
#define UART_BAUD_LOW UBRR1L
#define UART_STATUS UCSR1A
#define UART_TXREADY UDRE1
#define UART_RXREADY RXC1
#define UART_DOUBLE U2X1
#define UART_CTRL UCSR1B
#define UART_CTRL_DATA ((1<<TXEN1) | (1<<RXEN1))
#define UART_CTRL2 UCSR1C
#define UART_CTRL2_DATA ((1<<UCSZ11) | (1<<UCSZ10))
#define UART_DATA UDR1
#endif
#endif // #ifndef _MEGA128_H_

42
boot/mega128can.h Executable file
View File

@ -0,0 +1,42 @@
#ifndef _MEGA128CAN_H_
#define _MEGA128CAN_H_
/* Dummy: use ATmega128 device-code for now,
must be same as used in avrdude.conf */
/* Part-Code ISP */
#define DEVTYPE_ISP 0x43
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x44
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x97
#define SIG_BYTE3 0x81
#ifndef UART_USE_SECOND
#define UART_BAUD_HIGH UBRR0H
#define UART_BAUD_LOW UBRR0L
#define UART_STATUS UCSR0A
#define UART_TXREADY UDRE0
#define UART_RXREADY RXC0
#define UART_DOUBLE U2X0
#define UART_CTRL UCSR0B
#define UART_CTRL_DATA ((1<<TXEN0) | (1<<RXEN0))
#define UART_CTRL2 UCSR0C
#define UART_CTRL2_DATA ((1<<UCSZ01) | (1<<UCSZ00))
#define UART_DATA UDR0
#else
#define UART_BAUD_HIGH UBRR1H
#define UART_BAUD_LOW UBRR1L
#define UART_STATUS UCSR1A
#define UART_TXREADY UDRE1
#define UART_RXREADY RXC1
#define UART_DOUBLE U2X1
#define UART_CTRL UCSR1B
#define UART_CTRL_DATA ((1<<TXEN1) | (1<<RXEN1))
#define UART_CTRL2 UCSR1C
#define UART_CTRL2_DATA ((1<<UCSZ11) | (1<<UCSZ10))
#define UART_DATA UDR1
#endif
#endif // #ifndef _MEGA128CAN_H_

25
boot/mega16.h Executable file
View File

@ -0,0 +1,25 @@
#ifndef _MEGA16_H_
#define _MEGA16_H_
/* Part-Code ISP */
#define DEVTYPE_ISP 0x74
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x75
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x94
#define SIG_BYTE3 0x03
#define UART_BAUD_HIGH UBRRH
#define UART_BAUD_LOW UBRRL
#define UART_STATUS UCSRA
#define UART_TXREADY UDRE
#define UART_RXREADY RXC
#define UART_DOUBLE U2X
#define UART_CTRL UCSRB
#define UART_CTRL_DATA ((1<<TXEN) | (1<<RXEN))
#define UART_CTRL2 UCSRC
#define UART_CTRL2_DATA ((1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0))
#define UART_DATA UDR
#endif // #ifndef _MEGA16_H_

45
boot/mega162.h Executable file
View File

@ -0,0 +1,45 @@
#ifndef _MEGA162_H_
#define _MEGA162_H_
/* Part-Code ISP */
// documented code (AVR109 AppNote) but not supported by AVRProg 1.40
// #define DEVTYPE_ISP 0x62
// fake ATmega16 instead:
#define DEVTYPE_ISP 0x74
/* Part-Code Boot */
// documented code but not supported by AVRProg 1.40
// #define DEVTYPE_BOOT 0x63
// fake ATmega16:
#define DEVTYPE_BOOT 0x75
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x94
#define SIG_BYTE3 0x04
#ifndef UART_USE_SECOND
#define UART_BAUD_HIGH UBRR0H
#define UART_BAUD_LOW UBRR0L
#define UART_STATUS UCSR0A
#define UART_TXREADY UDRE0
#define UART_RXREADY RXC0
#define UART_DOUBLE U2X0
#define UART_CTRL UCSR0B
#define UART_CTRL_DATA ((1<<TXEN0) | (1<<RXEN0))
#define UART_CTRL2 UCSR0C
#define UART_CTRL2_DATA ((1<<URSEL0) | (1<<UCSZ01) | (1<<UCSZ00))
#define UART_DATA UDR0
#else
#define UART_BAUD_HIGH UBRR1H
#define UART_BAUD_LOW UBRR1L
#define UART_STATUS UCSR1A
#define UART_TXREADY UDRE1
#define UART_RXREADY RXC1
#define UART_DOUBLE U2X1
#define UART_CTRL UCSR1B
#define UART_CTRL_DATA ((1<<TXEN1) | (1<<RXEN1))
#define UART_CTRL2 UCSR1C
#define UART_CTRL2_DATA ( (1<<URSEL1) | (1<<UCSZ11) | (1<<UCSZ10))
#define UART_DATA UDR1
#endif
#endif // #ifndef _MEGA162_H_

23
boot/mega169.h Executable file
View File

@ -0,0 +1,23 @@
#ifndef _MEGA169_H_
#define _MEGA169_H_
#define DEVTYPE_ISP 0x78
#define DEVTYPE_BOOT 0x79
#define SIG_BYTE3 0x1E
#define SIG_BYTE2 0x94
#define SIG_BYTE1 0x05
#define UART_BAUD_HIGH UBRRH
#define UART_BAUD_LOW UBRRL
#define UART_STATUS UCSRA
#define UART_TXREADY UDRE
#define UART_RXREADY RXC
#define UART_DOUBLE U2X
#define UART_CTRL UCSRB
#define UART_CTRL_DATA ((1<<TXEN) | (1<<RXEN))
#define UART_CTRL2 UCSRC
#define UART_CTRL2_DATA ((1<<UCSZ1) | (1<<UCSZ0))
#define UART_DATA UDR
#endif // #ifndef _MEGA169_H_

25
boot/mega32.h Executable file
View File

@ -0,0 +1,25 @@
#ifndef _MEGA32_H_
#define _MEGA32_H_
/* Part-Code ISP */
#define DEVTYPE_ISP 0x72
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x73
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x95
#define SIG_BYTE3 0x02
#define UART_BAUD_HIGH UBRRH
#define UART_BAUD_LOW UBRRL
#define UART_STATUS UCSRA
#define UART_TXREADY UDRE
#define UART_RXREADY RXC
#define UART_DOUBLE U2X
#define UART_CTRL UCSRB
#define UART_CTRL_DATA ((1<<TXEN) | (1<<RXEN))
#define UART_CTRL2 UCSRC
#define UART_CTRL2_DATA ((1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0))
#define UART_DATA UDR
#endif // #ifndef _MEGA32_H_

17
boot/mega324p.h Executable file
View File

@ -0,0 +1,17 @@
#ifndef _MEGA324P_H_
#define _MEGA324P_H_
/* I (M. Thomas) could not find an official Boot-ID
for the ATmega324P so pretend it's an ATmega32 */
/* Part-Code ISP */
#define DEVTYPE_ISP 0x72
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x73
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x95
#define SIG_BYTE3 0x08
#include "megaxx4p.h"
#endif // #ifndef _MEGA324P_H_

39
boot/mega64.h Executable file
View File

@ -0,0 +1,39 @@
#ifndef _MEGA64_H_
#define _MEGA64_H_
/* Part-Code ISP */
#define DEVTYPE_ISP 0x45
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x46
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x96
#define SIG_BYTE3 0x02
#ifndef UART_USE_SECOND
#define UART_BAUD_HIGH UBRR0H
#define UART_BAUD_LOW UBRR0L
#define UART_STATUS UCSR0A
#define UART_TXREADY UDRE0
#define UART_RXREADY RXC0
#define UART_DOUBLE U2X0
#define UART_CTRL UCSR0B
#define UART_CTRL_DATA ((1<<TXEN0) | (1<<RXEN0))
#define UART_CTRL2 UCSR0C
#define UART_CTRL2_DATA ((1<<UCSZ01) | (1<<UCSZ00))
#define UART_DATA UDR0
#else
#define UART_BAUD_HIGH UBRR1H
#define UART_BAUD_LOW UBRR1L
#define UART_STATUS UCSR1A
#define UART_TXREADY UDRE1
#define UART_RXREADY RXC1
#define UART_DOUBLE U2X1
#define UART_CTRL UCSR1B
#define UART_CTRL_DATA ((1<<TXEN1) | (1<<RXEN1))
#define UART_CTRL2 UCSR1C
#define UART_CTRL2_DATA ((1<<UCSZ11) | (1<<UCSZ10))
#define UART_DATA UDR1
#endif
#endif // #ifndef _MEGA64_H_

42
boot/mega644.h Executable file
View File

@ -0,0 +1,42 @@
#ifndef _MEGA644_H_
#define _MEGA644_H_
/* I (M. Thomas) could not find an official Boot-ID
for the ATmega644 so pretend it's an ATmega64 */
/* Part-Code ISP */
#define DEVTYPE_ISP 0x45
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x46
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x96
#define SIG_BYTE3 0x09
#define UART_BAUD_HIGH UBRR0H
#define UART_BAUD_LOW UBRR0L
#define UART_STATUS UCSR0A
#define UART_TXREADY UDRE0
#define UART_RXREADY RXC0
#define UART_DOUBLE U2X0
#define UART_CTRL UCSR0B
#define UART_CTRL_DATA ((1<<TXEN0) | (1<<RXEN0))
#define UART_CTRL2 UCSR0C
#define UART_CTRL2_DATA ( (1<<UCSZ01) | (1<<UCSZ00))
#define UART_DATA UDR0
#define WDT_OFF_SPECIAL
static inline void bootloader_wdt_off(void)
{
cli();
wdt_reset();
/* Clear WDRF in MCUSR */
MCUSR &= ~(1<<WDRF);
/* Write logical one to WDCE and WDE */
/* Keep old prescaler setting to prevent unintentional time-out */
WDTCSR |= (1<<WDCE) | (1<<WDE);
/* Turn off WDT */
WDTCSR = 0x00;
}
#endif // #ifndef _MEGA644_H_

17
boot/mega644p.h Executable file
View File

@ -0,0 +1,17 @@
#ifndef _MEGA644P_H_
#define _MEGA644P_H_
/* I (M. Thomas) could not find an official Boot-ID
for the ATmega644P so pretend it's an ATmega64 */
/* Part-Code ISP */
#define DEVTYPE_ISP 0x45
/* Part-Code Boot */
#define DEVTYPE_BOOT 0x46
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x96
#define SIG_BYTE3 0x0A
#include "megaxx4p.h"
#endif // #ifndef _MEGA644P_H_

25
boot/mega8.h Executable file
View File

@ -0,0 +1,25 @@
#ifndef _MEGA8_H_
#define _MEGA8_H_
/* Part-Code ISP */
#define DEVTYPE_ISP 0x76
/* Part-Code BOOT */
#define DEVTYPE_BOOT 0x77
#define SIG_BYTE1 0x1E
#define SIG_BYTE2 0x93
#define SIG_BYTE3 0x07
#define UART_BAUD_HIGH UBRRH
#define UART_BAUD_LOW UBRRL
#define UART_STATUS UCSRA
#define UART_TXREADY UDRE
#define UART_RXREADY RXC
#define UART_DOUBLE U2X
#define UART_CTRL UCSRB
#define UART_CTRL_DATA ((1<<TXEN) | (1<<RXEN))
#define UART_CTRL2 UCSRC
#define UART_CTRL2_DATA ((1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0))
#define UART_DATA UDR
#endif // #ifndef _MEGA8_H_

47
boot/megaxx4p.h Executable file
View File

@ -0,0 +1,47 @@
#ifndef _MEGAxx4_H_
#define _MEGAxx4_H_
#ifndef UART_USE_SECOND
/* UART 0 */
#define UART_BAUD_HIGH UBRR0H
#define UART_BAUD_LOW UBRR0L
#define UART_STATUS UCSR0A
#define UART_TXREADY UDRE0
#define UART_RXREADY RXC0
#define UART_DOUBLE U2X0
#define UART_CTRL UCSR0B
#define UART_CTRL_DATA ((1<<TXEN0) | (1<<RXEN0))
#define UART_CTRL2 UCSR0C
#define UART_CTRL2_DATA ( (1<<UCSZ01) | (1<<UCSZ00))
#define UART_DATA UDR0
#else
/* UART 1 */
#define UART_BAUD_HIGH UBRR1H
#define UART_BAUD_LOW UBRR1L
#define UART_STATUS UCSR1A
#define UART_TXREADY UDRE1
#define UART_RXREADY RXC1
#define UART_DOUBLE U2X1
#define UART_CTRL UCSR1B
#define UART_CTRL_DATA ((1<<TXEN1) | (1<<RXEN1))
#define UART_CTRL2 UCSR1C
#define UART_CTRL2_DATA ( (1<<UCSZ11) | (1<<UCSZ10))
#define UART_DATA UDR1
#endif
#define WDT_OFF_SPECIAL
static inline void bootloader_wdt_off(void)
{
cli();
wdt_reset();
/* Clear WDRF in MCUSR */
MCUSR &= ~(1<<WDRF);
/* Write logical one to WDCE and WDE */
/* Keep old prescaler setting to prevent unintentional time-out */
WDTCSR |= (1<<WDCE) | (1<<WDE);
/* Turn off WDT */
WDTCSR = 0x00;
}
#endif // #ifndef _MEGA644_H_

267
boot/readme.txt Executable file
View File

@ -0,0 +1,267 @@
======================================================
ATMEL AVR UART Bootloader for AVR-GCC/avr-libc
by Martin Thomas, Kaiserslautern, Germany
mthomas@rhrk.uni-kl.de
eversmith@heizung-thomas.de
http://www.siwawi.arubi.uni-kl.de/avr_projects
** Addtional code and improvements contributed **
** by Uwe Bonnes, Bjoern Riemer and Olaf Rempel. **
Eearly versions of this bootloader-code have been
based on the AVR Butterfly bootloader-source REV02
which has been available from atmel.com.
======================================================
Programming-Software (on the "PC-Side"):
* AVRProg (included in AVRStudio) available at www.atmel.com.
MS-Windows only. AVRProg can be used as stand-alone application.
(avrprog.exe)
* avrdude available at http://savannah.nongnu.org/projects/avrdude/
"Multiplattform"
* Installation instructions at the end of this file.
3. Dec. 2008 - Version 0.85
* disable U2X before jump to app as suggested be Alexander Döller
* moved UBRR-macros to main.c and changed them. Inspired by code from avr-libc setbaud.
(macros which are commented out (//) are from Pavel Fertser)
6. Nov. 2008 - Version 0.84
* Added definitions for ATmega64 provided by Pavel Fertser - Thanks.
12. Apr. 2008 - Version 0.83
* Added definitions for ATmega644P and ATmega324P
* Tested with ATmega324P, gcc 4.2.2, avr-libc 1.4.6
* Added testapp to verify "exit bootloader" with
watchdog (n.b.: watchdog-disable called early in testapp)
27. Jan. 2007 - Version 0.82
* Added definitions for ATmega644.
* Using avr-lib's eeprom-functions (old "direct-access"-code
has not been compatible with ATmega644).
* Watchdog-disable at startup (configurable): avoids problems with
repeated login to bootloader. Not needed if the bootloader is
never re-entered again between an "exit programming" and
a system-reset/power-toogle.
* Additional watchdog disable-function for ATmega644.
* Made watchdog-enable time at exit-programming a configuration-value
(define).
* Bootloader read-protection: if enabled the bootloader fakes
an empty boot-section (configurable by define)
Since more of the avr-libc functions's are used this version
should be more portable for other AVRs but the size of the
binary increases a little bit.
Make sure to disable the watchdog early in the user-application
esp. when using a "modern" AVR (i.e. ATmega48/88/168/644/324P/644P).
3. Dec. 2006 - Version 0.81
* Added definitions for ATmega162.
* Fixed init for double-speed (bitmask). Thanks to Bernhard Roth
28. May 2006 - Version 0.8beta3
* Supports discarding of interrupt-vectors which saves some space
if no interrupts are needed in the bootloader. Added option
in makefile to enable this feature, modified LDFLAGS,
additional code in main.c for a pseudo default_interrupt ISR.
The modified linker-scripts have been contributed by
Olaf Rempel (basicly just the .vector-section is not linked).
* Reverted the order of signatur-byte-numbers in part-
configurations to the usual order in the datasheet,
also reverted in main.c for sending the signature.
* Definitions for lock/fuse-readout.
* Updated installation-instruction at the end of this file.
* Added DEVTYPE_ISP/DEVTYPE_BOOT to part-configurations,
added configuration-option for this in main.c.
* A remark about the DEVTYPE: Usualy there are two
Part-Codes/Device-Codes. One is for ISP: AVRProg shows
the type of the AVR. The other code is for bootloading:
AVRprog shows the type plus "BOOT". When a boot-device-code
gets detected by AVRprog it "knows" how do handle the
limited functionality of bootloaders. (When receiving the
ISP-code AVRProg expects an AVR910-type programmer.)
The offset between the codes is usualy 0x01 where the
ISP-code is the smaller value, i.e. ATmega32 ISP-code
is 0x72->"ATmega32" and boot-code is 0x73->"ATmega32 BOOT".
When using avrdude the bootloader's device-code must match
the device-code in the avrdude.conf. Check the avrdude-
code to see if both codes (AVR910 and AVR109) are supported.
-- I have got some e-mails from users which have been
confused by this. Hopefully this explanation is good enough.
* This bootloader lets the watchdog do a reset when the
user selects "Exit programmer" (i.e. in AVRProg) after an
update. Make sure to disable or reset the watchdog early in
your application.
27. May 2006 - Version 0.8beta2
* More very well done improvements contributed by Olaf Rempel.
* Olaf Rempel also modified the STARTUP_WAIT method.
21. May 2006 - Version 0.8beta
* Version contributed by Olaf Rempel. He has done a lot of modifications.
-> "cleaner code", smaller binaries.
09. Feb. 2006 - Version 0.75
* additional STARTUP_WAIT support contributed by Bjoern Riemer
18. Aug. 2005 - Version 0.74
* AT90CAN128 support contributed by Uwe Bonnes
* Makefile modifications contributed by Uwe Bonnes
23. Feb. 2005 - Version 0.7
* (Version 0.6 has never been available on the web-page)
* ATmega128 support
* code cleanup
* This version has been tested with ATmega8, ATmega32 and
ATmega128
7. Apr. 2004 - Version 0.5
* added different startup-methods
* compatible with ATmega8 now
* included makefile adapted to ATmega8 now
(ATmega16 options still available)
* fixed jump to application which did not work
reliably before
* tested with ATmega8
* minimal options and startup-code result in
bootloader-size < 512 words
6. Apr. 2004 - Version 0.4
* Buffered read of chars from UART during programming
since eeprom-write is too slow for unbuffered
operation. So EEPROM-upload does work now.
* Added BOOTICE-mode to flash JTAGICE-compatible
hardware (ATmega16@7,3Mhz) (if you know about BOOTICE,
you may unterstand why this has been added, if not
just keep the option disabled)
* small changes in (my)boot.h (lock-bit-mask) found
out during the development of the STK-500-compatible
bootloader. But setting lock-bits still does not
work with this bootloader.
* read of the low-fuse byte works (high byte still TODO)
* read of the lock-byte works (write still TODO)
27. Mar 2004 - Version 0.3
Felt that as much functions from avr-libc's boot.h
as possible should be used without modifications.
Latest CVS-version of boot.h is included.
Only the read-routine is still "self-made" based
on ATMELs assembler-code.
EEPROM write on Mega16 does not work (and did not
work with V0.2 too). May be caused by my old Mega16
chip. Needs testing. Flash read/write and EEPROM
read works. Still only tested with ATmega16.
This version may not work with the ATmega169 any
more.
24. Mar 2004 - Version 0.2
During the development of a data-logger application
with the AVR-Butterfly there was a need to make
some changes in the bootloader. The same problem
again: no IAR compiler. The same way to solve the
problem: a port of the code to avr-gcc/avr-libc.
So this code is based on the ATMEL Butterfly
bootloader source code Rev 0.2 for IAR.
The bootloader-port for the Butterfly which mimics
the complete functionality of the original
BF-bootloader is availabe at:
www.siwawi.arubi.uni-kl.de/avr_projects
Atmel used a separate "lib" written in "pure"
assembly to access the low-level functions
for flash read/write. Well, so far I
don't know how to use "mixed language sources"
with the avr-gcc toolchain, so the low-level
routines have been implemented as inline assembler.
The avr-libc boot.h module written by Eric
Weddington served as a template Three of the four
low-level routines found in lowlevel.c come from
boot.h with minimal changes. The read routine has
been developed based on the ATMEL assembler code.
Ignore the fuse and lock-bit readout. Read and Set is
not enabled (TODO).
--------------- Installation -----------------
- Change the MCU type in the makefile.
- Change the boot(loader)-size in Makefile. The needed
space depends on the features selected in main.c
- Set baudrate in main.c, a doublespeed configuration-option
is available too.
- Change the F_CPU in main.c to the clock-frequency
of your board. See the datasheet for frequencies
with minimum error at the selected baudrate.
- Select the start-condition in main.c.
- Please use at least avr-gcc 3.3.1/avr-libc 1.0
or WINAVR Sept. 2003 or later to compile and link
this bootloader.
- Upload the hex-File to the AVR (STK500, STK200, SP12
evertool, AVR910 etc.)
- Program the "Boot Flash section size" (BOOTSZ fuses)
according to the boot-size selected in the makefile
i.e. BOOTSZ=00 for boot-size 1024 words (2048 bytes)
on ATmega16
- enable the BOOT Reset Vector fuse (BOOTRST=0)
- Set the lock bits to protect the bootloader from
SPM-writes (Boot Loader Protection Mode 2 in STK500-
plugin) so that it can not overwrite itself.
- Connect the AVR UART Pins via level-shifter/inverter
(i.e. MAX232) to your PCs COM-Port.
- Reset the AVR while fullfilling the bootloader start-
condition. (Default: selected pin connected to GND).
The condition must be "true" until you see the
AVRPROG dialog or avrdude connects.
- Start AVRPROG (AVRStudio/Tools or stand-alone avrprog.exe)
AVRDUDE is supported too, check it's manual
for command-line options. Read the text above for
information about Device-Types and AVRDUDE
- AVRPROG or AVRDUDE should detect the bootloader.
- see AVRStudio's online-help for more information how
to use AVRPROG
- make sure to EXIT from AVRPROG (button) to start
your main-application or toogle power/reset.
Feedback welcome, Good luck.
Martin

619
boot/testapp/Makefile Executable file
View File

@ -0,0 +1,619 @@
# Hey Emacs, this is a -*- makefile -*-
#----------------------------------------------------------------------------
# WinAVR Makefile Template written by Eric B. Weddington, Jörg Wunsch, et al.
#
# Released to the Public Domain
#
# Additional material for this makefile was written by:
# Peter Fleury
# Tim Henigan
# Colin O'Flynn
# Reiner Patommel
# Markus Pfaff
# Sander Pool
# Frederik Rouleau
# Carlos Lamas
#
#----------------------------------------------------------------------------
# On command line:
#
# make all = Make software.
#
# make clean = Clean out built project files.
#
# make coff = Convert ELF to AVR COFF.
#
# make extcoff = Convert ELF to AVR Extended COFF.
#
# make program = Download the hex file to the device, using avrdude.
# Please customize the avrdude settings below first!
#
# make debug = Start either simulavr or avarice as specified for debugging,
# with avr-gdb or avr-insight as the front end for debugging.
#
# make filename.s = Just compile filename.c into the assembler code only.
#
# make filename.i = Create a preprocessed source file for use in submitting
# bug reports to the GCC project.
#
# To rebuild project do "make clean" then "make all".
#----------------------------------------------------------------------------
# MCU name
MCU = atmega324p
# Processor frequency.
# This will define a symbol, F_CPU, in all source code files equal to the
# processor frequency. You can then use this symbol in your source code to
# calculate timings. Do NOT tack on a 'UL' at the end, this will be done
# automatically to create a 32-bit value in your source code.
# Typical values are:
# F_CPU = 1000000
# F_CPU = 1843200
# F_CPU = 2000000
# F_CPU = 3686400
# F_CPU = 4000000
# F_CPU = 7372800
# F_CPU = 8000000
# F_CPU = 11059200
# F_CPU = 14745600
# F_CPU = 16000000
# F_CPU = 18432000
# F_CPU = 20000000
F_CPU = 3686400
# Output format. (can be srec, ihex, binary)
FORMAT = ihex
# Target file name (without extension).
TARGET = testapp
# Object files directory
# To put object files in current directory, use a dot (.), do NOT make
# this an empty or blank macro!
OBJDIR = .
# List C source files here. (C dependencies are automatically generated.)
SRC = $(TARGET).c
# List C++ source files here. (C dependencies are automatically generated.)
CPPSRC =
# List Assembler source files here.
# Make them always end in a capital .S. Files ending in a lowercase .s
# will not be considered source files but generated files (assembler
# output from the compiler), and will be deleted upon "make clean"!
# Even though the DOS/Win* filesystem matches both .s and .S the same,
# it will preserve the spelling of the filenames, and gcc itself does
# care about how the name is spelled on its command-line.
ASRC =
# Optimization level, can be [0, 1, 2, 3, s].
# 0 = turn off optimization. s = optimize for size.
# (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
OPT = s
# Debugging format.
# Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
# AVR Studio 4.10 requires dwarf-2.
# AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
DEBUG = dwarf-2
# List any extra directories to look for include files here.
# Each directory must be seperated by a space.
# Use forward slashes for directory separators.
# For a directory that has spaces, enclose it in quotes.
EXTRAINCDIRS =
# Compiler flag to set the C Standard level.
# c89 = "ANSI" C
# gnu89 = c89 plus GCC extensions
# c99 = ISO C99 standard (not yet fully implemented)
# gnu99 = c99 plus GCC extensions
CSTANDARD = -std=gnu99
# Place -D or -U options here for C sources
CDEFS = -DF_CPU=$(F_CPU)UL
# Place -D or -U options here for ASM sources
ADEFS = -DF_CPU=$(F_CPU)
# Place -D or -U options here for C++ sources
CPPDEFS = -DF_CPU=$(F_CPU)UL
#CPPDEFS += -D__STDC_LIMIT_MACROS
#CPPDEFS += -D__STDC_CONSTANT_MACROS
#---------------- Compiler Options C ----------------
# -g*: generate debugging information
# -O*: optimization level
# -f...: tuning, see GCC manual and avr-libc documentation
# -Wall...: warning level
# -Wa,...: tell GCC to pass this to the assembler.
# -adhlns...: create assembler listing
CFLAGS = -g$(DEBUG)
CFLAGS += $(CDEFS)
CFLAGS += -O$(OPT)
CFLAGS += -funsigned-char
CFLAGS += -funsigned-bitfields
CFLAGS += -fpack-struct
CFLAGS += -fshort-enums
CFLAGS += -Wall
CFLAGS += -Wstrict-prototypes
#CFLAGS += -mshort-calls
#CFLAGS += -fno-unit-at-a-time
#CFLAGS += -Wundef
#CFLAGS += -Wunreachable-code
#CFLAGS += -Wsign-compare
CFLAGS += -Wa,-adhlns=$(<:%.c=$(OBJDIR)/%.lst)
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
CFLAGS += $(CSTANDARD)
#---------------- Compiler Options C++ ----------------
# -g*: generate debugging information
# -O*: optimization level
# -f...: tuning, see GCC manual and avr-libc documentation
# -Wall...: warning level
# -Wa,...: tell GCC to pass this to the assembler.
# -adhlns...: create assembler listing
CPPFLAGS = -g$(DEBUG)
CPPFLAGS += $(CPPDEFS)
CPPFLAGS += -O$(OPT)
CPPFLAGS += -funsigned-char
CPPFLAGS += -funsigned-bitfields
CPPFLAGS += -fpack-struct
CPPFLAGS += -fshort-enums
CPPFLAGS += -fno-exceptions
CPPFLAGS += -Wall
CFLAGS += -Wundef
#CPPFLAGS += -mshort-calls
#CPPFLAGS += -fno-unit-at-a-time
#CPPFLAGS += -Wstrict-prototypes
#CPPFLAGS += -Wunreachable-code
#CPPFLAGS += -Wsign-compare
CPPFLAGS += -Wa,-adhlns=$(<:%.cpp=$(OBJDIR)/%.lst)
CPPFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
#CPPFLAGS += $(CSTANDARD)
#---------------- Assembler Options ----------------
# -Wa,...: tell GCC to pass this to the assembler.
# -adhlns: create listing
# -gstabs: have the assembler create line number information; note that
# for use in COFF files, additional information about filenames
# and function names needs to be present in the assembler source
# files -- see avr-libc docs [FIXME: not yet described there]
# -listing-cont-lines: Sets the maximum number of continuation lines of hex
# dump that will be displayed for a given single line of source input.
ASFLAGS = $(ADEFS) -Wa,-adhlns=$(<:%.S=$(OBJDIR)/%.lst),-gstabs,--listing-cont-lines=100
#---------------- Library Options ----------------
# Minimalistic printf version
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min
# Floating point printf version (requires MATH_LIB = -lm below)
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt
# If this is left blank, then it will use the Standard printf version.
PRINTF_LIB =
#PRINTF_LIB = $(PRINTF_LIB_MIN)
#PRINTF_LIB = $(PRINTF_LIB_FLOAT)
# Minimalistic scanf version
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min
# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt
# If this is left blank, then it will use the Standard scanf version.
SCANF_LIB =
#SCANF_LIB = $(SCANF_LIB_MIN)
#SCANF_LIB = $(SCANF_LIB_FLOAT)
MATH_LIB = -lm
# List any extra directories to look for libraries here.
# Each directory must be seperated by a space.
# Use forward slashes for directory separators.
# For a directory that has spaces, enclose it in quotes.
EXTRALIBDIRS =
#---------------- External Memory Options ----------------
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# used for variables (.data/.bss) and heap (malloc()).
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# only used for heap (malloc()).
#EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff
EXTMEMOPTS =
#---------------- Linker Options ----------------
# -Wl,...: tell GCC to pass this to linker.
# -Map: create map file
# --cref: add cross reference to map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
#LDFLAGS += -T linker_script.x
#---------------- Programming Options (avrdude) ----------------
# Programming hardware: alf avr910 avrisp bascom bsd
# dt006 pavr picoweb pony-stk200 sp12 stk200 stk500
#
# Type: avrdude -c ?
# to get a full listing.
#
AVRDUDE_PROGRAMMER = stk500
# com1 = serial port. Use lpt1 to connect to parallel port.
AVRDUDE_PORT = com1 # programmer connected to serial device
AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
# Uncomment the following if you want avrdude's erase cycle counter.
# Note that this counter needs to be initialized first using -Yn,
# see avrdude manual.
#AVRDUDE_ERASE_COUNTER = -y
# Uncomment the following if you do /not/ wish a verification to be
# performed after programming the device.
#AVRDUDE_NO_VERIFY = -V
# Increase verbosity level. Please use this when submitting bug
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude>
# to submit bug reports.
#AVRDUDE_VERBOSE = -v -v
AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)
#---------------- Debugging Options ----------------
# For simulavr only - target MCU frequency.
DEBUG_MFREQ = $(F_CPU)
# Set the DEBUG_UI to either gdb or insight.
# DEBUG_UI = gdb
DEBUG_UI = insight
# Set the debugging back-end to either avarice, simulavr.
DEBUG_BACKEND = avarice
#DEBUG_BACKEND = simulavr
# GDB Init Filename.
GDBINIT_FILE = __avr_gdbinit
# When using avarice settings for the JTAG
JTAG_DEV = /dev/com1
# Debugging port used to communicate between GDB / avarice / simulavr.
DEBUG_PORT = 4242
# Debugging host used to communicate between GDB / avarice / simulavr, normally
# just set to localhost unless doing some sort of crazy debugging when
# avarice is running on a different computer.
DEBUG_HOST = localhost
#============================================================================
# Define programs and commands.
SHELL = sh
CC = avr-gcc
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
SIZE = avr-size
AR = avr-ar rcs
NM = avr-nm
AVRDUDE = avrdude
REMOVE = rm -f
REMOVEDIR = rm -rf
COPY = cp
WINSHELL = cmd
# Define Messages
# English
MSG_ERRORS_NONE = Errors: none
MSG_BEGIN = -------- begin --------
MSG_END = -------- end --------
MSG_SIZE_BEFORE = Size before:
MSG_SIZE_AFTER = Size after:
MSG_COFF = Converting to AVR COFF:
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
MSG_FLASH = Creating load file for Flash:
MSG_EEPROM = Creating load file for EEPROM:
MSG_EXTENDED_LISTING = Creating Extended Listing:
MSG_SYMBOL_TABLE = Creating Symbol Table:
MSG_LINKING = Linking:
MSG_COMPILING = Compiling C:
MSG_COMPILING_CPP = Compiling C++:
MSG_ASSEMBLING = Assembling:
MSG_CLEANING = Cleaning project:
MSG_CREATING_LIBRARY = Creating library:
# Define all object files.
OBJ = $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o)
# Define all listing files.
LST = $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst)
# Compiler flags to generate dependency files.
GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d
# Combine all necessary flags and optional flags.
# Add target processor to flags.
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
# Default target.
all: begin gccversion sizebefore build sizeafter end
# Change the build target to build a HEX file or a library.
build: elf hex eep lss sym
#build: lib
elf: $(TARGET).elf
hex: $(TARGET).hex
eep: $(TARGET).eep
lss: $(TARGET).lss
sym: $(TARGET).sym
LIBNAME=lib$(TARGET).a
lib: $(LIBNAME)
# Eye candy.
# AVR Studio 3.x does not check make's exit code but relies on
# the following magic strings to be generated by the compile job.
begin:
@echo
@echo $(MSG_BEGIN)
end:
@echo $(MSG_END)
@echo
# Display size of file.
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
ELFSIZE = $(SIZE) --mcu=$(MCU) --format=avr $(TARGET).elf
sizebefore:
@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \
2>/dev/null; echo; fi
sizeafter:
@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \
2>/dev/null; echo; fi
# Display compiler version information.
gccversion :
@$(CC) --version
# Program the device.
program: $(TARGET).hex $(TARGET).eep
$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)
# Generate avr-gdb config/init file which does the following:
# define the reset signal, load the target file, connect to target, and set
# a breakpoint at main().
gdb-config:
@$(REMOVE) $(GDBINIT_FILE)
@echo define reset >> $(GDBINIT_FILE)
@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
@echo end >> $(GDBINIT_FILE)
@echo file $(TARGET).elf >> $(GDBINIT_FILE)
@echo target remote $(DEBUG_HOST):$(DEBUG_PORT) >> $(GDBINIT_FILE)
ifeq ($(DEBUG_BACKEND),simulavr)
@echo load >> $(GDBINIT_FILE)
endif
@echo break main >> $(GDBINIT_FILE)
debug: gdb-config $(TARGET).elf
ifeq ($(DEBUG_BACKEND), avarice)
@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
@$(WINSHELL) /c pause
else
@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
$(DEBUG_MFREQ) --port $(DEBUG_PORT)
endif
@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)
# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
COFFCONVERT = $(OBJCOPY) --debugging
COFFCONVERT += --change-section-address .data-0x800000
COFFCONVERT += --change-section-address .bss-0x800000
COFFCONVERT += --change-section-address .noinit-0x800000
COFFCONVERT += --change-section-address .eeprom-0x810000
coff: $(TARGET).elf
@echo
@echo $(MSG_COFF) $(TARGET).cof
$(COFFCONVERT) -O coff-avr $< $(TARGET).cof
extcoff: $(TARGET).elf
@echo
@echo $(MSG_EXTENDED_COFF) $(TARGET).cof
$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
# Create final output files (.hex, .eep) from ELF output file.
%.hex: %.elf
@echo
@echo $(MSG_FLASH) $@
$(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@
%.eep: %.elf
@echo
@echo $(MSG_EEPROM) $@
-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
--change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT) $< $@ || exit 0
# Create extended listing file from ELF output file.
%.lss: %.elf
@echo
@echo $(MSG_EXTENDED_LISTING) $@
$(OBJDUMP) -h -S $< > $@
# Create a symbol table from ELF output file.
%.sym: %.elf
@echo
@echo $(MSG_SYMBOL_TABLE) $@
$(NM) -n $< > $@
# Create library from object files.
.SECONDARY : $(TARGET).a
.PRECIOUS : $(OBJ)
%.a: $(OBJ)
@echo
@echo $(MSG_CREATING_LIBRARY) $@
$(AR) $@ $(OBJ)
# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
@echo
@echo $(MSG_LINKING) $@
$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)
# Compile: create object files from C source files.
$(OBJDIR)/%.o : %.c
@echo
@echo $(MSG_COMPILING) $<
$(CC) -c $(ALL_CFLAGS) $< -o $@
# Compile: create object files from C++ source files.
$(OBJDIR)/%.o : %.cpp
@echo
@echo $(MSG_COMPILING_CPP) $<
$(CC) -c $(ALL_CPPFLAGS) $< -o $@
# Compile: create assembler files from C source files.
%.s : %.c
$(CC) -S $(ALL_CFLAGS) $< -o $@
# Compile: create assembler files from C++ source files.
%.s : %.cpp
$(CC) -S $(ALL_CPPFLAGS) $< -o $@
# Assemble: create object files from assembler source files.
$(OBJDIR)/%.o : %.S
@echo
@echo $(MSG_ASSEMBLING) $<
$(CC) -c $(ALL_ASFLAGS) $< -o $@
# Create preprocessed source for use in sending a bug report.
%.i : %.c
$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@
# Target: clean project.
clean: begin clean_list end
clean_list :
@echo
@echo $(MSG_CLEANING)
$(REMOVE) $(TARGET).hex
$(REMOVE) $(TARGET).eep
$(REMOVE) $(TARGET).cof
$(REMOVE) $(TARGET).elf
$(REMOVE) $(TARGET).map
$(REMOVE) $(TARGET).sym
$(REMOVE) $(TARGET).lss
$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.o)
$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.lst)
$(REMOVE) $(SRC:.c=.s)
$(REMOVE) $(SRC:.c=.d)
$(REMOVE) $(SRC:.c=.i)
$(REMOVEDIR) .dep
# Create object files directory
$(shell mkdir $(OBJDIR) 2>/dev/null)
# Include the dependency files.
-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)
# Listing of phony targets.
.PHONY : all begin finish end sizebefore sizeafter gccversion \
build elf hex eep lss sym coff extcoff \
clean clean_list program debug gdb-config

62
boot/testapp/testapp.c Executable file
View File

@ -0,0 +1,62 @@
// Martin Thomas 4/2008
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <util/delay.h>
#define LED_PORT PORTB
#define LED_DDR DDRB
#define LED_BIT PB2
#define BT_PORT PORTC
#define BT_DDR DDRC
#define BT_PIN PINC
#define BT_BIT PC7
static inline void my_wdt_off(void)
{
cli();
wdt_reset();
/* Clear WDRF in MCUSR */
MCUSR &= ~(1<<WDRF);
/* Write logical one to WDCE and WDE */
/* Keep old prescaler setting to prevent unintentional time-out */
WDTCSR |= (1<<WDCE) | (1<<WDE);
/* Turn off WDT */
WDTCSR = 0x00;
}
static void my_delay( void )
{
int i;
for ( i=0; i<500; i++ ) {
_delay_ms(1);
}
}
int main( void )
{
my_wdt_off();
LED_PORT |= ( 1<<LED_BIT );
LED_DDR |= ( 1<<LED_BIT );
BT_DDR &= ~( 1<<BT_BIT );
BT_PORT |= ( 1<<BT_BIT );
while ( 1 ) {
LED_PORT &= ~( 1<<LED_BIT );
my_delay();
LED_PORT |= ( 1<<LED_BIT );
my_delay();
if ( !( BT_PIN & ( 1<<BT_BIT ) ) ) {
/* start bootloader */
wdt_enable( WDTO_250MS );
while (1) { ; }
}
}
return 0; /* never reached */
}

117
boot/testavrdude/dummy.hex Executable file
View File

@ -0,0 +1,117 @@
:103800000C942A1C0C94451C0C94451C0C94451CCF
:103810000C94451C0C94451C0C94451C0C94451CA4
:103820000C94451C0C94451C0C94451C0C94451C94
:103830000C94451C0C94451C0C94451C0C94451C84
:103840000C94451C0C94451C0C94451C0C94451C74
:103850000C94451C11241FBECFE5D4E0DEBFCDBFC4
:1038600010E0A0E6B0E0EEE2FFE302C005900D92AA
:10387000A036B107D9F710E0A0E6B0E001C01D9274
:10388000A53EB107E1F70C94871D0C94001C8F9A9C
:1038900084E083BD89E185BD089581E40E94E21E34
:1038A00086E50E94E21E82E50E94E21E82E40E94FA
:1038B000E21E8FE40E94E21E8FE40E94E21E84E575
:1038C0000E94E21E08958F929F92AF92BF92CF9274
:1038D000DF92EF92FF920F931F93CF93DF936C01D0
:1038E000962EEE24FF2487010E591F4FE7012196E3
:1038F000EC14FD0418F40E94E61E01C08FEFF801DD
:1039000080837E01C038D10570F3EE24FF248091BE
:10391000E400853721F08B3311F0C7018CC0A090F3
:10392000E200B090E300E199FECF8FB6F89426E470
:10393000921609F07DC08091E40087010E591F4F57
:10394000E7012196EEEFFFEFCE0EDF1E8537F1F493
:10395000F8018081282F3327FE01EE59FF4F808127
:103960009927982F8827282B392B7E010894E11C52
:10397000F11C41E08091E2009091E3000901FC011B
:1039800040935700E8951124029628C080E40E94D5
:103990004B1F8091E3000E944B1F8091E2000E9428
:1039A0004B1FF80180810E944B1F88E40E944B1F2F
:1039B0008091E3000E944B1F8091E2000E944B1F08
:1039C0007E010894E11CF11CCE59DF4F88810E94D2
:1039D0004B1F8091E2009091E30001969093E300E9
:1039E0008093E200C114D10409F0A5CF8091E400D6
:1039F000853769F485E0F50180935700E89507B6AF
:103A000000FCFDCF81E180935700E89511C08CE464
:103A10000E944B1F8B2D99270E944B1F8A2D0E94BD
:103A20004B1F80E00E944B1F88E893E10E94F51E27
:103A30008FBE8DE090E0DF91CF911F910F91FF90AD
:103A4000EF90DF90CF90BF90AF909F908F900895B0
:103A5000FF920F931F93CF93DF93EC01FFB6F8947F
:103A6000E199FECF8091E4008537E9F4653409F4EB
:103A700047C060E08091E2009091E3000E94EB1E5D
:103A80008C010E94E21E812F99270E94E21E8091E4
:103A9000E2009091E30002969093E3008093E200AD
:103AA000229739F72DC08B3359F580E20E944B1FC6
:103AB0008091E3000E944B1F8091E2000E944B1F07
:103AC0008FEF0E944B1F0E94E21E88E20E944B1F54
:103AD0008091E3000E944B1F8091E2000E944B1FE7
:103AE0008FEF0E944B1F0E94E21E8091E200909196
:103AF000E30001969093E3008093E2002297A9F6F9
:103B0000FFBEDF91CF911F910F91FF900895CFE5F8
:103B1000D4E0DEBFCDBFF89401E005BF82E085BFF1
:103B2000A698AE9A60E087E190E00E94D81E9E9B26
:103B300008C0AE9805BF15BEE0916000F09161002D
:103B40000995BB9AC39A0E94401F0E94471C0E947D
:103B5000E61E813611F489E528C18134F9F40E940A
:103B6000E61E99279093E3008093E200182F002728
:103B70000E94E61E282F3327202B312B3093E300A1
:103B80002093E2008091E400853709F083C0220F82
:103B9000331F3093E3002093E2007CC0823689F427
:103BA00089E50E94E21E8091E400853729F480E0D7
:103BB0000E94E21E80E8F9C080E00E94E21E80E4DC
:103BC000F4C0823489F40E94E61E9927182F00273A
:103BD0000E94E61E9927082B192B0E94E61E682FCB
:103BE000C8010E94631CE1C0873689F40E94E61E6A
:103BF0009927182F00270E94E61E9927082B192BBA
:103C00000E94E61E682FC8010E94281DA0CF85369D
:103C1000B1F58091E4008537F9F41092E300109239
:103C2000E20043E020E030E0F90140935700E895DE
:103C300007B600FCFDCFC90180589F4F9C0158E397
:103C40008030950788F39093E3008093E20081E150
:103C500080935700E8951EC08B33E1F48CEA0E94F4
:103C60004B1F80E80E944B1F80E00E944B1F80E0AA
:103C70000E944B1F8CE893E20E94F51E0BC0853416
:103C800059F488E190E028E00FB6F894A89581BD3A
:103C90000FBE21BD8DE089C0803539F48091E400EC
:103CA0008B33C1F70E94511FF5CF8C3439F48091CA
:103CB000E4008B3379F70E946D1FECCF803711F44D
:103CC00083E573C0823711F48FEF6FC08E3459F4DF
:103CD0008091E400853711F488E967C08B3309F0DF
:103CE00036CF8EED62C08C3619F40E94E61ED2CF1C
:103CF000843741F485E70E94E21E8BE30E94E21EB6
:103D000080E053C0883731F40E94E61E823031F4DF
:103D1000C398C0CF893721F40E94E61EC39ABACF58
:103D2000843529F40E94E61E8093E400B3CF8335E6
:103D300019F40E944D1C0BCF863529F480E30E94B4
:103D4000E21E87E332C0833711F58091E4008537A6
:103D500041F483E00E94E21E84E90E94E21E8EE1AB
:103D600024C08B3309F0F3CE03E0015080E30E94BE
:103D70004B1F80E00E944B1F802F0E944B1F8FEF34
:103D80000E944B1F0E94E21E002379F7E0CE8D3483
:103D900041F488B398E0892788BB84E70E94E21E3B
:103DA00079CF8B3109F4D3CE8FE30E94E21ECFCEC0
:103DB0009C01832F992780BD29B988E18AB986E8BB
:103DC00080BD08955D9BFECF8CB908955F9BFECFAB
:103DD0008CB199270895FC0160FD60935700C89548
:103DE000802DE395C895902D0895CF93DF93CDB79F
:103DF000DEB722970FB6F894DEBF0FBECDBF039695
:103E000065E070E00E94831F9B0144275527DA017B
:103E1000C90163E0880F991FAA1FBB1F6A95D1F7DC
:103E2000821B930BA40BB50B9C0119821A8289810A
:103E30009A818217930750F489819A810196898328
:103E40009A8389819A8182179307B0F322960FB6DD
:103E5000F894DEBF0FBECDBFDF91CF910895D89803
:103E600088E092E50E94F51E0895D89A88E092E5D0
:103E70000E94F51E08950E94351F0E942F1F08956D
:103E8000C79A87B3806B87BBD09ABE9883E58DB9FC
:103E90000E94351F08958FB9779BFECF8FB1992768
:103EA0000895CF93C7980E943B1FC0E08CEA0E9400
:103EB0004B1F83E50E944B1F8FEF0E944B1F8335E2
:103EC00011F4C1E402C00E943B1F80E00E944B1F1E
:103ED000CF5FC03458F3CF9108950E943B1F0E94DA
:103EE000351F08950E94511F8CEA0E944B1F80E8E5
:103EF0000E944B1F80E00E944B1F80E00E944B1FDE
:103F00000E946D1F0895AA1BBB1B51E107C0AA1F89
:103F1000BB1FA617B70710F0A61BB70B881F991F6A
:0E3F20005A95A9F780959095BC01CD010895A2
:0400000300003800C1
:00000001FF

20
boot/testavrdude/go.cmd Executable file
View File

@ -0,0 +1,20 @@
@echo off
rem Use avrdude as programming-software with the AVRProg compatible bootloader
rem Martin Thomas, 2006
rem Verfiy that the bootloader is configured with #define DEVTYPE DEVTYPE_ISP
rem since it seems that avrdude does not work with "Boot" device-types and needs
rem ISP device-types (at least in version 5.1 as in WinAVR 4/06)
set HEXFILE=cansniffer.hex
set PROGRAMMER=avr109
set PORT=com2
set BAUD=19200
set PART=atmega32
rem * disable safemode - bootloader can not "restore" fuses anyway
set DIS_SAVE=-u
avrdude %DIS_SAVE% -p %PART% -P %PORT% -c %PROGRAMMER% -b %BAUD% -v -U flash:w:%HEXFILE%
rem pause