demo_project(3)

NAME
demo_project - A simple projectAt this point, you should have the GNU tools configured, built, and installed on your system. In this chapter, we present a simple example of using the GNU tools in an AVR project. After reading this chapter, you should have a better feel as to how the tools are used and how a Makefile can be configured.

The Project

This project will use the pulse-width modulator (PWM) to ramp an LED on and off every two seconds. An AT90S2313 processor will be used as the controller. The circuit for this demonstration is shown in the schematic diagram. If you have a development kit, you should be able to use it, rather than build the circuit, for this project.

Note:
    Meanwhile, the AT90S2313 became obsolete. Either use its successor, the (pin-compatible) ATtiny2313 for the project, or perhaps the ATmega8 or one of its successors (ATmega48/88/168) which have become quite popular since the original demo project had been established. For all these more modern devices, it is no longer necessary to use an external crystal for clocking as they ship with the internal 1 MHz oscillator enabled, so C1, C2, and Q1 can be omitted. Normally, for this experiment, the external circuitry on /RESET (R1, C3) can be omitted as well, leaving only the AVR, the LED, the bypass capacitor C4, and perhaps R2. For the ATmega8/48/88/168, use PB1 (pin 15 at the DIP-28 package) to connect the LED to. Additionally, this demo has been ported to many different other AVRs. The location of the respective OC pin varies between different AVRs, and it is mandated by the AVR hardware.

Schematic of circuit for demo projectSchematic of circuit for demo project

The source code is given in demo.c. For the sake of this example, create a file called demo.c containing this source code. Some of the more important parts of the code are:

Note [1]:
    As the AVR microcontroller series has been developed during the past years, new features have been added over time. Even though the basic concepts of the timer/counter1 are still the same as they used to be back in early 2001 when this simple demo was written initially, the names of registers and bits have been changed slightly to reflect the new features. Also, the port and pin mapping of the output compare match 1A (or 1 for older devices) pin which is used to control the LED varies between different AVRs. The file iocompat.h tries to abstract between all this differences using some preprocessor #ifdef statements, so the actual program itself can operate on a common set of symbolic names. The macros defined by that file are:

•   OCR the name of the OCR register used to control the PWM (usually either OCR1 or OCR1A)

•   DDROC the name of the DDR (data direction register) for the OC output

•   OC1 the pin number of the OC1[A] output within its port

•   TIMER1_TOP the TOP value of the timer used for the PWM (1023 for 10-bit PWMs, 255 for devices that can only handle an 8-bit PWM)

•   TIMER1_PWM_INIT the initialization bits to be set into control register 1A in order to setup 10-bit (or 8-bit) phase and frequency correct PWM mode

•   TIMER1_CLOCKSOURCE the clock bits to set in the respective control register to start the PWM timer; usually the timer runs at full CPU clock for 10-bit PWMs, while it runs on a prescaled clock for 8-bit PWMs

Note [2]:
    ISR() is a macro that marks the function as an interrupt routine. In this case, the function will get called when timer 1 overflows. Setting up interrupts is explained in greater detail in <avr/interrupt.h>: Interrupts.

Note [3]:
    The PWM is being used in 10-bit mode, so we need a 16-bit variable to remember the current value.

Note [4]:
    This section determines the new value of the PWM.

Note [5]:
    Here's where the newly computed value is loaded into the PWM register. Since we are in an interrupt routine, it is safe to use a 16-bit assignment to the register. Outside of an interrupt, the assignment should only be performed with interrupts disabled if there's a chance that an interrupt routine could also access this register (or another register that uses TEMP), see the appropriate FAQ entry.

Note [6]:
    This routine gets called after a reset. It initializes the PWM and enables interrupts.

Note [7]:
    The main loop of the program does nothing -- all the work is done by the interrupt routine! The sleep_mode() puts the processor on sleep until the next interrupt, to conserve power. Of course, that probably won't be noticable as we are still driving a LED, it is merely mentioned here to demonstrate the basic principle.

Note [8]:
    Early AVR devices saturate their outputs at rather low currents when sourcing current, so the LED can be connected directly, the resulting current through the LED will be about 15 mA. For modern parts (at least for the ATmega 128), however Atmel has drastically increased the IO source capability, so when operating at 5 V Vcc, R2 is needed. Its value should be about 150 Ohms. When operating the circuit at 3 V, it can still be omitted though.

