Man Linux: Main Page and Category List


       overview - .TH "overview" 3 "Thu Aug 12 2010" "Version 1.6.8" "avr-


       overview - .SH "Introduction"

       Welcome to the open source software development toolset for the Atmel

       There is not a single tool that provides everything needed to develop
       software for the AVR. It takes many tools working together.
       Collectively, the group of tools are called a toolset, or commonly a
       toolchain, as the tools are chained together to produce the final
       executable application for the AVR microcontroller.

       The following sections provide an overview of all of these tools. You
       may be used to cross-compilers that provide everything with a GUI
       front-end, and not know what goes on 'underneath the hood'. You may be
       coming from a desktop or server computer background and not used to
       embedded systems. Or you may be just learning about the most common
       software development toolchain available on Unix and Linux systems.
       Hopefully the following overview will be helpful in putting everything
       in perspective.


       According to its website, "the Free Software Foundation (FSF),
       established in 1985, is dedicated to promoting computer users' rights
       to use, study, copy, modify, and redistribute computer programs. The
       FSF promotes the development and use of free software, particularly the
       GNU operating system, used widely in its GNU/Linux variant." The FSF
       remains the primary sponsor of the GNU project.

       The GNU Project was launched in 1984 to develop a complete Unix-like
       operating system which is free software: the GNU system. GNU is a
       recursive acronym for GNU's Not Unix; it is pronounced guh-noo,
       approximately like canoe.

       One of the main projects of the GNU system is the GNU Compiler
       Collection, or GCC, and its sister project, GNU Binutils. These two
       open source projects provide a foundation for a software development
       toolchain. Note that these projects were designed to originally run on
       Unix-like systems.


       GCC stands for GNU Compiler Collection. GCC is highly flexible compiler
       system. It has different compiler front-ends for different languages.
       It has many back-ends that generate assembly code for many different
       processors and host operating systems. All share a common 'middle-end',
       containing the generic parts of the compiler, including a lot of

       In GCC, a host system is the system (processor/OS) that the compiler
       runs on. A target system is the system that the compiler compiles code
       for. And, a build system is the system that the compiler is built (from
       source code) on. If a compiler has the same system for host and for
       target, it is known as a native compiler. If a compiler has different
       systems for host and target, it is known as a cross-compiler. (And if
       all three, build, host, and target systems are different, it is known
       as a Canadian cross compiler, but we won't discuss that here.) When GCC
       is built to execute on a host system such as FreeBSD, Linux, or
       Windows, and it is built to generate code for the AVR microcontroller
       target, then it is a cross compiler, and this version of GCC is
       commonly known as 'AVR GCC'. In documentation, or discussion, AVR GCC
       is used when referring to GCC targeting specifically the AVR, or
       something that is AVR specific about GCC. The term 'GCC' is usually
       used to refer to something generic about GCC, or about GCC as a whole.

       GCC is different from most other compilers. GCC focuses on translating
       a high-level language to the target assembly only. AVR GCC has three
       available compilers for the AVR: C language, C++, and Ada. The compiler
       itself does not assemble or link the final code.

       GCC is also known as a 'driver' program, in that it knows about, and
       drives other programs seamlessly to create the final output. The
       assembler, and the linker are part of another open source project
       called GNU Binutils. GCC knows how to drive the GNU assembler (gas) to
       assemble the output of the compiler. GCC knows how to drive the GNU
       linker (ld) to link all of the object modules into a final executable.

       The two projects, GCC and Binutils, are very much interrelated and many
       of the same volunteers work on both open source projects.

       When GCC is built for the AVR target, the actual program names are
       prefixed with 'avr-'. So the actual executable name for AVR GCC is:
       avr-gcc. The name 'avr-gcc' is used in documentation and discussion
       when referring to the program itself and not just the whole AVR GCC

       See the GCC Web Site and GCC User Manual for more information about

GNU Binutils

       The name GNU Binutils stands for 'Binary Utilities'. It contains the
       GNU assembler (gas), and the GNU linker (ld), but also contains many
       other utilities that work with binary files that are created as part of
       the software development toolchain.

       Again, when these tools are built for the AVR target, the actual
       program names are prefixed with 'avr-'. For example, the assembler
       program name, for a native assembler is 'as' (even though in
       documentation the GNU assembler is commonly referred to as 'gas'). But
       when built for an AVR target, it becomes 'avr-as'. Below is a list of
       the programs that are included in Binutils:

           The Assembler.

           The Linker.

           Create, modify, and extract from libraries (archives).

           Generate index to library (archive) contents.

           Copy and translate object files to different formats.

           Display information from object files including disassembly.

           List section sizes and total size.

           List symbols from object files.

           List printable strings from files.

           Discard symbols from files.

           Display the contents of ELF format files.

           Convert addresses to file and line.

           Filter to demangle encoded C++ symbols.


       GCC and Binutils provides a lot of the tools to develop software, but
       there is one critical component that they do not provide: a Standard C

       There are different open source projects that provide a Standard C
       Library depending upon your system time, whether for a native compiler
       (GNU Libc), for some other embedded system (newlib), or for some
       versions of Linux (uCLibc). The open source AVR toolchain has its own
       Standard C Library project: avr-libc.

       AVR-Libc provides many of the same functions found in a regular
       Standard C Library and many additional library functions that is
       specific to an AVR. Some of the Standard C Library functions that are
       commonly used on a PC environment have limitations or additional issues
       that a user needs to be aware of when used on an embedded system.

       AVR-Libc also contains the most documentation about the whole AVR

Building Software

       Even though GCC, Binutils, and avr-libc are the core projects that are
       used to build software for the AVR, there is another piece of software
       that ties it all together: Make. GNU Make is a program that makes
       things, and mainly software. Make interprets and executes a Makefile
       that is written for a project. A Makefile contains dependency rules,
       showing which output files are dependent upon which input files, and
       instructions on how to build output files from input files.

       Some distributions of the toolchains, and other AVR tools such as
       MFile, contain a Makefile template written for the AVR toolchain and
       AVR applications that you can copy and modify for your application.

       See the GNU Make User Manual for more information.


       After creating your software, you'll want to program your device. You
       can do this by using the program AVRDUDE which can interface with
       various hardware devices to program your processor.

       AVRDUDE is a very flexible package. All the information about AVR
       processors and various hardware programmers is stored in a text
       database. This database can be modified by any user to add new hardware
       or to add an AVR processor if it is not already listed.

GDB / Insight / DDD

       The GNU Debugger (GDB) is a command-line debugger that can be used with
       the rest of the AVR toolchain. Insight is GDB plus a GUI written in
       Tcl/Tk. Both GDB and Insight are configured for the AVR and the main
       executables are prefixed with the target name: avr-gdb, and avr-
       insight. There is also a 'text mode' GUI for GDB: avr-gdbtui. DDD (Data
       Display Debugger) is another popular GUI front end to GDB, available on
       Unix and Linux systems.


       AVaRICE is a back-end program to AVR GDB and interfaces to the Atmel
       JTAG In-Circuit Emulator (ICE), to provide emulation capabilities.


       SimulAVR is an AVR simulator used as a back-end with AVR GDB.
       Unfortunately, this project is currently unmaintained and could use
       some help.


       There are also other optional utilities available that may be useful to
       add to your toolset.

       SRecord is a collection of powerful tools for manipulating EPROM load
       files. It reads and writes numerous EPROM file formats, and can perform
       many different manipulations.

       MFile is a simple Makefile generator is meant as an aid to quickly
       customize a Makefile to use for your AVR application.

Toolchain Distributions (Distros)

       All of the various open source projects that comprise the entire
       toolchain are normally distributed as source code. It is left up to the
       user to build the tool application from its source code. This can be a
       very daunting task to any potential user of these tools.

       Luckily there are people who help out in this area. Volunteers take the
       time to build the application from source code on particular host
       platforms and sometimes packaging the tools for convenient installation
       by the end user. These packages contain the binary executables of the
       tools, pre-made and ready to use. These packages are known as
       'distributions' of the AVR toolchain, or by a more shortened name,

       AVR toolchain distros are available on FreeBSD, Windows, Mac OS X, and
       certain flavors of Linux.

Open Source

       All of these tools, from the original source code in the multitude of
       projects, to the various distros, are put together by many, many
       volunteers. All of these projects could always use more help from other
       people who are willing to volunteer some of their time. There are many
       different ways to help, for people with varying skill levels,
       abilities, and available time.

       You can help to answer questions in mailing lists such as the avr-gcc-
       list, or on forums at the AVR Freaks website. This helps many people
       new to the open source AVR tools.

       If you think you found a bug in any of the tools, it is always a big
       help to submit a good bug report to the proper project. A good bug
       report always helps other volunteers to analyze the problem and to get
       it fixed for future versions of the software.

       You can also help to fix bugs in various software projects, or to add
       desirable new features.

       Volunteers are always welcome! :-)