topic2168.html
[syntax=c]////////////////////////////////////////////////////////////////////////////////
/* Bootloader
* Autor: Mirosław Kardaś (2009-06-16)
* Modyfikacje: Paweł Szramowski (2009-06-30) */
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/* Dołączenie bibliotek */
////////////////////////////////////////////////////////////////////////////////
/* biblioteki avr-libc */
#include <stdint.h>
#include <avr/boot.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <util/delay.h>
#include <util/setbaud.h>
////////////////////////////////////////////////////////////////////////////////
/* Definicje stałych programowych i makr */
////////////////////////////////////////////////////////////////////////////////
/* wersja bootloadera */
#define BOOTLOADER_VERSION 1
/* ustawienia UART */
#define UART_DATA_BITS 8
#define UART_PARITY 'n'
#define UART_STOP_BITS 1
//#define USE_2X
// definicje na potrzeby RS485
#define UART_DE_PORT PORTD
#define UART_DE_DIR DDRD
#define UART_DE_BIT (1<<PD2)
#define UART_DE_ODBIERANIE UART_DE_PORT &= ~UART_DE_BIT
#define UART_DE_NADAWANIE UART_DE_PORT |= UART_DE_BIT
/* dla procesorów typu ATmega88 gdy Watchdog działa także po resecie) itp trzeba włączyć poniższą opcję */
#define WDIFr
/* czas przesyłania jednego znaku przez UART [us] */
#if UART_PARITY == 'n'
#define UART_BYTE_TIME \
( 1000000UL / ( BAUD / ( 1 + UART_DATA_BITS + UART_STOP_BITS ) ) )
#elif ( UART_PARITY == 'e' ) || ( UART_PARITY == 'o' )
#define UART_BYTE_TIME \
( 1000000UL / ( BAUD / ( 1 + UART_DATA_BITS + 1 + UART_STOP_BITS ) ) )
#endif
/* podstawienie nazwa rejestrów UART */
#ifndef UCSRA
#define UCSRA UCSR0A
#endif
#ifndef UCSRB
#define UCSRB UCSR0B
#endif
#ifndef UCSRC
#define UCSRC UCSR0C
#endif
#ifndef UBRRL
#define UBRRL UBRR0L
#endif
#ifndef UBRRH
#define UBRRH UBRR0H
#endif
#ifndef UDR
#define UDR UDR0
#endif
/* podstawienie nazw bitów w rejestrze UCSRA */
#ifndef RXC
#define RXC RXC0
#endif
#ifndef TXC
#define TXC TXC0
#endif
#ifndef UDRE
#define UDRE UDRE0
#endif
#ifndef FE
#define FE FE0
#endif
#ifndef DOR
#define DOR DOR0
#endif
#ifndef UPE
#define UPE UPE0
#endif
#ifndef U2X
#define U2X U2X0
#endif
#ifndef MPCM
#define MPCM MPCM0
#endif
/* podstawienie nazw bitów w rejestrze UCSRB */
#ifndef RXCIE
#define RXCIE RXCIE0
#endif
#ifndef TXCIE
#define TXCIE TXCIE0
#endif
#ifndef UDRIE
#define UDRIE UDRIE0
#endif
#ifndef RXEN
#define RXEN RXEN0
#endif
#ifndef TXEN
#define TXEN TXEN0
#endif
#ifndef UCSZ2
#define UCSZ2 UCSZ02
#endif
#ifndef RXB8
#define RXB8 RXB80
#endif
#ifndef TXB8
#define TXB8 TXB80
#endif
/* podstawienie nazw bitów w rejestrze UCSRC */
#ifdef URSEL0
#define URSEL URSEL0
#endif
#ifndef UMSEL
#ifdef UMSEL0
#define UMSEL UMSEL0
#else
#define UMSEL UMSEL00
#define UMSEL0 UMSEL00
#define UMSEL1 UMSEL01
#endif
#endif
#ifndef UPM1
#define UPM1 UPM01
#endif
#ifndef UPM0
#define UPM0 UPM00
#endif
#ifndef USBS
#define USBS USBS0
#endif
#ifndef UCSZ1
#define UCSZ1 UCSZ01
#endif
#ifndef UCSZ0
#define UCSZ0 UCSZ00
#endif
#ifndef UCPOL
#define UCPOL UCPOL0
#endif
#if UART_DATA_BITS == 5
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 0 << UCSZ1 | 0 << UCSZ0 )
#elif UART_DATA_BITS == 6
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 0 << UCSZ1 | 1 << UCSZ0 )
#elif UART_DATA_BITS == 7
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 1 << UCSZ1 | 0 << UCSZ0 )
#elif UART_DATA_BITS == 8
#define UCSRB_DATA_BITS ( 0 << UCSZ2 )
#define UCSRC_DATA_BITS ( 1 << UCSZ1 | 1 << UCSZ0 )
#elif UART_DATA_BITS == 9
#define UCSRB_DATA_BITS ( 1 << UCSZ2 )
#define UCSRC_DATA_BITS ( 1 << UCSZ1 | 1 << UCSZ0 )
#endif
#if UART_PARITY == 'n'
#define UCSRC_PARITY ( 0 << UPM1 | 0 << UPM0 )
#elif UART_PARITY == 'e'
#define UCSRC_PARITY ( 1 << UPM1 | 0 << UPM0 )
#elif UART_PARITY == 'o'
#define UCSRC_PARITY ( 1 << UPM1 | 1 << UPM0 )
#endif
#if UART_STOP_BITS == 1
#define UCSRC_STOP_BITS ( 0 << USBS )
#elif UART_STOP_BITS == 2
#define UCSRC_STOP_BITS ( 1 << USBS )
#endif
/* makro zamieniające podany argument na łańcuch znaków */
#define TOSTRING( x ) STRINGIFY( x )
#define STRINGIFY( x ) #x
////////////////////////////////////////////////////////////////////////////////
/* Deklaracje funkcji statycznych */
////////////////////////////////////////////////////////////////////////////////
static void UART_TX_Byte(
const uint8_t Data );
static void UART_TX_String_P(
const prog_char *String_Ptr );
static uint8_t _UART_RX_Wait(
uint16_t Timeout );
/* Makro przeliczające argument w milisekundach na przyjmowaną przez funkcję
* _UART_RX_Wait wielokrotność czasu przesyłania jednego znaku. */
#define UART_RX_Wait( x ) _UART_RX_Wait( ( x * 1000UL ) / UART_BYTE_TIME )
////////////////////////////////////////////////////////////////////////////////
/* Definicje funkcji */
////////////////////////////////////////////////////////////////////////////////
static void __vectors(
void )
__attribute__ (( section( ".vectors" ), naked, used ));
static void __vectors(
void )
{
/* skok do sekcji .init2 (konieczny ze względu na umieszczanie stałych z
* pamięci programu pomiędzy sekcjami .vectors a .init0, a więc na samym
* początku programu w przypadku wykorzystania opcji -nostartfiles */
asm (
"rjmp __init2" "\n\t"
: : );
}
static void __init2(
void )
__attribute__ (( section( ".init2" ), naked, used ));
static void __init2(
void )
{
/* inicjalizacja wskaźnika stosu, rejestru z zerem i rejestru flag */
asm volatile (
"out __SP_L__, %A0" "\n\t"
"out __SP_H__, %B0" "\n\t"
"clr __zero_reg__" "\n\t"
"out __SREG__, __zero_reg__" "\n\t"
: : "r"( ( uint16_t )( RAMEND ) ) );
}
#ifdef WDIFr
static void __init3(
void )
__attribute__ (( section( ".init3" ), naked, used ));
static void __init3(
void )
{
/* wyłączenie watchdoga (w tych mikrokontrolerach, w których watchdog
* ma możliwość generowania przerwania pozostaje on też aktywny po
* resecie) */
MCUSR = 0;
_WD_CONTROL_REG = 1 << _WD_CHANGE_BIT | 1 << WDE;
_WD_CONTROL_REG = 0;
}
#endif
static void __init9(
void )
__attribute__ (( section( ".init9" ), naked, used ));
static void __init9(
void )
{
/* skok do funkcji main */
asm (
"rjmp main" "\n\t"
: : );
}
int main(
void )
__attribute__ (( noreturn ));
int main(
void )
{
/* konfiguracja i włączenie interfejsu UART */
UBRRH = UBRRH_VALUE;
UBRRL = UBRRL_VALUE;
#if USE_2X
UCSRA = 1 << U2X;
#else
UCSRA = 0;
#endif
#ifdef URSEL
UCSRC = 1 << URSEL | UCSRC_DATA_BITS | UCSRC_PARITY | UCSRC_STOP_BITS;
#else
#ifdef URSEL0 /* opcja specjalna dla ATmega162 */
UCSRC = 1 << URSEL0 | UCSRC_DATA_BITS | UCSRC_PARITY | UCSRC_STOP_BITS;
#else
UCSRC = UCSRC_DATA_BITS | UCSRC_PARITY | UCSRC_STOP_BITS;
#endif
#endif
UCSRB = 1 << RXEN | 1 << TXEN | UCSRB_DATA_BITS;
/* deklaracja zmiennych */
uint8_t Received_Char;
UART_DE_DIR |= UART_DE_BIT;
UART_DE_ODBIERANIE;
/* wysyłanie znaku '?' do odebrania znaku 'u' lub upłynięcia czasu
* oczekiwania */
for ( uint8_t Retries_Left = BOOT_WAIT * 10; Retries_Left > 0;
--Retries_Left )
{
if ( ( Received_Char = UART_RX_Wait( 100 ) ) == 'u' )
break;
UART_TX_Byte( '?' );
}
if ( Received_Char == 'u' )
{
while ( 1 )
{
/* odebranie znaku */
Received_Char = UART_RX_Wait( 1000 );
if ( Received_Char == 'i' )
{
/* jeśli odebrano znak 'i', to wysłanie ciągu znaków
* identyfikujących mikrokontroler i bootloader */
UART_TX_String_P( PSTR( "\r\n" "&"
TOSTRING( SPM_PAGESIZE ) ","
TOSTRING( BLS_START ) ","
TOSTRING( MCU ) ","
TOSTRING( XTAL ) ","
TOSTRING( BOOTLOADER_VERSION )
"*" "\r\n" ) );
}
else if ( Received_Char == 'w' )
{
/* odczekanie do zakończenia operacji na pamięci EEPROM
* i Flash */
eeprom_busy_wait();
boot_spm_busy_wait();
/* kasowanie całej pamięci programu */
for ( uint32_t Page_Address = 0; Page_Address < BLS_START;
Page_Address += SPM_PAGESIZE )
{
/* skasowanie strony pamięci */
boot_page_erase( Page_Address );
boot_spm_busy_wait();
}
/* programowanie pamięci programu */
for ( uint32_t Page_Address = 0; Page_Address < BLS_START;
Page_Address += SPM_PAGESIZE )
{
/* wysłanie znaku '@' */
UART_TX_Byte( '@' );
/* jeśli odebrano zero lub upłynął czas oczekiwania na
* odpowiedź, to zakończenie pracy bootloadera */
if ( !UART_RX_Wait( 500 ) )
break;
/* zapełnienie bufora strony */
for ( uint16_t Byte_Address = 0;
Byte_Address < SPM_PAGESIZE; Byte_Address += 2 )
{
/* przygotowanie instrukcji */
uint16_t Instruction = ( uint16_t )UART_RX_Wait( 500 );
Instruction += UART_RX_Wait( 500 ) << 8;
/* zapisanie instrukcji do bufora */
boot_page_fill( Byte_Address, Instruction );
}
/* zapisanie strony pamięci */
boot_page_write( Page_Address );
boot_spm_busy_wait();
}
/* odblokowanie sekcji Read-While-Write */
boot_rww_enable();
/* zakończenie pracy bootloadera */
break;
}
else
{
/* jeśli odebrano inny znak lub upłynął czas oczekiwania na
* odpowiedź, to zakończenie pracy bootloadera */
break;
}
}
}
/* wyłączenie interfejsu UART (dzieje się to dopiero po zakończeniu
* wysyłania) i odczekanie do końca ewentualnej transmisji */
UCSRB = 0;
//_delay_us( UART_BYTE_TIME );
/* skok do właściwego programu */
#ifdef __AVR_HAVE_JMP_CALL__
asm volatile (
"jmp 0" "\n\t"
: : );
#else
asm volatile (
"clr r30" "\n\t"
"clr r31" "\n\t"
"ijmp" "\n\t"
: : );
#endif
/* nieskończona pętla (konieczna, by kompilator nie wygenerował
* niepotrzebnego kodu) */
while ( 1 )
{}
}
static void UART_TX_Byte(
const uint8_t Data )
{
while ( !( UCSRA & 1 << UDRE ) ) wdt_reset();
UART_DE_NADAWANIE;
UDR = Data;
while ( !( UCSRA & 1 << TXC ) ) wdt_reset();
UCSRA|=1<<TXC;
UART_DE_ODBIERANIE;
}
static void UART_TX_String_P(
const prog_char *String_Ptr )
{
uint8_t Single_Char;
while ( ( Single_Char = pgm_read_byte( String_Ptr++ ) ) )
UART_TX_Byte( Single_Char );
}
static uint8_t _UART_RX_Wait(
uint16_t Timeout )
{
do
{
if ( UCSRA & 1 << RXC )
return UDR;
_delay_us( UART_BYTE_TIME );
} while ( Timeout-- );
return 0;
}[/syntax]
+ makefile dla atmeg32.
[syntax=c]#----------------------------------------------------------------------------
# make all = Make software.
# make clean = Clean out built project files.
# make size = Display sizes of object files.
# make doc = Start doxygen to prepare documentation.
# make filename.s = Just compile filename.c into the assembler code only.
# make filename.i = Create a preprocessed source file.
# make program = Download the hex file to the device.
# make fuse = Download configuration bits to the device.
# make lock = Download lock bits to the device.
#----------------------------------------------------------------------------
# MCU name
#MCU = atmega8
#MCU = atmega16
#MCU = atmega168
MCU = atmega32
#MCU = atmega644p
# MCU frequency (without UL suffix)
F_CPU = 11059200
#F_CPU = 8000000
#F_CPU = 16000000
# Bootloader options
#BLS_START = 0x1E00
#BLS_START = 0x3E00
BLS_START = 0x7E00
#BLS_START = 0xFC00
BOOT_WAIT = 2
BAUD_RATE = 19200
#BAUD_RATE = 115200
# MCU configuration fuse and lockbits (leave empty if not to be programmed or
# to be programmed according to .fuse and .lock sections in ELF file)
LFUSE =
HFUSE =
EFUSE =
LOCK =
# Target file name (without extension)
TARGET = Bootloader
# Optimization level (can be 0, 1, 2, 3 or s)
OPT = s
# List C source files here (C dependencies are automatically generated)
SRC = main.c
# List Assembler source files here (make them always end in a capital .S!)
ASRC =
# List any extra directories to look for include files here
EXTRAINCDIRS =
# Doxygen configuration file (leave empty if not available)
DOXYFILE =
# C Standard level (can be c89, gnu89, c99 or gnu99)
CSTANDARD = -std=gnu99
# Output format (can be srec, ihex or binary)
FORMAT = ihex
# Debugging format
DEBUG = dwarf-2
# Programming hardware
AVRDUDE_PROGRAMMER = usbasp
AVRDUDE_PORT = lpt1
# Object files directory (don't leave it empty, put . instead!)
OBJDIR = .
# Place -D or -U options here for all sources
COMDEFS = -DBLS_START=$(BLS_START)
COMDEFS += -DBOOT_WAIT=$(BOOT_WAIT)
COMDEFS += -DBAUD=$(BAUD_RATE)
COMDEFS += -DXTAL=$(F_CPU)
COMDEFS += -DMCU=$(MCU)
# Place -D or -U options here for C sources
CDEFS =
# Place -D or -U options here for ASM sources
ADEFS =
#---------------- 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 += -DF_CPU=$(F_CPU)UL
CFLAGS += $(COMDEFS)
CFLAGS += $(CDEFS)
CFLAGS += -O$(OPT)
CFLAGS += -fgnu89-inline
CFLAGS += -funsigned-char
CFLAGS += -funsigned-bitfields
CFLAGS += -fpack-struct
CFLAGS += -fshort-enums
CFLAGS += -fno-tree-scev-cprop
CFLAGS += -fno-inline-small-functions
CFLAGS += -fno-split-wide-types
CFLAGS += -ffreestanding
CFLAGS += -mno-interrupts
#CFLAGS += -mshort-calls
CFLAGS += -pedantic
CFLAGS += -Wextra
CFLAGS += -Wno-sign-compare
CFLAGS += -Wstrict-prototypes
CFLAGS += -Wundef
#CFLAGS += -Wunreachable-code
CFLAGS += -Wa,-adhlns=$(<:%.c=$(OBJDIR)/%.lst)
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
CFLAGS += $(CSTANDARD)
CFLAGS += -Wno-deprecated-declarations -D__PROG_TYPES_COMPAT__
#---------------- 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 = -gstabs
ASFLAGS += -DF_CPU=$(F_CPU)
ASFLAGS += $(COMDEFS)
ASFLAGS += $(ADEFS)
ASFLAGS += -Wa,-adhlns=$(<:%.S=$(OBJDIR)/%.lst)
ASFLAGS += -listing-cont-lines=100
#---------------- Library Options ----------------
# 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 =
#---------------- 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 += -Wl,--relax
LDFLAGS += -nostartfiles
LDFLAGS += -Wl,--section-start=.text=$(BLS_START)
LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
#LDFLAGS += -T linker_script.x
#---------------- Programming Options (avrdude) ----------------
AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
#============================================================================
# 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
DOXYGEN = doxygen
# Define all object files.
OBJ = $(SRC:%.c=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o)
# Define all listing files.
LST = $(SRC:%.c=$(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_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
#============================================================================
# Default target.
all: begin sizebefore build sizeafter end
# Change the build target to build a HEX file or a library.
build: elf hex lss sym
#build: lib
burn: fuse program lock
elf: $(TARGET).elf
hex: $(TARGET).hex
lss: $(TARGET).lss
sym: $(TARGET).sym
LIBNAME=lib$(TARGET).a
lib: $(LIBNAME)
# Eye candy.
begin:
@echo
@echo -------- begin --------
end:
@echo -------- 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 Size before:; $(ELFSIZE); \
2>/dev/null; fi
sizeafter:
@if test -f $(TARGET).elf; then echo; echo Size after:; $(ELFSIZE); \
2>/dev/null; fi
# Program the device.
program: $(TARGET).hex
@echo
@echo Programming Flash memory:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U flash:w:$(TARGET).hex
# Program fusebits.
fuse: $(TARGET).elf
@echo
ifdef LFUSE
@echo Programming low fusebits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U lfuse:w:$(LFUSE):m
else
@echo Creating load file for low fusebits:
-$(OBJCOPY) -j .fuse --change-section-lma .fuse=0 --no-change-warnings \
-i 3 -b 0 -O $(FORMAT) $< $(TARGET).lfuse || exit 0
@echo
@echo Programming low fusebits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U lfuse:w:$(TARGET).lfuse
endif
@echo
ifdef HFUSE
@echo Programming high fusebits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U hfuse:w:$(HFUSE):m
else
@echo Creating load file for high fusebits:
-$(OBJCOPY) -j .fuse --change-section-lma .fuse=0 --no-change-warnings \
-i 3 -b 1 -O $(FORMAT) $< $(TARGET).hfuse || exit 0
@echo
@echo Programming high fusebits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U hfuse:w:$(TARGET).hfuse
endif
@echo
ifdef EFUSE
@echo Programming extended fusebits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U efuse:w:$(EFUSE):m
else
@echo Creating load file for extended fusebits:
-$(OBJCOPY) -j .fuse --change-section-lma .fuse=0 --no-change-warnings \
-i 3 -b 2 -O $(FORMAT) $< $(TARGET).efuse || exit 0
@echo
@echo Programming extended fusebits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U efuse:w:$(TARGET).efuse
endif
# Program lockbits.
lock: $(TARGET).elf
@echo
ifdef LOCK
@echo Programming lockbits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U lock:w:$(LOCK):m
else
@echo Creating load file for lockbits:
-$(OBJCOPY) -j .lock --change-section-lma .lock=0 --no-change-warnings \
-O $(FORMAT) $< $(TARGET).lock || exit 0
@echo
@echo Programming lockbits:
$(AVRDUDE) $(AVRDUDE_FLAGS) -U lock:w:$(TARGET).lock
endif
# Generate documentation with Doxygen.
doc:
@if test -f $(DOXYFILE); echo; then $(DOXYGEN) $(DOXYFILE); fi
# Display sizes of the object files.
size: $(OBJ)
@echo
@echo Sizes of the object files "(Flash = .text + .data, RAM = .data + .bss)":
$(SIZE) -B -d -t --common $(OBJ)
# Create final output file (.hex) from ELF output file.
%.hex: %.elf
@echo
@echo Creating load file for Flash: $@
$(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock $< $@
# Create extended listing file from ELF output file.
%.lss: %.elf
@echo
@echo Creating Extended Listing: $@
$(OBJDUMP) -h -S -z $< > $@
# Create a symbol table from ELF output file.
%.sym: %.elf
@echo
@echo Creating Symbol Table: $@
$(NM) -n $< > $@
# Create library from object files.
.SECONDARY : $(TARGET).a
.PRECIOUS : $(OBJ)
%.a: $(OBJ)
@echo
@echo Creating library: $@
$(AR) $@ $(OBJ)
# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
@echo
@echo Linking: $@
$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)
# Compile: create object files from C source files.
$(OBJDIR)/%.o : %.c
@echo
@echo Compiling C: $<
$(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.
$(OBJDIR)/%.o : %.S
@echo
@echo 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 Cleaning project:
$(REMOVE) $(TARGET).hex
$(REMOVE) $(TARGET).lfuse
$(REMOVE) $(TARGET).hfuse
$(REMOVE) $(TARGET).efuse
$(REMOVE) $(TARGET).lock
$(REMOVE) $(TARGET).elf
$(REMOVE) $(TARGET).map
$(REMOVE) $(TARGET).sym
$(REMOVE) $(TARGET).lss
$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.o)
$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.lst)
$(REMOVE) $(ASRC:%.S=$(OBJDIR)/%.o)
$(REMOVE) $(ASRC:%.S=$(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 \
build elf hex lss sym \
clean clean_list program fuse lock doc[/syntax]
Na tym działa na 100%
Pozdrawiam
Jarek
Statystyki: Napisane przez jark — 9 lut 2016, o 21:56
]]>