The Source Code

/*
 * ----------------------------------------------------------------------------
 * "THE BEER-WARE LICENSE" (Revision 42):
 * <joerg@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
 * can do whatever you want with this stuff. If we meet some day, and you think
 * this stuff is worth it, you can buy me a beer in return.        Joerg Wunsch
 * ----------------------------------------------------------------------------
 *
 * Simple AVR demonstration.  Controls a LED that can be directly
 * connected from OC1/OC1A to GND.  The brightness of the LED is
 * controlled with the PWM.  After each period of the PWM, the PWM
 * value is either incremented or decremented, that's all.
 *
 * $Id: demo.c 1637 2008-03-17 21:49:41Z joerg_wunsch $
 */
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include "iocompat.h"        /* Note [1] */
enum { UP, DOWN };
ISR (TIMER1_OVF_vect)       /* Note [2] */
{
    static uint16_t pwm;    /* Note [3] */
    static uint8_t direction;
    switch (direction)      /* Note [4] */
    {
        case UP:
            if (++pwm == TIMER1_TOP)
                direction = DOWN;
            break;
        case DOWN:
            if (--pwm == 0)
                direction = UP;
            break;
    }
    OCR = pwm;          /* Note [5] */
}
void
ioinit (void)           /* Note [6] */
{
    /* Timer 1 is 10-bit PWM (8-bit PWM on some ATtinys). */
    TCCR1A = TIMER1_PWM_INIT;
    /*
     * Start timer 1.
     *
     * NB: TCCR1A and TCCR1B could actually be the same register, so
     * take care to not clobber it.
     */
    TCCR1B |= TIMER1_CLOCKSOURCE;
    /*
     * Run any device-dependent timer 1 setup hook if present.
     */
#if defined(TIMER1_SETUP_HOOK)
    TIMER1_SETUP_HOOK();
#endif
    /* Set PWM value to 0. */
    OCR = 0;
    /* Enable OC1 as output. */
    DDROC = _BV (OC1);
    /* Enable timer 1 overflow interrupt. */
    TIMSK = _BV (TOIE1);
    sei ();
}
int
main (void)
{
    ioinit ();
    /* loop forever, the interrupts are doing the rest */
    for (;;)            /* Note [7] */
        sleep_mode();
    return (0);
}

Compiling and Linking

This first thing that needs to be done is compile the source. When compiling, the compiler needs to know the processor type so the -mmcu option is specified. The -Os option will tell the compiler to optimize the code for efficient space usage (at the possible expense of code execution speed). The -g is used to embed debug info. The debug info is useful for disassemblies and doesn't end up in the .hex files, so I usually specify it. Finally, the -c tells the compiler to compile and stop -- don't link. This demo is small enough that we could compile and link in one step. However, real-world projects will have several modules and will typically need to break up the building of the project into several compiles and one link.

    $ avr-gcc -g -Os -mmcu=atmega8 -c demo.c

The compilation will create a demo.o file. Next we link it into a binary called demo.elf.

    $ avr-gcc -g -mmcu=atmega8 -o demo.elf demo.o

It is important to specify the MCU type when linking. The compiler uses the -mmcu option to choose start-up files and run-time libraries that get linked together. If this option isn't specified, the compiler defaults to the 8515 processor environment, which is most certainly what you didn't want.

Examining the Object File

Now we have a binary file. Can we do anything useful with it (besides put it into the processor?) The GNU Binutils suite is made up of many useful tools for manipulating object files that get generated. One tool is avr-objdump, which takes information from the object file and displays it in many useful ways. Typing the command by itself will cause it to list out its options.

For instance, to get a feel of the application's size, the -h option can be used. The output of this option shows how much space is used in each of the sections (the .stab and .stabstr sections hold the debugging information and won't make it into the ROM file).

An even more useful option is -S. This option disassembles the binary file and intersperses the source code in the output! This method is much better, in my opinion, than using the -S with the compiler because this listing includes routines from the libraries and the vector table contents. Also, all the 'fix-ups' have been satisfied. In other words, the listing generated by this option reflects the actual code that the processor will run.

    $ avr-objdump -h -S demo.elf > demo.lst

