path: root/test/arduino_make.sh

#!/bin/sh
# ardmake: A command-line Arduino make/build environment.     2009-12-08
# For instructions, run with the argument "help"!
#
# This script is Copyright (c) 2009 Kimmo Kulovesi <http://arkku.com/>.
# Use at your own risk only. Released under GPL, see below for details.
# Please mark any modified copies as such, and retain the original
# copyright notice in all relevant files, usage, and documentation.
#
#
#   INTRODUCTION
#
# This script runs the Makefile included with Arduino to compile and
# upload projects on the command-line. This script sets all
# board-specific variables automatically according to the board type,
# as well as detects and adds libraries automatically based on the
# #include-directives in the program (i.e. with the same convenience
# as the graphical Arduino environment). This script also supports
# burning bootloaders, setting fuses, uploading pre-compiled binaries,
# and using certain external programming devices (e.g. for stand-alone
# microcontrollers).
#
# In short, this script can completely replace the Arduino IDE for
# typical Arduino/ATMega development, and in some cases it can even
# do more than the IDE. The intended user is a relatively experienced
# command-line user, who wants to combine the power of their chosen
# editor and tools with the development speed and convenience of
# the Arduino platform. Beginners will probably be more comfortable
# starting with the simple graphical Arduino IDE.
#
# This script is not an official part of Arduino, but since it is
# in active use by its author, it will probably be rapidly updated
# to support any new Arduino releases (and some care has been
# taken to minimise the changes necessary to support each release).
#
#
#   INSTALLATION
#
# Install Arduino somewhere, e.g. /opt/arduino or ~/arduino. If you
# are using additional core types (e.g. Sanguino) or custom board
# types (e.g. ADABoot), also install them. Custom libraries can be
# installed in e.g. ~/sketchbook/libraries, or anywhere you like.
#
# Install the AVR version of GCC (e.g. package name avr-gcc) and
# AVRDUDE (you can probably use the one bundled with Arduino if you
# prefer). Preferably install versions packaged for your specific
# Linux distribution (e.g. with apt-get install avr-gcc avrdude).
#
# Put this script somewhere along your PATH (e.g. /usr/local/bin,
# ~/bin, or wherever you like to install programs). This script is
# distributed by the author as "arduino_make.sh" due to historical
# reasons, but "ardmake" is the suggested name (shorter to type and
# all). Run this script with the parameter "help" and read about
# configuring and usage (usually only the board type needs to be set
# and you are good to go).
#
#
#   SYSTEM REQUIREMENTS
#
# Last been tested with Arduino version 0017 on Ubuntu 9.04, with
# avr-gcc and avrdude installed from Ubuntu packages. While this script
# should run in non-Linux environments, there are some dependencies to
# GNU tools (e.g. GNU Make), so GNU/Linux should be considered the
# preferred/intended environment for running this.
#
#
#   CHANGES
#
# December 2009     - Added a "serial monitor" (target "serial") with
#                     limited support for serial speed autodetection
#                     from the Arduino program.
#                   - Added support for using the "arduino" protocol
#                     in avrdude when available; this eliminates the
#                     need to reset the device with "stty". The old
#                     behaviour can be restored by using the target
#                     "upload_autoreset" instead of "upload".
#                   - Added support for downloading with external
#                     programmers.
#                   - Added basic support for reading configurations
#                     for external programming devices from the
#                     file hardware/programmers.txt, in addition to
#                     the built-in isp and dragon targets. This should
#                     enable the use of parallel programmers.
#                   - Added target "programmers" for listing supported
#                     external programming devices.
#                   - Don't do autoreset when uploading with external
#                     programmers.
#                   - Removed unnecessary debug outputs. 
#                   - Additional documentation in the script file.
# November 2009     - Major bugfix for boards with CPU frequency other
#                     than 16MHz.
#                   - Possibly fixed the __cxa_pure_virtual issue.
#                   - Forcing user to define ARDUINO_BOARD explicitly
#                     since using an incorrect board type can cause
#                     nasty hidden errors.
#                   - Added reset commands to upload and download
#                     when not using the Makefile.
#                   - Added dependency on the board type, i.e. if the
#                     board type is changed, everything gets rebuilt.
#                   - Added target "boards" to list available boards.
#                   - Changed default library path to include the
#                     "~/sketchbook/libraries" directory, similarly to
#                     the current Arduino IDE.
#                   - Made building locally the default and fixed
#                     the problem of dependency files being built in
#                     the core directory.
#                   - Implemented reading configuration from
#                     ~/.ardmake.conf and ardmake.conf in the
#                     sketch directory.
#                   - Fixed build dependencies with Sanguino.
#                   - Rewrote most of the help texts.
#                   - Fixed compatibility with mawk. Thanks to Tom
#                     Parkin for reporting this!
# October 2009      - Support AVRISP and burning bootloaders.
#                   - Support building object files into the
#                     applet directory instead of the core and
#                     library directories.
#                   - Generate automatic dependecies for libraries
#                   - Support uploading specified .hex or .bin
#                     directly without compiling anything
#                   - Support downloading flash memory from
#                     microcontroller to .hex or .bin file
#                   - Replace the slightly broken build target:
#                       - Proper dependencies
#                       - Show correct file name and line numbers for errors
#                       - Display program size compared to controller capacity
# September 2009    - Support Arduino 017
# March 2009        - Support Arduino 014
# February 2009     - Initial version
#
#
#   FANCY ARDUINO DEVICE NODES ON LINUX
#
# The default port for the Arduino is set to "/dev/arduino", which
# requires udev rules (but avoids the problem of changing ttyUSB names).
# Alternatively, it can be changed in this file. The udev rule that
# works for the Arduino clone that I have is this:
#
# KERNEL=="ttyUSB*", ATTRS{product}=="FT232R USB UART", \
# ATTRS{idProduct}=="6001", ATTRS{idVendor}=="0403", \
# SYMLINK+="arduino arduino_$attr{serial}", GROUP="avrprog", MODE="0660"
#
# You will probably want to change the group to "dialout", or create
# the "avrprog" group on your system (like I did). On Ubuntu Linux, place
# the rule in a file inside "/etc/udev/rules.d", e.g. "80-arduino.rules".
#
# If you have many devices with the same product and vendor ids,
# as may be the case with a popular chip like FT232R, you can
# add the condition "ATTRS{serial}" to your udev rules. You can
# see the serial if you first use the above rules and then look at
# the symlink "arduino_SERIAL" where SERIAL is the serial number
# of that particular device. Then create one rule for each of your
# devices' serial numbers (add ATTRS{serial}=="MySerial", right
# before SYMLINK in the above rules).
#
#
#   COMPILER ERROR ABOUT __cxa_pure_virtual
#
# Some versions of Arduino and avr-gcc cause an error about a missing
# function "__cxa_pure_virtual" in programs where C++ classes are used.
# To fix this problem, add the following line anywhere in your program:
#
#   extern "C" void __cxa_pure_virtual() {}
#
###################################################################################
# This script is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License,
# or (at your option) any later version.
#
# This script is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this script.  If not, see <http://www.gnu.org/licenses/>.
###################################################################################
# Read the configuration file (if any):

