diff options
Diffstat (limited to 'test/arduino_make.sh')
| -rwxr-xr-x | test/arduino_make.sh | 1359 |
1 files changed, 1359 insertions, 0 deletions
diff --git a/test/arduino_make.sh b/test/arduino_make.sh new file mode 100755 index 0000000..a4aaee9 --- /dev/null +++ b/test/arduino_make.sh @@ -0,0 +1,1359 @@ +#!/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} "$@" |