Here's the output as saved in the demo.lst file:

demo.elf:     file format elf32-avr
Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         000000d0  00000000  00000000  00000094  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000000  00800060  000000d0  00000164  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .bss          00000003  00800060  00800060  00000164  2**0
                  ALLOC
  3 .stab         0000075c  00000000  00000000  00000164  2**2
                  CONTENTS, READONLY, DEBUGGING
  4 .stabstr      00000d21  00000000  00000000  000008c0  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .comment      00000011  00000000  00000000  000015e1  2**0
                  CONTENTS, READONLY
Disassembly of section .text:
00000000 <__ctors_end>:
   0:	20 e0       	ldi	r18, 0x00	; 0
   2:	a0 e6       	ldi	r26, 0x60	; 96
   4:	b0 e0       	ldi	r27, 0x00	; 0
   6:	01 c0       	rjmp	.+2      	; 0xa <.do_clear_bss_start>
00000008 <.do_clear_bss_loop>:
   8:	1d 92       	st	X+, r1
0000000a <.do_clear_bss_start>:
   a:	a3 36       	cpi	r26, 0x63	; 99
   c:	b2 07       	cpc	r27, r18
   e:	e1 f7       	brne	.-8      	; 0x8 <.do_clear_bss_loop>
00000010 <__vector_8>:
#include "iocompat.h"		/* Note [1] */
enum { UP, DOWN };
ISR (TIMER1_OVF_vect)		/* Note [2] */
{
  10:	1f 92       	push	r1
  12:	0f 92       	push	r0
  14:	0f b6       	in	r0, 0x3f	; 63
  16:	0f 92       	push	r0
  18:	11 24       	eor	r1, r1
  1a:	2f 93       	push	r18
  1c:	8f 93       	push	r24
  1e:	9f 93       	push	r25
    static uint16_t pwm;	/* Note [3] */
    static uint8_t direction;
    switch (direction)		/* Note [4] */
  20:	80 91 62 00 	lds	r24, 0x0062
  24:	88 23       	and	r24, r24
  26:	f1 f0       	breq	.+60     	; 0x64 <__SREG__+0x25>
  28:	81 30       	cpi	r24, 0x01	; 1
  2a:	71 f4       	brne	.+28     	; 0x48 <__SREG__+0x9>
            if (++pwm == TIMER1_TOP)
                direction = DOWN;
            break;
        case DOWN:
            if (--pwm == 0)
  2c:	80 91 60 00 	lds	r24, 0x0060
  30:	90 91 61 00 	lds	r25, 0x0061
  34:	01 97       	sbiw	r24, 0x01	; 1
  36:	90 93 61 00 	sts	0x0061, r25
  3a:	80 93 60 00 	sts	0x0060, r24
  3e:	00 97       	sbiw	r24, 0x00	; 0
  40:	39 f4       	brne	.+14     	; 0x50 <__SREG__+0x11>
                direction = UP;
  42:	10 92 62 00 	sts	0x0062, r1
  46:	04 c0       	rjmp	.+8      	; 0x50 <__SREG__+0x11>
  48:	80 91 60 00 	lds	r24, 0x0060
  4c:	90 91 61 00 	lds	r25, 0x0061
            break;
    }
    OCR = pwm;			/* Note [5] */
  50:	9b bd       	out	0x2b, r25	; 43
  52:	8a bd       	out	0x2a, r24	; 42
}
  54:	9f 91       	pop	r25
  56:	8f 91       	pop	r24
  58:	2f 91       	pop	r18
  5a:	0f 90       	pop	r0
  5c:	0f be       	out	0x3f, r0	; 63
  5e:	0f 90       	pop	r0
  60:	1f 90       	pop	r1
  62:	18 95       	reti
    static uint8_t direction;
    switch (direction)		/* Note [4] */
    {
        case UP:
            if (++pwm == TIMER1_TOP)
  64:	80 91 60 00 	lds	r24, 0x0060
  68:	90 91 61 00 	lds	r25, 0x0061
  6c:	01 96       	adiw	r24, 0x01	; 1
  6e:	90 93 61 00 	sts	0x0061, r25
  72:	80 93 60 00 	sts	0x0060, r24
  76:	8f 3f       	cpi	r24, 0xFF	; 255
  78:	23 e0       	ldi	r18, 0x03	; 3
  7a:	92 07       	cpc	r25, r18
  7c:	49 f7       	brne	.-46     	; 0x50 <__SREG__+0x11>
                direction = DOWN;
  7e:	21 e0       	ldi	r18, 0x01	; 1
  80:	20 93 62 00 	sts	0x0062, r18
  84:	e5 cf       	rjmp	.-54     	; 0x50 <__SREG__+0x11>
00000086 <ioinit>:
void
ioinit (void)			/* Note [6] */
{
    /* Timer 1 is 10-bit PWM (8-bit PWM on some ATtinys). */
    TCCR1A = TIMER1_PWM_INIT;
  86:	83 e8       	ldi	r24, 0x83	; 131
  88:	8f bd       	out	0x2f, r24	; 47
     * Start timer 1.
     *
     * NB: TCCR1A and TCCR1B could actually be the same register, so
     * take care to not clobber it.
     */
    TCCR1B |= TIMER1_CLOCKSOURCE;
  8a:	8e b5       	in	r24, 0x2e	; 46
  8c:	81 60       	ori	r24, 0x01	; 1
  8e:	8e bd       	out	0x2e, r24	; 46
#if defined(TIMER1_SETUP_HOOK)
    TIMER1_SETUP_HOOK();
#endif
    /* Set PWM value to 0. */
    OCR = 0;
  90:	1b bc       	out	0x2b, r1	; 43
  92:	1a bc       	out	0x2a, r1	; 42
    /* Enable OC1 as output. */
    DDROC = _BV (OC1);
  94:	82 e0       	ldi	r24, 0x02	; 2
  96:	87 bb       	out	0x17, r24	; 23
    /* Enable timer 1 overflow interrupt. */
    TIMSK = _BV (TOIE1);
  98:	84 e0       	ldi	r24, 0x04	; 4
  9a:	89 bf       	out	0x39, r24	; 57
    sei ();
  9c:	78 94       	sei
  9e:	08 95       	ret
000000a0 <main>:
void
ioinit (void)			/* Note [6] */
{
    /* Timer 1 is 10-bit PWM (8-bit PWM on some ATtinys). */
    TCCR1A = TIMER1_PWM_INIT;
  a0:	83 e8       	ldi	r24, 0x83	; 131
  a2:	8f bd       	out	0x2f, r24	; 47
     * Start timer 1.
     *
     * NB: TCCR1A and TCCR1B could actually be the same register, so
     * take care to not clobber it.
     */
    TCCR1B |= TIMER1_CLOCKSOURCE;
  a4:	8e b5       	in	r24, 0x2e	; 46
  a6:	81 60       	ori	r24, 0x01	; 1
  a8:	8e bd       	out	0x2e, r24	; 46
#if defined(TIMER1_SETUP_HOOK)
    TIMER1_SETUP_HOOK();
#endif
    /* Set PWM value to 0. */
    OCR = 0;
  aa:	1b bc       	out	0x2b, r1	; 43
  ac:	1a bc       	out	0x2a, r1	; 42
    /* Enable OC1 as output. */
    DDROC = _BV (OC1);
  ae:	82 e0       	ldi	r24, 0x02	; 2
  b0:	87 bb       	out	0x17, r24	; 23
    /* Enable timer 1 overflow interrupt. */
    TIMSK = _BV (TOIE1);
  b2:	84 e0       	ldi	r24, 0x04	; 4
  b4:	89 bf       	out	0x39, r24	; 57
    sei ();
  b6:	78 94       	sei
    ioinit ();
    /* loop forever, the interrupts are doing the rest */
    for (;;)			/* Note [7] */
        sleep_mode();
  b8:	85 b7       	in	r24, 0x35	; 53
  ba:	80 68       	ori	r24, 0x80	; 128
  bc:	85 bf       	out	0x35, r24	; 53
  be:	88 95       	sleep
  c0:	85 b7       	in	r24, 0x35	; 53
  c2:	8f 77       	andi	r24, 0x7F	; 127
  c4:	85 bf       	out	0x35, r24	; 53
  c6:	f8 cf       	rjmp	.-16     	; 0xb8 <main+0x18>
000000c8 <exit>:
  c8:	f8 94       	cli
  ca:	00 c0       	rjmp	.+0      	; 0xcc <_exit>
000000cc <_exit>:
  cc:	f8 94       	cli
000000ce <__stop_program>:
  ce:	ff cf       	rjmp	.-2      	; 0xce <__stop_program>

Linker Map Files

avr-objdump is very useful, but sometimes it's necessary to see information about the link that can only be generated by the linker. A map file contains this information. A map file is useful for monitoring the sizes of your code and data. It also shows where modules are loaded and which modules were loaded from libraries. It is yet another view of your application. To get a map file, I usually add -Wl,-Map,demo.map to my link command. Relink the application using the following command to generate demo.map (a portion of which is shown below).

    $ avr-gcc -g -mmcu=atmega8 -Wl,-Map,demo.map -o demo.elf demo.o

Some points of interest in the demo.map file are:

.rela.plt
 *(.rela.plt)
.text           0x0000000000000000       0xd0
 *(.vectors)
 *(.vectors)
 *(.progmem.gcc*)
                0x0000000000000000                . = ALIGN (0x2)
                0x0000000000000000                __trampolines_start = .
 *(.trampolines)
 .trampolines   0x0000000000000000        0x0 linker stubs
 *(.trampolines*)
                0x0000000000000000                __trampolines_end = .
 *(.progmem*)
                0x0000000000000000                . = ALIGN (0x2)
 *(.jumptables)
 *(.jumptables*)
 *(.lowtext)
 *(.lowtext*)
                0x0000000000000000                __ctors_start = .

The .text segment (where program instructions are stored) starts at location 0x0.

 *(.fini2)
 *(.fini2)
 *(.fini1)
 *(.fini1)
 *(.fini0)
 .fini0         0x00000000000000cc        0x4 /junk/testroot/lib/gcc/avr/5.3.0/avr4/libgcc.a(_exit.o)
 *(.fini0)
                0x00000000000000d0                _etext = .
.data           0x0000000000800060        0x0 load address 0x00000000000000d0
                0x0000000000800060                PROVIDE (__data_start, .)
 *(.data)
 .data          0x0000000000800060        0x0 demo.o
 .data          0x0000000000800060        0x0 /home/joerg/src/avr-libc/avr/lib/avr4/exit.o
 .data          0x0000000000800060        0x0 /junk/testroot/lib/gcc/avr/5.3.0/avr4/libgcc.a(_exit.o)
 .data          0x0000000000800060        0x0 /junk/testroot/lib/gcc/avr/5.3.0/avr4/libgcc.a(_clear_bss.o)
 *(.data*)
 *(.rodata)
 *(.rodata*)
 *(.gnu.linkonce.d*)
                0x0000000000800060                . = ALIGN (0x2)
                0x0000000000800060                _edata = .
                0x0000000000800060                PROVIDE (__data_end, .)
.bss            0x0000000000800060        0x3
                0x0000000000800060                PROVIDE (__bss_start, .)
 *(.bss)
 .bss           0x0000000000800060        0x3 demo.o
 .bss           0x0000000000800063        0x0 /home/joerg/src/avr-libc/avr/lib/avr4/exit.o
 .bss           0x0000000000800063        0x0 /junk/testroot/lib/gcc/avr/5.3.0/avr4/libgcc.a(_exit.o)
 .bss           0x0000000000800063        0x0 /junk/testroot/lib/gcc/avr/5.3.0/avr4/libgcc.a(_clear_bss.o)
 *(.bss*)
 *(COMMON)
                0x0000000000800063                PROVIDE (__bss_end, .)
                0x00000000000000d0                __data_load_start = LOADADDR (.data)
                0x00000000000000d0                __data_load_end = (__data_load_start + SIZEOF (.data))
.noinit         0x0000000000800063        0x0
                0x0000000000800063                PROVIDE (__noinit_start, .)
 *(.noinit*)
                0x0000000000800063                PROVIDE (__noinit_end, .)
                0x0000000000800063                _end = .
                0x0000000000800063                PROVIDE (__heap_start, .)
.eeprom         0x0000000000810000        0x0
 *(.eeprom*)
                0x0000000000810000                __eeprom_end = .

The last address in the .text segment is location 0x114 ( denoted by _etext ), so the instructions use up 276 bytes of FLASH.

The .data segment (where initialized static variables are stored) starts at location 0x60, which is the first address after the register bank on an ATmega8 processor.

The next available address in the .data segment is also location 0x60, so the application has no initialized data.

The .bss segment (where uninitialized data is stored) starts at location 0x60.

The next available address in the .bss segment is location 0x63, so the application uses 3 bytes of uninitialized data.

The .eeprom segment (where EEPROM variables are stored) starts at location 0x0.

The next available address in the .eeprom segment is also location 0x0, so there aren't any EEPROM variables.

Generating Intel Hex Files

We have a binary of the application, but how do we get it into the processor? Most (if not all) programmers will not accept a GNU executable as an input file, so we need to do a little more processing. The next step is to extract portions of the binary and save the information into .hex files. The GNU utility that does this is called avr-objcopy.

The ROM contents can be pulled from our project's binary and put into the file demo.hex using the following command:

    $ avr-objcopy -j .text -j .data -O ihex demo.elf demo.hex

The resulting demo.hex file contains:

:1000000020E0A0E6B0E001C01D92A336B207E1F700
:100010001F920F920FB60F9211242F938F939F93DD
:10002000809162008823F1F0813071F4809160004A
:100030009091610001979093610080936000009718
:1000400039F41092620004C08091600090916100C8
:100050009BBD8ABD9F918F912F910F900FBE0F90E6
:100060001F90189580916000909161000196909387
:100070006100809360008F3F23E0920749F721E001
:1000800020936200E5CF83E88FBD8EB581608EBD81
:100090001BBC1ABC82E087BB84E089BF78940895BA
:1000A00083E88FBD8EB581608EBD1BBC1ABC82E01B
:1000B00087BB84E089BF789485B7806885BF8895C1
:1000C00085B78F7785BFF8CFF89400C0F894FFCF3D
:00000001FF

The -j option indicates that we want the information from the .text and .data segment extracted. If we specify the EEPROM segment, we can generate a .hex file that can be used to program the EEPROM:

    $ avr-objcopy -j .eeprom --change-section-lma .eeprom=0 -O ihex demo.elf demo_eeprom.hex

There is no demo_eeprom.hex file written, as that file would be empty.

Starting with version 2.17 of the GNU binutils, the avr-objcopy command that used to generate the empty EEPROM files now aborts because of the empty input section .eeprom, so these empty files are not generated. It also signals an error to the Makefile which will be caught there, and makes it print a message about the empty file not being generated.

Letting Make Build the Project

Rather than type these commands over and over, they can all be placed in a make file. To build the demo project using make, save the following in a file called Makefile.

Note:
    This Makefile can only be used as input for the GNU version of make.

1 PRG            = demo
2 OBJ            = demo.o
3 #MCU_TARGET     = at90s2313
4 #MCU_TARGET     = at90s2333
5 #MCU_TARGET     = at90s4414
6 #MCU_TARGET     = at90s4433
7 #MCU_TARGET     = at90s4434
8 #MCU_TARGET     = at90s8515
9 #MCU_TARGET     = at90s8535
10 #MCU_TARGET     = atmega128
11 #MCU_TARGET     = atmega1280
12 #MCU_TARGET     = atmega1281
13 #MCU_TARGET     = atmega1284p
14 #MCU_TARGET     = atmega16
15 #MCU_TARGET     = atmega163
16 #MCU_TARGET     = atmega164p
17 #MCU_TARGET     = atmega165
18 #MCU_TARGET     = atmega165p
19 #MCU_TARGET     = atmega168
20 #MCU_TARGET     = atmega169
21 #MCU_TARGET     = atmega169p
22 #MCU_TARGET     = atmega2560
23 #MCU_TARGET     = atmega2561
24 #MCU_TARGET     = atmega32
25 #MCU_TARGET     = atmega324p
26 #MCU_TARGET     = atmega325
27 #MCU_TARGET     = atmega3250
28 #MCU_TARGET     = atmega329
29 #MCU_TARGET     = atmega3290
30 #MCU_TARGET     = atmega32u4
31 #MCU_TARGET     = atmega48
32 #MCU_TARGET     = atmega64
33 #MCU_TARGET     = atmega640
34 #MCU_TARGET     = atmega644
35 #MCU_TARGET     = atmega644p
36 #MCU_TARGET     = atmega645
37 #MCU_TARGET     = atmega6450
38 #MCU_TARGET     = atmega649
39 #MCU_TARGET     = atmega6490
40 MCU_TARGET     = atmega8
41 #MCU_TARGET     = atmega8515
42 #MCU_TARGET     = atmega8535
43 #MCU_TARGET     = atmega88
44 #MCU_TARGET     = attiny2313
45 #MCU_TARGET     = attiny24
46 #MCU_TARGET     = attiny25
47 #MCU_TARGET     = attiny26
48 #MCU_TARGET     = attiny261
49 #MCU_TARGET     = attiny44
50 #MCU_TARGET     = attiny45
51 #MCU_TARGET     = attiny461
52 #MCU_TARGET     = attiny84
53 #MCU_TARGET     = attiny85
54 #MCU_TARGET     = attiny861
55 OPTIMIZE       = -O2
56
57 DEFS           =
58 LIBS           =
59
60 # You should not have to change anything below here.
61
62 CC             = avr-gcc
63
64 # Override is only needed by avr-lib build system.
65
66 override CFLAGS        = -g -Wall $(OPTIMIZE) -mmcu=$(MCU_TARGET) $(DEFS)
67 override LDFLAGS       = -Wl,-Map,$(PRG).map
68
69 OBJCOPY        = avr-objcopy
70 OBJDUMP        = avr-objdump
71
72 all: $(PRG).elf lst text eeprom
73
74 $(PRG).elf: $(OBJ)
75     $(CC) $(CFLAGS) $(LDFLAGS) -o $@ $^ $(LIBS)
76
77 # dependency:
78 demo.o: demo.c iocompat.h
79
80 clean:
81     rm -rf *.o $(PRG).elf *.eps *.png *.pdf *.bak
82     rm -rf *.lst *.map $(EXTRA_CLEAN_FILES)
83
84 lst:  $(PRG).lst
85
86 %.lst: %.elf
87     $(OBJDUMP) -h -S $< > $@
88
89 # Rules for building the .text rom images
90
91 text: hex bin srec
92
93 hex:  $(PRG).hex
94 bin:  $(PRG).bin
95 srec: $(PRG).srec
96
97 %.hex: %.elf
98     $(OBJCOPY) -j .text -j .data -O ihex $< $@
99
100 %.srec: %.elf
101     $(OBJCOPY) -j .text -j .data -O srec $< $@
102
103 %.bin: %.elf
104     $(OBJCOPY) -j .text -j .data -O binary $< $@
105
106 # Rules for building the .eeprom rom images
107
108 eeprom: ehex ebin esrec
109
110 ehex:  $(PRG)_eeprom.hex
111 ebin:  $(PRG)_eeprom.bin
112 esrec: $(PRG)_eeprom.srec
113
114 %_eeprom.hex: %.elf
115     $(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O ihex $< $@ 116     || { echo empty $@ not generated; exit 0; }
117
118 %_eeprom.srec: %.elf
119     $(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O srec $< $@ 120     || { echo empty $@ not generated; exit 0; }
121
122 %_eeprom.bin: %.elf
123     $(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O binary $< $@ 124     || { echo empty $@ not generated; exit 0; }
125
126 # Every thing below here is used by avr-libc's build system and can be ignored
127 # by the casual user.
128
129 FIG2DEV                 = fig2dev
130 EXTRA_CLEAN_FILES       = *.hex *.bin *.srec
131
132 dox: eps png pdf
133
134 eps: $(PRG).eps
135 png: $(PRG).png
136 pdf: $(PRG).pdf
137
138 %.eps: %.fig
139     $(FIG2DEV) -L eps $< $@
140
141 %.pdf: %.fig
142     $(FIG2DEV) -L pdf $< $@
143
144 %.png: %.fig
145     $(FIG2DEV) -L png $< $@
146

Reference to the source code

Author

Generated automatically by Doxygen for avr-libc from the source code.