CONFNAME="ardmake.conf"
for conf in "./$CONFNAME" "$HOME/.$CONFNAME"; do
    if [ -r "$conf" ]; then
        eval "$(awk -v FS== '{ sub(/^[ \t]*/, ""); sub(/^(set|export)[ ]*/, "");
                      if (/^A(RDUINO_|AVR)[A-Za-z0-9_]*=[^;<>`]*$/) {
                          print "[ -z \"$" $1 "\" ] && " $0
                      }
                      next }' "$conf")"
        #echo "Loaded configuration file \"$conf\"."
    fi
done

###################################################################################
# Defaults configuration:

# Path to avr tools (/usr/bin if installed from Linux distribution packages)
[ -z "$AVR_TOOLS_PATH" ] && AVR_TOOLS_PATH=/usr/bin

# Path to avrdude (/usr/bin if installed from Linux distribution packages)
[ -z "$AVRDUDE_PATH" ] && AVRDUDE_PATH=/usr/bin

# Path to search for additional Arduino libraries (separated by : colons).
# The "official" script directory at hardware/libraries is always searched!

if [ -z "$ARDUINO_LIBRARY_PATH" ]; then
    ARDUINO_LIBRARY_PATH="../libraries:$HOME/sketchbook/libraries"
fi

# Try to figure out Arduino install directory (first from environment
# variable ARDUINO_DIR, then ~/arduino, then opt/arduino)
if [ -n "$ARDUINO_DIR" ]; then
    INSTALL_DIR="$ARDUINO_DIR"
else
    INSTALL_DIR="$HOME/arduino"
    if [ ! -x "$INSTALL_DIR/arduino" -a -x '/opt/arduino/arduino' ]; then
        INSTALL_DIR='/opt/arduino'
    fi
fi

# Build locally unless a shared build is specifically requested:
if [ ! "$ARDUINO_BUILD" = "shared" ]; then
    BUILD_LOCALLY=1
else
    BUILD_LOCALLY=''
fi

# The extension for Arduino program files (.pde at the time of writing, but
# this is the same as for Processing - .ade would be more fitting)
EXT='pde'

# Command to reset serial port:
RESET_COMMAND="stty hupcl; sleep 0.1; true"

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

basename="$(basename "$0")"

# Check the configuration:

PROGRAMMERFILE="$INSTALL_DIR/hardware/programmers.txt"
BOARDFILE="$INSTALL_DIR/hardware/boards.txt"
if [ ! -r "$BOARDFILE" ]; then
    cat >&2 <<EOF
ERROR: Could not read "$BOARDFILE".

Please set ARDUINO_DIR correctly so that \$ARDUINO_DIR/hardware/boards.txt
is the location of the boards.txt in your Arduino installation.

You can configure ARDUINO_DIR either in the environment, or in the
configuration file ~/.$CONFNAME, e.g.:
    echo ARDUINO_DIR=$HOME/arduino-0017 >>~/.$CONFNAME

Run "$basename help" for instructions.
EOF
    exit 1
fi

[ ! -x "$AVRDUDE_PATH/avrdude" ] && AVRDUDE_PATH="$INSTALL_DIR/hardware/tools"
[ ! -x "$AVRDUDE_PATH/avrdude" ] && AVRDUDE_PATH="$(dirname $(which avrdude))"
if [ ! -x "$AVRDUDE_PATH/avrdude" ]; then
    cat >&2 <<EOF
ERROR: Could not find an executable avrdude!

Please set AVRDUDE_PATH correctly so that \$AVRDUDE_PATH/avrdude is
the correct avrdude executable. If you do not have avrdude installed,
see if it's available in your system packages, e.g. on Ubuntu Linux
you should be able to use:

    sudo apt-get install avrdude
EOF
    exit 1
fi

AVRDUDE_CONFIG="$AVRDUDE_PATH/avrdude.conf"
[ ! -e "$AVRDUDE_CONFIG" ] && AVRDUDE_CONFIG="/etc/avrdude.conf"
[ ! -e "$AVRDUDE_CONFIG" ] && AVRDUDE_CONFIG="$INSTALL_DIR/hardware/tools/avrdude.conf"

[ ! -x "$AVR_TOOLS_PATH/avr-gcc" ] && AVR_TOOLS_PATH="$INSTALL_DIR/hardware/tools"
[ ! -x "$AVR_TOOLS_PATH/AVR_TOOLS" ] && AVR_TOOLS_PATH="$(dirname $(which avr-gcc))"
if [ ! -x "$AVR_TOOLS_PATH/avr-gcc" ]; then
    cat >&2 <<EOF
ERROR: Could not find an executable avr-gcc!

Please set AVR_TOOLS_PATH correctly so that \$AVR_TOOLS_PATH/avr-gcc is
the correct avr-gcc executable. Other avr build tools (binutils, etc)
should be installed at the same location. If you do not have avr-gcc
installed, see if it's available in your system packages, e.g. on
Ubuntu Linux you should be able to use:

    sudo apt-get install gcc-avr
EOF
    exit 1
fi

# Usage:

if [ "$1" = 'help' -o "$1" = '--help' -o "$1" = '-h' ]; then
    cat | less <<EOF
Command-line Arduino programming helper (make and library handler),
copyright (c) 2009 Kimmo Kulovesi <http://arkku.com/>. This script
is provided as free software under GPL with ABSOLUTELY NO WARRANTY.

Usage: $basename [target] [options for Make]

This script provides a command-line build environment for Arduino,
by wrapping the call to Make and setting parameters for it over those
defined in the Arduino Makefile. Supported features include library
autodetection from #include-directives (just like the graphical IDE),
custom library paths, all board types (including custom ones), external
programming devices, downloading programs from the microcontroller, etc.


Setup and installation:
    1) Install Arduino, e.g.:
        wget http://arduino.googlecode.com/files/arduino-0017.tgz
        tar xvzf arduino-0017.tgz; ln -s arduino-0017 arduino
    2) Install avrdude and GCC for AVR, e.g. on Ubuntu & Debian:
        apt-get install avrdude gcc-avr
    3) Configure your Arduino installation directory, e.g.
        export ARDUINO_DIR=/path/to/arduino
    3) Configure your Arduino board, e.g.:
        export ARDUINO_BOARD=diecimila
    4) Configure your Arduino serial port device, e.g.:
        export ARDUINO_PORT=/dev/ttyUSB0

    The variable ARDUINO_BOARD must be set to the short name of the
    board you are using. To list available board types, use the
    command "$basename boards".

    By default, this script attempts to find an Arduino installation
    in ~/arduino and /opt/arduino. If it's neither of these, specify
    the variable ARDUINO_DIR accordingly.

    The serial device defaults to /dev/<corename> (e.g. /dev/arduino), 
    and to /dev/ttyUSB0 if that is not available. A specific port may
    be configured by setting the variable ARDUINO_PORT. Linux admins
    may wish to specify udev rules so that the port device is constant
    (e.g. /dev/arduino); for details on that, see the comments at the top
    of this script file, i.e. "$0".

Configuring variables:
    The configuration variables for this script (as detailed above)
    can be set in the file ~/.$CONFNAME, e.g.:
        echo ARDUINO_BOARD=atmega328 >~/.$CONFNAME

    To override all or part of this global configuration, a
    program-specific configuration file called $CONFNAME can be
    created inside each sketch directory, if desired. Any settings
    found in the sketch directory $CONFNAME take precedence over
    the settings in the user's ~/.$CONFNAME.

    You may also configure any or all of these variables in the
    environment. Variables configured in the environment take
    precedence over those in any configuration file! This allows
    you to specify variables directly on the command-line, e.g.:
        ARDUINO_DIR=~/arduino-0014 $basename

To create and upload an Arduino sketch:
    1) Create a directory for your program ("sketch"), e.g.
        mkdir -p ~/sketchbook/Blink
    2) Create your program .$EXT inside the directory, e.g.:
        cd ~/sketchbook/Blink; vim Blink.$EXT
    3) Compile your program by running this script:
        $basename
    4) After a succesful compilation, upload to your board:
        $basename upload

    Libraries are automatically detected from the #include-directives
    used. The libraries installed together with your Arduino are
    always available. Custom libraries are searched for in the
    directory ~/sketchbook/libraries and in ../libraries (i.e. in
    the directory libraries in the same directory as your sketch
    directory is in).

    The custom library locations can be overridden by specifying
    the variable ARDUINO_LIBRARY_PATH as a colon-separated list of
    directories, e.g.:
        ARDUINO_LIBRARY_PATH=$HOME/arduino_libs:/opt/arduino_libs


There are also other make targets that you may use instead of 
compile (the default) and upload. The target is specified as the first
command-line argument, and it can be any target in the Makefile. Special
targets handled by $basename are:

compile (default):  Compile the applet (.hex file) ready for uploading.
                    Do this first after making changes to your program!

upload:             Upload the applet to the microcontroller. See above
                    about the configuration variable ARDUINO_PORT. Usage:
                        $basename upload

                    To upload a pre-compiled file to the microcontroller,
                    you can specify a filename after upload on the
                    command line. The file must have the extension
                    .hex for Intel hex format, or the extension .bin
                    for raw binary format. For example:
                        $basename upload myprog.hex

isp:
dragon:             Just like "upload", but an AVRISP (or clone) or
                    an AVRDragon device is used to upload instead. These
                    can be used to upload to a stand-alone microcontroller
                    in ISP mode.
                    
                    The AVRDragon is an USB device and the port is
                    autodetected. For AVRISP and clones, the default
                    ports are /dev/avrisp and /dev/ttyUSB0, but the
                    port can be overridden by setting AVRISP_PORT.

programmer:         Like "isp" and "dragon", except the target must
                    be followed by the short name of a programmer
                    defined in hardware/programmers.txt. This allows
                    you to use any external programmer define there, e.g.:
                        $basename programmer parallel

download:           Download the microcontroller's flash memory to
                    the file specified as the next command line
                    parameter. The file name MUST have either the
                    extension .hex for Intel hex format, or the
                    extension .bin for raw binary format. For example:
                        $basename download backup.bin

                    External programmers can be used by specifying
                    "download" after the programmer, e.g.:
                        $basename isp download backup.hex

serial:             Start a serial monitor on the serial port. The port
                    device defaults to the programming port (ARDUINO_PORT),
                    but it can be specified on the command line. The
                    speed can often be autodetected from the program in
                    the current directory if it uses Serial.begin(speed),
                    but the speed defaults to 9600 and can be specified
                    on the command line. Examples:
                        $basename serial
                        $basename serial 19200
                        $basename serial /dev/ttyS0
                        $basename serial /dev/ttyUSB1 2400

boards:             List available board types.
programmers:        List available external programmer types.
coff:               Build an applet .cof file for debugging/etc.
lss:                Build an applet .lss file to show annotated assembler. 


    Targets for burning a bootloader (requires a programming device!):

bootloader:         Program the fuses and burn a bootloader. The
                    filenames and settings are obtained from the
                    file ARDUINO_DIR/harware/boards.txt according
                    to the board type (ARDUINO_BOARD).

                    The bootloader can only be burned with an external
                    programmer. If the settings in boards.txt are not
                    applicable to your programmer device (as is
                    probably the case), you can specify the external
                    programmer at the end of the command line.

                    For example, to burn the ADABoot bootloader for
                    ATMega168 using an AVRISP device, you would set
                    ARDUINO_BOARD="ADABoot168" and then run:
                        $basename bootloader isp

                    You can also follow the bootloader target with
                    a .bin or .hex filename to burn a custom
                    bootloader without entering it into boards.txt, e.g.:
                        $basename bootloader boot.hex programmer parallel

fuses:              Just program the fuses and set the lock bits
                    to unlock.  For example:
                        $basename fuses isp

EOF
    exit 0
fi

# Display list of available board types if requested:

if [ "$1" = "boards" -o "$1" = "programmers" ]; then
    if [ "$1" = "boards" ]; then
        file="$BOARDFILE"
    else
        file="$PROGRAMMERFILE"
    fi
    echo "Available $1 in $file:"
    awk -v FS== '$1 ~ /\.name/ {
        sub(/\.name$/, "", $1)
        printf("\t%-15s\t\"%s\"\n", $1, $2);
    }' "$file"
    if [ "$1" = "boards" ]; then
        cat <<EOF

To configure your board type, set the variable ARDUINO_BOARD
either in the environment or in ~/.$CONFNAME, or in the
file $CONFNAME inside your program's directory.
EOF
    else
        cat <<EOF

To use an external programming device for uploading, you can use
the target "programmer" followed by the device name (as listed above)
instead of "upload", e.g.
    $basename programmer parallel

Also note that $basename has two built-in programming device types:
1) AVRDragon in ISP mode, which can be invoked as:
    $basename dragon

2) AVRISP and clones (the most common third-party device sold online):
    $basename isp

The AVRDragon device requires no port configuration, nor do many of
the programmers typically defined in hardware/programmers.txt. The
serial port for the built-in AVRISP can be defined as AVRISP_PORT,
while others use ARDUINO_PORT (and default to the /dev/<programmer_name>
or /dev/ttyUSB0 if that is not available).
EOF
    fi
    exit 0
fi

# Die if no board type is set:

if [ -z "$ARDUINO_BOARD" ]; then
    cat <<EOF >&2
ERROR: The variable ARDUINO_BOARD must be set to the type of Arduino
board you are using. Accepted values are those appearing in Arduino's
hardware/boards.txt, e.g. "diecimila", "mega", "lilypad", etc.
The names are case-sensitive.

To save a certain board type as your default, put the setting
in ~/.$CONFNAME, e.g.:
    echo ARDUINO_BOARD=diecimila >>~/.$CONFNAME

To configure a project-specific board type, put the setting
in the file $CONFNAME in the sketch directory, e.g.:
    cd ~/sketchbook/MyProg
    echo ARDUINO_BOARD=mega >>$CONFNAME

Run "$basename help" for instructions.
EOF
    exit 1
fi

# Try to read the hardware configuration for this board:

eval $(awk -v FS== -v board="$ARDUINO_BOARD" '$1 ~ /\.name$/ {
                                if (boardname) { exit 0 }
                                sub(/\.name$/, "", $1)
                                if (board == $1 || board == $2) {
                                    boardname = $2
                                    speed=0; core=""; mcu=""; protocol="";
                                    f_cpu=0; lfuse=""; hfuse=""; efuse="";
                                    unlock_bits=""; lock_bits="";
                                    bootloader_dir=""; bootlader_file="";
                                }
                                next
                            }
                            !boardname { next }
                            $1 ~ /\.upload\.protocol$/ { protocol = $2; next }
                            $1 ~ /\.upload\.speed$/ { speed = $2; next }
                            $1 ~ /\.upload\.maximum_size$/ {
                                max_size = $2; next
                            }
                            $1 ~ /\.build\.core$/ { core = $2; next }
                            $1 ~ /\.build\.f_cpu$/ { f_cpu = $2; next }
                            $1 ~ /\.build\.mcu$/ { mcu = $2; next }
                            $1 ~ /\.bootloader\.low_fuses$/ {
                                lfuse = $2; next
                            }
                            $1 ~ /\.bootloader\.high_fuses$/ {
                                hfuse = $2; next
                            }
                            $1 ~ /\.bootloader\.extended_fuses$/ {
                                efuse = $2; next
                            }
                            $1 ~ /\.bootloader\.unlock_bits$/ {
                                unlock_bits = $2; next
                            }
                            $1 ~ /\.bootloader\.lock_bits$/ {
                                lock_bits = $2; next
                            }
                            $1 ~ /\.bootloader\.path$/ {
                                bootloader_dir = $2; next
                            }
                            $1 ~ /\.bootloader\.file$/ {
                                bootloader_file = $2; next
                            }
                            END {
                                if (boardname) {
                                    print "BOARDNAME=\"" boardname "\""
                                    if (speed) {
                                        gsub(/[^0-9]/, "", speed)
                                        print "UPLOAD_RATE=\"" speed "\""
                                    }
                                    if (f_cpu) {
                                        gsub(/[^0-9]/, "", f_cpu)
                                        print "F_CPU=\"" f_cpu "\""
                                    }
                                    if (core) {
                                        gsub(/[^a-zA-Z0-9_.:-]/, "", core)
                                        print "CORE=\"" core "\""
                                    }
                                    if (mcu) {
                                        gsub(/[^a-zA-Z0-9_.:-]/, "", mcu)
                                        print "MCU=\"" mcu "\""
                                    }
                                    if (protocol) {
                                        gsub(/[^a-zA-Z0-9_.:-]/, "", protocol)
                                        print "AVRDUDE_PROGRAMMER=\"" \
                                            protocol "\""
                                    }
                                    if (max_size) {
                                        gsub(/[^0-9]/, "", max_size)
                                        print "MAX_SIZE=\"" max_size "\""
                                    }
                                    if (hfuse != "") {
                                        gsub(/[^0-9xA-Fa-f]/, "", hfuse)
                                        print "BL_HFUSE=\"" hfuse "\""
                                    }
                                    if (lfuse != "") {
                                        gsub(/[^0-9xA-Fa-f]/, "", lfuse)
                                        print "BL_LFUSE=\"" lfuse "\""
                                    }
                                    if (efuse != "") {
                                        gsub(/[^0-9xA-Fa-f]/, "", efuse)
                                        print "BL_EFUSE=\"" efuse "\""
                                    }
                                    if (lock_bits != "") {
                                        gsub(/[^0-9xA-Fa-f]/, "", lock_bits)
                                        print "BL_LOCK=\"" lock_bits "\""
                                    }
                                    if (unlock_bits != "") {
                                        gsub(/[^0-9xA-Fa-f]/, "", unlock_bits)
                                        print "BL_UNLOCK=\"" unlock_bits "\""
                                    }
                                    if (bootloader_dir && bootloader_file) {
                                        gsub(/["]/, "\\\"", bootloader_dir)
                                        gsub(/["]/, "\\\"", bootloader_file)
                                        print "BL_PATH=\"" bootloader_dir "/" \
                                                           bootloader_file "\""
                                    }
                                }
                            }' "$BOARDFILE")

# Die if the board configuration was not found:

if [ -z "$F_CPU" ]; then
    cat <<EOF >&2
ERROR: The board "$ARDUINO_BOARD" was not found in the configuration
file "$BOARDFILE". The variable ARDUINO_BOARD
must be set to the (case-sensitive) short name of the board,
e.g. "diecimila" or "atmega328".

Run "$basename boards" to list known board types, or
"$basename help" for general instructions.
EOF
    exit 1
fi

# Some defaults for board types, e.g. if the user has placed a custom
# board in boards.txt and didn't define everything:

[ -z "$CORE" ] && CORE=arduino
[ -z "$MAX_SIZE" ] && MAX_SIZE=14336
[ -z "$MCU" ] && MCU="$ARDUINO_BOARD"
[ -z "$AVRDUDE_PROGRAMMER" ] && AVRDUDE_PROGRAMMER=stk500v1
[ -z "$UPLOAD_RATE" ] && UPLOAD_RATE=19200
UPLOAD_DELAY=""

# Set some helper variables based on the Arduino location:

MAKEFILE="$INSTALL_DIR/hardware/cores/$CORE/Makefile"
[ ! -e "$MAKEFILE" ] && MAKEFILE="$INSTALL_DIR/hardware/cores/arduino/Makefile"
ARDUINO="$INSTALL_DIR/hardware/cores/$CORE"
LIBRARY_DIR="$INSTALL_DIR/hardware/libraries"

# Check for the wiring_serial.c bug in some versions of Arduino:

if grep -q -s -F 'wiring_serial.c' "$MAKEFILE"; then
    if [ ! -e "$ARDUINO/wiring_serial.c" ]; then
        echo '/* Empty file created due to bug in Arduino Makefile */' \
            >"$ARDUINO/wiring_serial.c"
        if [ ! -e "$ARDUINO/wiring_serial.c" ]; then
            cat <<EOF >&2

WARNING: The file "$ARDUINO/wiring_serial.c" is referred to in
the Makefile, but it does not exist. This is a bug in some Arduino
versions, and will probably lead to failed builds. To remedy, please
create the file (it can be empty) or remove the reference from the
Makefile ("$MAKEFILE").

EOF
        fi
    fi
fi

# Correct the programmer "stk500" specified for pretty much every
# Arduino board to "stk500v1" (which is the correct, more specific
# option for avrdude):
[ "$AVRDUDE_PROGRAMMER" = "stk500" ] && AVRDUDE_PROGRAMMER='stk500v1'

# Configure the programmer port location:

if [ -n "$ARDUINO_PORT" ]; then
    PORT="$ARDUINO_PORT"
else
    PORT="/dev/$CORE"
    if [ ! -e "$PORT" ]; then
        PORT="/dev/$ARDUINO_BOARD"
        if [ ! -e "$PORT" ]; then
            PORT='/dev/avr'
            [ ! -e "$PORT" ] && PORT='/dev/ttyUSB0'
        fi
    fi
fi

# Serial monitor:

if [ "$1" = "serial" ]; then
    shift
    if [ -c "$1" ]; then
        PORT="$1"
        shift
    fi
    if [ ! -e "$PORT" ]; then
        cat >&2 <<EOF
ERROR: Serial port device "$PORT" not found.

You can either specify the port as the variable ARDUINO_PORT, or give an
alternative port on the command line, e.g.:
    $basename serial /dev/ttyUSB1

The speed of the serial port is normally autodetected from typical
programs using the Arduino Serial library, but it can be specified
on the command line, e.g. for 9600 bps:
    $basename serial /dev/ttyUSB0 9600
EOF
        exit 1
    fi
    TARGET="$(basename "$(pwd)").$EXT"
    if [ -n "$1" ]; then
        SPEED="$1"
    elif [ -r "$TARGET" ]; then
        SPEED=$(awk -v baud="${ARDUINO_BAUD:-9600}" '/Serial[0-9]*\.begin/ {
                        sub(/^.*Serial[^0-9]*/, "");
                        sub(/[^0-9].*$/, "");
                        if ($0 != "" && $0 > 0) { baud = $0; exit }
                     }
                     END { print baud }' "$TARGET")
    else
        SPEED="${ARDUINO_BAUD:-9600}"
    fi
    if tty >/dev/null 2>&1; then
        cat >&2 <<EOF
Starting serial monitor on port $PORT at $SPEED bps.
Your input will be sent to the serial port. Press Ctrl-C to stop.

EOF
    fi
    stty -F "$PORT" ospeed "$SPEED" ispeed "$SPEED" \
         cs8 ignbrk -ignpar -cstopb -hupcl -echo \
         -ixon -crtscts -imaxbel
    cat <"$PORT" &
    catpid=$!
    trap '[ -n "$catpid" ] && kill $catpid; catpid=""' EXIT INT QUIT TERM
    if [ -e "$PORT" ]; then
        cat >"$PORT"
        exit $?
    else
        echo "Error: Serial device \"$PORT\" does not exist!" >&2
        exit 1
    fi
fi

# Display verification that the correct board was selected:

cat <<EOF
Read settings for ARDUINO_BOARD="$ARDUINO_BOARD":
    $BOARDNAME

EOF

# Configure AVRDUDE here, since the Makefile included with Arduino
# has non-working paths hard-coded:

AVRDUDE_MCU=$(echo "$MCU" | awk '
    $1 ~ /^atmega/ { sub(/^atmega/, "m", $1); print $1; exit }
    $1 ~ /^attiny/ { sub(/^attiny/, "t", $1); print $1; exit }
    $1 ~ /^at90s/ { sub(/^at90s/, "t", $1); print $1; exit }
    $1 ~ /^at90pwm/ { sub(/^at90/, "t", $1); print $1; exit }')

AVRDUDE_FLAGS="-F -D -p $AVRDUDE_MCU -v -v"

# Allow targets "bootloader" and "fuses" for burning the bootloader
# or setting the fuses, respectively, e.g. for preparing a DIY
# Arduino clone with a blank ATMega device.

burn_bootloader=''
program_fuses=''
if [ "$1" = "bootloader" -o "$1" = "fuses" ]; then
    program_fuses='yes'
    [ "$1" = "bootloader" ] && burn_bootloader='yes'
    shift
    [ ! -x "$AVRDUDE_PATH/avrdude" ] && AVRDUDE_PATH=''

    if [ -z "$BL_HFUSE" -o -z "$BL_LFUSE" -o -z "$BL_EFUSE" -o \
         -z "$BL_UNLOCK" -o -z "$BL_PATH" ]
    then
        cat >&2 <<EOF
ERROR: boards.txt did not define the information necessary for burning
a bootloader and/or setting the fuses. You must ensure that the file
$INSTALL_DIR/hardware/boards.txt is available and contains the following
settings for your board type (currently "$ARDUINO_BOARD"):

$ARDUINO_BOARD.bootloader.low_fuses=0x??
$ARDUINO_BOARD.bootloader.high_fuses=0x??
$ARDUINO_BOARD.bootloader.extended_fuses=0x??
$ARDUINO_BOARD.bootloader.unlock_bits=0x??
$ARDUINO_BOARD.bootloader.lock_bits=0x??
$ARDUINO_BOARD.bootloader.file=filename.hex
$ARDUINO_BOARD.bootloader.path=dirname

Aborting...
EOF
        exit 1
    fi
    BOOTLOADER_FILE="$INSTALL_DIR/hardware/bootloaders/$BL_PATH"
    if [ -n "$1" -a -r "$1" ] && echo "$1" | grep -E -q -s '\.(hex|bin)$' ; then
        BOOTLOADER_FILE="$1"
        shift
    elif [ ! -r "$BOOTLOADER_FILE" ]; then
        echo "ERROR: Bootloader file "$BOOTLOADER_FILE" is not readable!" >&2
        exit 1
    fi
    cat <<EOF
This command will set the following:

EOF
    [ -n "$burn_bootloader" ] && echo "Bootloader: $BOOTLOADER_FILE"
    cat <<EOF
Fuses: high=$BL_HFUSE low=$BL_LFUSE extended=$BL_EFUSE

    WARNING!

Burning a bootloader and/or setting the fuse bits is potentially
dangerous and incorrect settings can make your device stop working!
Note that an external programmer is required for this operation,
i.e. you can't burn the bootloader via Arduino's own USB.

Press Return to continue (at your own risk), or Ctrl-C to cancel!

EOF
    read press_enter >/dev/null 2>&1
fi

# Change the target "dragon" to "upload", but perform the upload using
# the AVRDragon in ISP mode instead of the instead of the typical Arduino
# programming method (e.g. for DIY projects using the same microprocessor
# as an Arduino but not having the programming capability themselves).
#
# Similarly change the target "isp" to "upload", but perform the upload
# using an AVRISP (or clone thereof).

if [ -n "$1" ]; then
    if [ "$1" = "dragon" ]; then
        # Uploading with the AVR Dragon:

        AVRDUDE_PROGRAMMER='dragon_isp'
        PORT='usb'
        UPLOAD_RATE=''
        target='upload'
        if [ "$2" = "download" ]; then target="$2"; shift; fi
    elif [ "$1" = "isp" ]; then
        # Uploading via AVRISP with the stk500v2 protocol:
        if [ -n "$AVRISP_PORT" ]; then
            PORT="$AVRISP_PORT"
        elif [ -e '/dev/avrisp' ]; then
            PORT='/dev/avrisp'
        else
            PORT='/dev/ttyUSB0'
        fi
        AVRDUDE_PROGRAMMER='stk500v2'
        UPLOAD_RATE="$AVRISP_BAUD"
        target='upload'
        if [ "$2" = "download" ]; then target="$2"; shift; fi
    elif [ "$1" = "programmer" ]; then
        shift
        AVRDUDE_PROGRAMMER="$1"

        if [ -z "$AVRDUDE_PROGRAMMER" ]; then
            echo "ERROR: No programming device specified on the command-line!" >&2
            exit 1
        fi
        if [ ! -r "$PROGRAMMERFILE" ]; then
            echo "ERROR: Could not read \"$PROGRAMMERFILE\"!" >&2
            exit 1
        fi

        # Read custom configuration for an external programming device:

        eval $(awk -v FS== -v prog="$AVRDUDE_PROGRAMMER" '$1 ~ /\.name$/ {
                        if (progname) { exit 0 }
                        sub(/\.name$/, "", $1)
                        if (prog == $1 || prog == $2) {
                            progname = $2; communication="";
                            protocol=""; delay=""; port="";
                        }
                        next
                    }
                    !progname { next }
                    $1 ~ /\.communication$/ { communication = $2; next }
                    $1 ~ /\.protocol$/ { protocol = $2; next }
                    $1 ~ /\.delay$/ { delay = $2; next }
                    END {
                        if (progname) {
                            print "AVRDUDE_PROGRAMMER_NAME=\"" progname "\""
                            gsub(/[^a-zA-Z0-9_.:-]/, "", communication)
                            print "AVR_COMMUNICATION=\"" communication "\""
                            gsub(/[^0-9]/, "", delay)
                            print "UPLOAD_DELAY=\"" delay "\""
                            if (protocol) {
                                gsub(/[^a-zA-Z0-9_.:-]/, "", protocol)
                                print "AVRDUDE_PROGRAMMER=\"" protocol "\""
                            }
                        }
                    }' "$PROGRAMMERFILE")

        # Die if the specified programmer was not found in programmers.txt:
        if [ -z "$AVRDUDE_PROGRAMMER_NAME" ]; then
            cat >&2 <<EOF
ERROR: "$AVRDUDE_PROGRAMMER" not found in "$PROGRAMMERFILE". You can
view a list of the available programmer types with the command:
    $basename programmers
EOF
            exit 1
        fi

        # Set up the ports according to means of communication:
        if [ "$AVR_COMMUNICATION" = 'usb' ]; then
            PORT='usb'
            UPLOAD_RATE=''
        else
            if [ "$AVR_COMMUNICATION" = 'serial' ]; then
                if [ ! "$PORT" = "$ARDUINO_PORT" -o ! -e "$PORT" ]; then
                    if [ -e "/dev/$AVRDUDE_PROGRAMMER" ]; then
                        PORT="/dev/$AVRDUDE_PROGRAMMER"
                    elif [ ! -e "$PORT" ]; then
                        PORT='/dev/ttyUSB0'
                    fi
                fi
                UPLOAD_RATE="$AVRISP_BAUD"
            else
                # DEBUG: Specifying port for parallel programmers?
                PORT=''
                UPLOAD_RATE=''
            fi
        fi

        target='upload'
        if [ "$2" = "download" ]; then target="$2"; shift; fi
        echo "    Programming device..... $AVRDUDE_PROGRAMMER_NAME"
    elif [ '(' "$1" = "upload" -o "$1" = "download" ')' \
           -a "$AVRDUDE_PROGRAMMER" = "stk500v1" ]
    then
        if "$AVRDUDE_PATH/avrdude" ${AVRDUDE_CONFIG:+-C "$AVRDUDE_CONFIG"} \
            -c list_all 2>&1 | grep -q -s '^ *arduino *= .*conf'; then
            # Use the "arduino" programmer with autoreset built in,
            # if it's available in the avrdude version we are using.
            AVRDUDE_PROGRAMMER='arduino'
            target="$1"
        else
            target="$1_autoreset"
        fi
    else
        target="$1"
    fi
    shift
else
    target='compile'
fi
AVRDUDE_FLAGS="$AVRDUDE_FLAGS${PORT:+ -P $PORT} -c $AVRDUDE_PROGRAMMER${UPLOAD_RATE:+ -b $UPLOAD_RATE}${UPLOAD_DELAY:+ -i $UPLOAD_DELAY}"

# Show the configuration:

cat <<EOF
    Core................... $CORE
    Core directory......... $ARDUINO
    Microcontroller........ $MCU ($AVRDUDE_MCU)
    Clock frequency........ $(echo "$F_CPU" | sed 's/UL$//') Hz
    Programming protocol... $AVRDUDE_PROGRAMMER
    Port................... ${PORT:-(unspecified)}
    Maximum upload size.... ${MAX_SIZE:-?} bytes

EOF

# Program the fuses (usually as the first step for burning a bootloader):

if [ -n "$program_fuses" ]; then
    "$AVRDUDE_PATH/avrdude" ${AVRDUDE_CONFIG:+-C "$AVRDUDE_CONFIG"} \
        $AVRDUDE_FLAGS -e -U "lock:w:$BL_UNLOCK:m" \
        -U "efuse:w:$BL_EFUSE:m" -U "hfuse:w:$BL_HFUSE:m" \
        -U "lfuse:w:$BL_LFUSE:m" || exit 1
    cat <<EOF

Programmed fuses: high=$BL_HFUSE low=$BL_LFUSE extended=$BL_EFUSE
Setting lock bits to unlock: $BL_UNLOCK
EOF
fi

# Burn the bootloader:

if [ -n "$burn_bootloader" ]; then
cat <<EOF

Burning bootloader: $BOOTLOADER_FILE

EOF
    sleep 5
    exec "$AVRDUDE_PATH/avrdude" ${AVRDUDE_CONFIG:+-C "$AVRDUDE_CONFIG"} \
          $AVRDUDE_FLAGS -e -U "flash:w:$BOOTLOADER_FILE:a" -U "lock:w:$BL_LOCK:m"
elif [ -n "$program_fuses" ]; then
    exit 0
fi

# Upload custom file (.hex or .bin) with compiling:

if [ '(' "$target" = "upload" -o "$target" = "upload_autoreset" ')' \
     -a -r "$1" ] && echo "$1" | grep -E -q -s '\.(hex|bin)$' ; then
    echo "Uploading file '$1' to microcontroller..."
    if [ "$target" = "upload_autoreset" ]; then
        ( eval "$RESET_COMMAND" ) <"$PORT" 2>/dev/null
    fi
    exec "$AVRDUDE_PATH/avrdude" ${AVRDUDE_CONFIG:+-C "$AVRDUDE_CONFIG"} \
          $AVRDUDE_FLAGS -U "flash:w:$1:a"
fi

# Download flash to file (.hex or .bin, Intel Hex or raw binary format):

if [ '(' "$target" = "download" -o "$target" = "download_autoreset" ')' \
    -a -n "$1" ] && \
    echo "$1" | grep -E -q -s '\.(hex|bin)$' ; then
    echo "Downloading flash memory to file '$1'..."
    if [ "$target" = "download_autoreset" ]; then
        ( eval "$RESET_COMMAND" ) <"$PORT" 2>/dev/null
    fi
    exec "$AVRDUDE_PATH/avrdude" ${AVRDUDE_CONFIG:+-C "$AVRDUDE_CONFIG"} \
          $AVRDUDE_FLAGS \
          -U "flash:r:$1:$(echo "$1" | sed 's/^.*hex$/i/; s/^.*bin$/r/')"
fi

# Escape AVRDUDE_CONFIG path for the Makefile:

[ -n "$AVRDUDE_CONFIG" ] && AVRDUDE_FLAGS="-C \"$AVRDUDE_CONFIG\" $AVRDUDE_FLAGS"

# Try to discover the program name:

TARGET=$(basename "$(pwd)")
for f in *.$EXT; do
    TARGET=$(echo "$f" | sed "s/\.$EXT$//")
    break
done
if [ ! -e "./$TARGET.$EXT" ]; then
    cat >&2 <<EOF
ERROR: No sketch found! To create a program, make a directory with the
program name, e.g. MyProg, and write the program code inside that
directory in a file with the same name but with the extension ".$EXT".
For example:
    mkdir MyProg; cd MyProg; vim MyProg.$EXT
    $basename

Run "$basename help" for instructions!
EOF
    exit 1
fi

# Figure out what libraries are being used:

LIBRARIES_DIR="\$(INSTALL_DIR)/hardware/libraries"
LIBSRC=''
LIBASRC=''
LIBCXXSRC=''
CINCS=''
CXXINCS='$(CINCS)'
LIBCHECK_FILES=' '

ARDUINO_LIBRARY_PATH=$(echo "$ARDUINO_LIBRARY_PATH" | \
                       sed 's/ /\\ /g; s/[^+-9:=@A-Z_a-z!]//g; s/:/ /g')

echo 'Looking for libraries in these directories:'
for libpath in $ARDUINO_LIBRARY_PATH "$LIBRARY_DIR"; do
    echo "    $libpath/"
done
echo

# Check an included header for matching .c, .cpp and/or .S files
# (simply by filename) and add any of those to the sources.

check_header () {
    local libname="$1"
    local base="$2"
    local inlib="$3"
    local pfx="$base/$libname"
    [ ! -e "$pfx.h" ] && return 1

    check_for_libraries "$pfx.h"

    local makepfx="$pfx"
    if [ "$base" = "$ARDUINO" ]; then
        # Beautify the Arduino directory path
        makepfx="\$(ARDUINO)/$libname"
    elif [ -n "$inlib" ]; then
        # Beautify the Arduino library directory path
        if echo "$base" | grep -q -s -F "$LIBRARY_DIR/$inlib/utility"
        then
            makepfx="\$(LIBRARIES_DIR)/$inlib/utility/$libname"
        elif echo "$base" | grep -q -s -F "$LIBRARY_DIR/$inlib"
        then
            makepfx="\$(LIBRARIES_DIR)/$inlib/$libname"
        fi
    fi

    if [ -e "$pfx.c" ]; then
        check_for_libraries "$pfx.c" "$inlib" && \
            LIBSRC="$LIBSRC $makepfx.c"
    fi
    if [ -e "$pfx.cpp" ]; then
        check_for_libraries "$pfx.cpp" "$inlib" && \
            LIBCXXSRC="$LIBCXXSRC $makepfx.cpp"
    fi
    [ -e "$pfx.S" ] && LIBASRC="$LIBASRC $makepfx.S"

    return 0
}

# Check a file for new libraries we need to include. This is done simply
# by locating the #include-lines in the C/C++ sources. Obviously no
# pre-processor conditionals or such are supported, but for simple purposes
# this seems to work reasonably well. (All examples included with Arduino
# version 013 compile correctly.)

check_for_libraries () {
    [ ! -r "$1" ] && return 1
    if echo "$LIBCHECK_FILES" | grep -q -s -F " |$1| "; then
        return 1
    fi
    LIBCHECK_FILES="${LIBCHECK_FILES}|$1| "
    local basedir=$(dirname "$1")
    local inlib="$2"

    # Note: Print.cpp is a standard dependency for Arduino programs, but
    # the dependency was not included in the official Makefile up to and
    # including version 0014. If this script is used with old versions of
    # Arduino, compilation may fail due to missing Print.cpp. The suggested
    # solution is to update Arduino, but if that is not possible you can
    # add "Print" after the closing ")" on the line before "do":

    for lib in $(awk -F '[<>"]' '/^[ ]*#include [<"]/ { sub(/\.h[p]*$/, "", $2);
                                    gsub(/[^a-zA-Z0-9_.:/-]/, "", $2);
                                    print $2; next }' "$1" 2>/dev/null)
    do
        local found=''
        local libpath=''
        local libname="$lib"
        local header="$ARDUINO/$libname.h"
        local base=''

        for libpath in $ARDUINO_LIBRARY_PATH "$LIBRARY_DIR"; do
            local libdir="$libpath/$libname"

            if [ -e "$libdir" ]; then
                if check_for_libraries "$libdir/$libname.h" "$libname"; then
                    if [ "$libpath" = "$LIBRARY_DIR" ]; then
                        echo "Including Arduino library: $libname"
                        CINCS="$CINCS -I\$(LIBRARIES_DIR)/$libname"
                        [ -e "$libdir/utility" ] && \
                            CINCS="$CINCS -I\$(LIBRARIES_DIR)/$libname/utility"
                    else
                        echo "Including local library: $libname"
                        CINCS="$CINCS -I$libdir"
                        [ -e "$libdir/utility" ] && \
                            CINCS="$CINCS -I$libdir/utility"
                    fi
                fi
                check_header "$libname" "$libdir" "$libname"
                found=1
                break
            fi
        done

        if [ -z "$found" ]; then
            for base in "$ARDUINO" "$basedir" "$basedir/utility"; do
                check_header "$libname" "$base" "$inlib" && break
            done
        fi
    done
    return 0
}

check_for_libraries "$TARGET.$EXT"

# Ensure the applet directory exists:

 [ ! -d applet ] && mkdir applet

if [ -e 'applet/board' -a ! "$BOARDFILE" -nt "applet/board" ]; then
    configured_board="$(head -n 1 'applet/board')"
else
    configured_board=''
fi
[ ! "$configured_board" = "$ARDUINO_BOARD" ] && echo "$ARDUINO_BOARD" >'applet/board'

# Display library settings to the user:

old_CINCS="$CINCS"
CINCS="-I. -I./utility -I\$(ARDUINO)$CINCS"
if [ -n "$old_CINCS" ]; then
    echo
    echo "Includes = $CINCS"
    #[ -n "$LIBSRC" ] && echo "LIBSRC =$LIBSRC"
    #[ -n "$LIBASRC" ] && echo "LIBASRC =$LIBASRC"
    #[ -n "$LIBCXXSRC" ] && echo "LIBCXXSRC =$LIBCXXSRC"
    echo
fi
unset old_CINCS

# Set the compiler options to better match the IDE:

CTUNING='-ffunction-sections -fdata-sections -fshort-enums'
CFLAGS='$(CDEFS) $(CINCS) -O$(OPT) $(CWARN) $(CTUNING) $(CEXTRA) $(CDEBUG)'
CXXFLAGS='$(CDEFS) $(CINCS) -O$(OPT) -fno-exceptions $(CTUNING)'

# Create the Makefile:

if [ ! -e 'applet/Makefile' -o 'applet/board' -nt 'applet/Makefile' \
     -o "$0" -nt 'applet/Makefile' ]; then
    # Change the Make default target to our own:
    echo 'compile: do_compile' >applet/Makefile

    # Take the original Makefile, but remove the built-in dependency
    # includes (so we can override them) and the original .elf target
    # which we are replacing below:
    sed '/^include $[(][^)]*\.d[)]/ d;
         /^applet\/$[(]TARGET[)]\.elf: / d;
         /^[ \t]*#/ d;
         s/\.pde/\.$(EXT)/g' "$MAKEFILE" >>applet/Makefile

    # Now the dirty parts, featuring some rather explicit Make:
    echo -e 'do_compile: do_build show_size
do_build: applet/$(TARGET).hex
applet/$(TARGET).hex: applet/$(TARGET).elf

ARDMAKE_BOARD=applet/board

applet/$(TARGET).elf: applet/$(TARGET).cpp applet/core.a
\t$(CXX) $(ALL_CXXFLAGS) -Wl,--gc-sections $(LDFLAGS) -L. -Lapplet/ -o $@ $< applet/core.a
\t@chmod a-x $@ >/dev/null 2>&1 || true

applet/$(TARGET).cpp: $(TARGET).$(EXT) $(ARDUINO)/main.cxx $(ARDUINO)/WProgram.h $(ARDMAKE_BOARD)
\techo '\''#include "WProgram.h"'\'' >$@
\t@echo '\''#line 1 "$<"'\'' >>$@
\tcat $(TARGET).$(EXT) >>$@
\t@echo '\''#line 1 "$(ARDUINO)/main.cxx"'\'' >>$@
\tcat $(ARDUINO)/main.cxx >>$@

show_size:
\t@echo
\t@echo Program size:
\t@$(HEXSIZE) | awk -v m="$(MAX_SIZE)" '\''{print;if(NR^1){s=$$4}} \\
    END {printf("\\n%d/%d bytes (%.1f%% of capacity, %d bytes left)\\n\\n",\\
    s,m,s*100.0/m,m-s);}'\''

upload_autoreset: do_autoreset upload unreset

do_autoreset:
\t@echo Sending reset to prepare for upload...
\t( '"$RESET_COMMAND"' ) <$(PORT) 2>/dev/null
\t@echo

unreset:
\t@stty -hupcl <$(PORT) 2>/dev/null || true

$(OBJ): $(ARDMAKE_BOARD)
$(DEPS): $(ARDMAKE_BOARD)

$(APPC): applet/%.o: %.c
\t$(CC) -c $(ALL_CFLAGS) -o $@ $<

$(APPCXX): applet/%.o: %.cpp
\t$(CXX) -c $(ALL_CXXFLAGS) -o $@ $<

$(APPA): applet/%.o: %.S
\t$(CC) -c $(ALL_ASFLAGS) -o $@ $<

$(APPC:.o=.d): applet/%.d: %.c
\t$(CC) -M $(ALL_CFLAGS) $< | sed '\''s;^[^:]*:;applet/$*.o applet/$*.d:;'\'' >$@

$(APPCXX:.o=.d): applet/%.d: %.cpp
\t$(CXX) -M $(ALL_CXXFLAGS) $< | sed '\''s;^[^:]*:;applet/$*.o applet/$*.d:;'\'' >$@

$(APPA:.o=.d): applet/%.d: %.S
\t$(CC) -M $(ALL_ASFLAGS) $< | sed '\''s;^[^:]*:;applet/$*.o applet/$*.d:;'\'' >$@

applet/$(TARGET).d: applet/$(TARGET).cpp

vpath %.c applet/ $(sort $(dir $(OBJC)))
vpath %.cpp applet/ $(sort $(dir $(OBJCXX)))
vpath %.S applet/ $(sort $(dir $(OBJA)))

include $(DEPS)' >>applet/Makefile

    # Ensure applet/core.a gets re-built every time, because otherwise
    # we won't get the correct dependencies:
    if [ -z "$target" -o "$target" = "compile" -o "$target" = "all" ]; then
        if [ -w "applet/core.a" ]; then
            echo "rm -f applet/core.a"
            rm -f "applet/core.a"
        fi
    fi
fi

# Don't do autoreset if we don't have a serial port:

[ "$target" = "upload_autoreset" -a ! -c "$PORT" ] && target=upload

# Substitute the Makefile "clean" target:

if [ "$target" = "clean" ]; then
    echo "Cleaning up..."
    for ext in d o cpp h elf hex a s S lss cof; do
        rm -f applet/*.$ext 2>/dev/null
    done
    rm -f applet/Makefile applet/board 2>/dev/null
    # If we are building locally, do not try to clean inside Arduino dir:
    [ -n "$BUILD_LOCALLY" ] && exit 0
fi

# Finally, execute Make:

exec make -f applet/Makefile \
    MAKEFILE='applet/Makefile' LIBRARIES_DIR="$LIBRARIES_DIR" \
    AVRDUDE_FLAGS="$AVRDUDE_FLAGS" AVRDUDE_PROGRAMMER="$AVRDUDE_PROGRAMMER" \
    TARGET="$TARGET" PORT="$PORT" MCU="$MCU" F_CPU="$F_CPU" MAX_SIZE="$MAX_SIZE" \
    AVR_TOOLS_PATH="$AVR_TOOLS_PATH" INSTALL_DIR="$INSTALL_DIR" EXT="$EXT" \
    AVRDUDE_PATH="$AVRDUDE_PATH" UPLOAD_RATE="$UPLOAD_RATE" ARDUINO="$ARDUINO" \
    LIBSRC="$LIBSRC" LIBASRC="$LIBASRC" LIBCXXSRC="$LIBCXXSRC" \
    CINCS="$CINCS" CXXINCS="$CXXINCS" AVRDUDE='$(AVRDUDE_PATH)/avrdude' \
    CTUNING="$CTUNING" CFLAGS="$CFLAGS" CXXFLAGS="$CXXFLAGS" \
    OBJC='$(sort $(SRC:.c=.o) $(abspath $(LIBSRC:.c=.o)))' \
    OBJCXX='$(sort $(CXXSRC:.cpp=.o) $(abspath $(LIBCXXSRC:.cpp=.o)))' \
    OBJA='$(sort $(ASRC:.S=.o) $(abspath $(LIBASRC:.S=.o)))' \
    OBJARDUINODIR='$(OBJC) $(OBJCXX) $(OBJA)' \
    APPC='$(addprefix applet/,$(notdir $(OBJC)))' \
    APPCXX='$(addprefix applet/,$(notdir $(OBJCXX)))' \
    APPA='$(addprefix applet/,$(notdir $(OBJA)))' \
    OBJAPPDIR='$(APPC) $(APPCXX) $(APPA)' \
    OBJ='$(if $(BUILD_LOCALLY),$(OBJAPPDIR),$(OBJARDUINODIR))' \
    DEPS='$(OBJ:.o=.d) applet/$(TARGET).d' LST='$(OBJ:.o=.lst)' \
    $target ${BUILD_LOCALLY:+BUILD_LOCALLY=1} "$@"