You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1206 lines
40 KiB
1206 lines
40 KiB
########################################################################
|
|
#
|
|
# Makefile for compiling Arduino sketches from command line
|
|
# System part (i.e. project independent)
|
|
#
|
|
# Copyright (C) 2012 Sudar <http://sudarmuthu.com>, based on
|
|
# - M J Oldfield work: https://github.com/mjoldfield/Arduino-Makefile
|
|
#
|
|
# Copyright (C) 2010,2011,2012 Martin Oldfield <m@mjo.tc>, based on
|
|
# work that is copyright Nicholas Zambetti, David A. Mellis & Hernando
|
|
# Barragan.
|
|
#
|
|
# This file is free software; you can redistribute it and/or modify it
|
|
# under the terms of the GNU Lesser General Public License as
|
|
# published by the Free Software Foundation; either version 2.1 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# Adapted from Arduino 0011 Makefile by M J Oldfield
|
|
#
|
|
# Original Arduino adaptation by mellis, eighthave, oli.keller
|
|
#
|
|
# Current version: 1.0.1
|
|
#
|
|
# Refer to HISTORY.md file for complete history of changes
|
|
#
|
|
########################################################################
|
|
#
|
|
# PATHS YOU NEED TO SET UP
|
|
#
|
|
# We need to worry about three different sorts of file:
|
|
#
|
|
# 1. Things which are included in this distribution e.g. ard-reset-arduino
|
|
# => ARDMK_DIR - Where the *.mk files are stored
|
|
# => ARDMK_PATH - Where the ard-reset-arduino script is stored
|
|
#
|
|
# 2. Things which are always in the Arduino distribution e.g.
|
|
# boards.txt, libraries, &c.
|
|
# => ARDUINO_DIR
|
|
#
|
|
# 3. Things which might be bundled with the Arduino distribution, but
|
|
# might come from the system. Most of the toolchain is like this:
|
|
# on Linux it's supplied by the system.
|
|
# => AVR_TOOLS_DIR
|
|
#
|
|
# Having set these three variables, we can work out the rest assuming
|
|
# that things are canonically arranged beneath the directories defined
|
|
# above.
|
|
#
|
|
# On the Mac you might want to set:
|
|
#
|
|
# ARDUINO_DIR = /Applications/Arduino.app/Contents/Resources/Java
|
|
# ARDMK_DIR = /usr/local
|
|
#
|
|
# On Linux, you might prefer:
|
|
#
|
|
# ARDUINO_DIR = /usr/share/arduino
|
|
# ARDMK_DIR = /usr
|
|
# AVR_TOOLS_DIR = /usr
|
|
#
|
|
# You can either set these up in the Makefile, or put them in your
|
|
# environment e.g. in your .bashrc
|
|
#
|
|
# If you don't specify these, we can try to guess, but that might not work
|
|
# or work the way you want it to.
|
|
#
|
|
# If you don't install the ard-reset-arduino binary to /usr/local/bin, but
|
|
# instead copy them to e.g. /home/mjo/arduino.mk/bin then set
|
|
# ARDMK_PATH = /home/mjo/arduino.mk/bin
|
|
#
|
|
# If you'd rather not see the configuration output, define ARDUINO_QUIET.
|
|
#
|
|
########################################################################
|
|
#
|
|
# DEPENDENCIES
|
|
#
|
|
# The Perl programs need a couple of libraries:
|
|
# Device::SerialPort
|
|
#
|
|
########################################################################
|
|
#
|
|
# STANDARD ARDUINO WORKFLOW
|
|
#
|
|
# Given a normal sketch directory, all you need to do is to create
|
|
# a small Makefile which defines a few things, and then includes this one.
|
|
#
|
|
# For example:
|
|
#
|
|
# ARDUINO_LIBS = Ethernet SPI
|
|
# BOARD_TAG = uno
|
|
# MONITOR_PORT = /dev/cu.usb*
|
|
#
|
|
# include /usr/share/arduino/Arduino.mk
|
|
#
|
|
# Hopefully these will be self-explanatory but in case they're not:
|
|
#
|
|
# ARDUINO_LIBS - A list of any libraries used by the sketch (we
|
|
# assume these are in $(ARDUINO_DIR)/hardware/libraries
|
|
# or your sketchbook's libraries directory)
|
|
#
|
|
# MONITOR_PORT - The port where the Arduino can be found (only needed
|
|
# when uploading)
|
|
#
|
|
# BOARD_TAG - The tag for the board e.g. uno or mega
|
|
# 'make show_boards' shows a list
|
|
#
|
|
# If you have your additional libraries relative to your source, rather
|
|
# than in your "sketchbook", also set USER_LIB_PATH, like this example:
|
|
#
|
|
# USER_LIB_PATH := $(realpath ../../libraries)
|
|
#
|
|
# If you've added the Arduino-Makefile repository to your git repo as a
|
|
# submodule (or other similar arrangement), you might have lines like this
|
|
# in your Makefile:
|
|
#
|
|
# ARDMK_DIR := $(realpath ../../tools/Arduino-Makefile)
|
|
# include $(ARDMK_DIR)/arduino-mk/Arduino.mk
|
|
#
|
|
# In any case, once this file has been created the typical workflow is just
|
|
#
|
|
# $ make upload
|
|
#
|
|
# All of the object files are created in the build-{BOARD_TAG} subdirectory
|
|
# All sources should be in the current directory and can include:
|
|
# - at most one .pde or .ino file which will be treated as C++ after
|
|
# the standard Arduino header and footer have been affixed.
|
|
# - any number of .c, .cpp, .s and .h files
|
|
#
|
|
# Included libraries are built in the build-{BOARD_TAG}/libs subdirectory.
|
|
#
|
|
# Besides make upload, there are a couple of other targets that are available.
|
|
# Do make help to get the complete list of targets and their description
|
|
#
|
|
########################################################################
|
|
#
|
|
# SERIAL MONITOR
|
|
#
|
|
# The serial monitor just invokes the GNU screen program with suitable
|
|
# options. For more information see screen (1) and search for
|
|
# 'character special device'.
|
|
#
|
|
# The really useful thing to know is that ^A-k gets you out!
|
|
#
|
|
# The fairly useful thing to know is that you can bind another key to
|
|
# escape too, by creating $HOME{.screenrc} containing e.g.
|
|
#
|
|
# bindkey ^C kill
|
|
#
|
|
# If you want to change the baudrate, just set MONITOR_BAUDRATE. If you
|
|
# don't set it, it tries to read from the sketch. If it couldn't read
|
|
# from the sketch, then it defaults to 9600 baud.
|
|
#
|
|
########################################################################
|
|
#
|
|
# ARDUINO WITH ISP
|
|
#
|
|
# You need to specify some details of your ISP programmer and might
|
|
# also need to specify the fuse values:
|
|
#
|
|
# ISP_PROG = stk500v2
|
|
# ISP_PORT = /dev/ttyACM0
|
|
#
|
|
# You might also need to set the fuse bits, but typically they'll be
|
|
# read from boards.txt, based on the BOARD_TAG variable:
|
|
#
|
|
# ISP_LOCK_FUSE_PRE = 0x3f
|
|
# ISP_LOCK_FUSE_POST = 0xcf
|
|
# ISP_HIGH_FUSE = 0xdf
|
|
# ISP_LOW_FUSE = 0xff
|
|
# ISP_EXT_FUSE = 0x01
|
|
#
|
|
# You can specify to also upload the EEPROM file:
|
|
# ISP_EEPROM = 1
|
|
#
|
|
# I think the fuses here are fine for uploading to the ATmega168
|
|
# without bootloader.
|
|
#
|
|
# To actually do this upload use the ispload target:
|
|
#
|
|
# make ispload
|
|
#
|
|
#
|
|
########################################################################
|
|
#
|
|
# ALTERNATIVE CORES
|
|
#
|
|
# To use alternative cores for platforms such as ATtiny, you need to
|
|
# specify a few more variables, depending on the core in use.
|
|
#
|
|
# The HLT (attiny-master) core can be used just by specifying
|
|
# ALTERNATE_CORE, assuming your core is in your ~/sketchbook/hardware
|
|
# directory. For example:
|
|
#
|
|
# ISP_PORT = /dev/ttyACM0
|
|
# BOARD_TAG = attiny85
|
|
# ALTERNATE_CORE = attiny-master
|
|
#
|
|
# To use the more complex arduino-tiny and TinyCore2 cores, you must
|
|
# also set ARDUINO_CORE_PATH and ARDUINO_VAR_PATH to the core
|
|
# directory, as these cores essentially replace the main Arduino core.
|
|
# For example:
|
|
#
|
|
# ISP_PORT = /dev/ttyACM0
|
|
# BOARD_TAG = attiny85at8
|
|
# ALTERNATE_CORE = arduino-tiny
|
|
# ARDUINO_VAR_PATH = ~/sketchbook/hardware/arduino-tiny/cores/tiny
|
|
# ARDUINO_CORE_PATH = ~/sketchbook/hardware/arduino-tiny/cores/tiny
|
|
#
|
|
# or....
|
|
#
|
|
# ISP_PORT = /dev/ttyACM0
|
|
# BOARD_TAG = attiny861at8
|
|
# ALTERNATE_CORE = tiny2
|
|
# ARDUINO_VAR_PATH = ~/sketchbook/hardware/tiny2/cores/tiny
|
|
# ARDUINO_CORE_PATH = ~/sketchbook/hardware/tiny2/cores/tiny
|
|
#
|
|
########################################################################
|
|
|
|
arduino_output =
|
|
# When output is not suppressed and we're in the top-level makefile,
|
|
# running for the first time (i.e., not after a restart after
|
|
# regenerating the dependency file), then output the configuration.
|
|
ifndef ARDUINO_QUIET
|
|
ifeq ($(MAKE_RESTARTS),)
|
|
ifeq ($(MAKELEVEL),0)
|
|
arduino_output = $(info $(1))
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
########################################################################
|
|
# Makefile distribution path
|
|
|
|
ifndef ARDMK_DIR
|
|
# presume it's a level above the path to our own file
|
|
ARDMK_DIR := $(realpath $(dir $(realpath $(lastword $(MAKEFILE_LIST))))/..)
|
|
else
|
|
# show_config_variable macro is defined in Common.mk file and is not available yet.
|
|
# Let's define a variable to know that user specified ARDMK_DIR
|
|
ARDMK_DIR_MSG = USER
|
|
endif
|
|
|
|
ifneq ($(wildcard $(ARDMK_DIR)/arduino-mk/Common.mk),)
|
|
# git checkout
|
|
ARDMK_FILE = $(ARDMK_DIR)/arduino-mk/arduino.mk
|
|
include $(ARDMK_DIR)/arduino-mk/Common.mk
|
|
else
|
|
ifneq ($(wildcard $(ARDMK_DIR)/Common.mk),)
|
|
# package install
|
|
ARDMK_FILE = $(ARDMK_DIR)/arduino.mk
|
|
include $(ARDMK_DIR)/Common.mk
|
|
endif
|
|
endif
|
|
|
|
# show_config_variable macro is available now. So let's print config details for ARDMK_DIR
|
|
ifndef ARDMK_DIR_MSG
|
|
$(call show_config_variable,ARDMK_DIR,[COMPUTED],(relative to $(notdir $(lastword $(MAKEFILE_LIST)))))
|
|
else
|
|
$(call show_config_variable,ARDMK_DIR,[USER])
|
|
endif
|
|
|
|
ifndef ARDMK_PATH
|
|
ARDMK_PATH = $(ARDMK_DIR)/bin
|
|
$(call show_config_variable,ARDMK_PATH,[COMPUTED],(relative to ARDMK_DIR))
|
|
else
|
|
$(call show_config_variable,ARDMK_PATH,[USER])
|
|
endif
|
|
|
|
########################################################################
|
|
# Arduino Directory
|
|
|
|
ifndef ARDUINO_DIR
|
|
AUTO_ARDUINO_DIR := $(firstword \
|
|
$(call dir_if_exists,/usr/share/arduino) \
|
|
$(call dir_if_exists,/Applications/Arduino.app/Contents/Resources/Java) )
|
|
ifdef AUTO_ARDUINO_DIR
|
|
ARDUINO_DIR = $(AUTO_ARDUINO_DIR)
|
|
$(call show_config_variable,ARDUINO_DIR,[AUTODETECTED])
|
|
else
|
|
echo $(error "ARDUINO_DIR is not defined")
|
|
endif
|
|
else
|
|
$(call show_config_variable,ARDUINO_DIR,[USER])
|
|
endif
|
|
|
|
########################################################################
|
|
# Default TARGET to pwd (ex Daniele Vergini)
|
|
|
|
ifndef TARGET
|
|
TARGET = $(notdir $(CURDIR))
|
|
endif
|
|
|
|
########################################################################
|
|
# Arduino version number
|
|
|
|
ifndef ARDUINO_VERSION
|
|
# Remove all the decimals, and right-pad with zeros, and finally grab the first 3 bytes.
|
|
# Works for 1.0 and 1.0.1
|
|
VERSION_FILE := $(ARDUINO_DIR)/lib/version.txt
|
|
AUTO_ARDUINO_VERSION := $(shell [ -e $(VERSION_FILE) ] && cat $(VERSION_FILE) | sed -e 's/^[0-9]://g' -e 's/[.]//g' -e 's/$$/0000/' | head -c3)
|
|
ifdef AUTO_ARDUINO_VERSION
|
|
ARDUINO_VERSION = $(AUTO_ARDUINO_VERSION)
|
|
$(call show_config_variable,ARDUINO_VERSION,[AUTODETECTED])
|
|
else
|
|
ARDUINO_VERSION = 100
|
|
$(call show_config_variable,ARDUINO_VERSION,[DEFAULT])
|
|
endif
|
|
else
|
|
$(call show_config_variable,ARDUINO_VERSION,[USER])
|
|
endif
|
|
|
|
########################################################################
|
|
# Arduino Sketchbook folder
|
|
|
|
ifndef ARDUINO_SKETCHBOOK
|
|
ifndef ARDUINO_PREFERENCES_PATH
|
|
|
|
AUTO_ARDUINO_PREFERENCES := $(firstword \
|
|
$(call dir_if_exists,$(HOME)/.arduino/preferences.txt) \
|
|
$(call dir_if_exists,$(HOME)/Library/Arduino/preferences.txt) )
|
|
ifdef AUTO_ARDUINO_PREFERENCES
|
|
ARDUINO_PREFERENCES_PATH = $(AUTO_ARDUINO_PREFERENCES)
|
|
$(call show_config_variable,ARDUINO_PREFERENCES_PATH,[AUTODETECTED])
|
|
endif
|
|
|
|
else
|
|
$(call show_config_variable,ARDUINO_PREFERENCES_PATH,[USER])
|
|
endif
|
|
|
|
ifneq ($(ARDUINO_PREFERENCES_PATH),)
|
|
ARDUINO_SKETCHBOOK = $(shell grep --max-count=1 --regexp="sketchbook.path=" \
|
|
$(ARDUINO_PREFERENCES_PATH) | \
|
|
sed -e 's/sketchbook.path=//' )
|
|
endif
|
|
|
|
ifneq ($(ARDUINO_SKETCHBOOK),)
|
|
$(call show_config_variable,ARDUINO_SKETCHBOOK,[AUTODETECTED],(from arduino preferences file))
|
|
else
|
|
|
|
ARDUINO_SKETCHBOOK := $(firstword \
|
|
$(call dir_if_exists,$(HOME)/sketchbook) \
|
|
$(call dir_if_exists,$(HOME)/Documents/Arduino/) )
|
|
$(call show_config_variable,ARDUINO_SKETCHBOOK,[DEFAULT])
|
|
endif
|
|
else
|
|
$(call show_config_variable,ARDUINO_SKETCHBOOK)
|
|
endif
|
|
|
|
########################################################################
|
|
# Arduino and system paths
|
|
|
|
ifndef CC_NAME
|
|
CC_NAME = avr-gcc
|
|
endif
|
|
|
|
ifndef CXX_NAME
|
|
CXX_NAME = avr-g++
|
|
endif
|
|
|
|
ifndef OBJCOPY_NAME
|
|
OBJCOPY_NAME = avr-objcopy
|
|
endif
|
|
|
|
ifndef OBJDUMP_NAME
|
|
OBJDUMP_NAME = avr-objdump
|
|
endif
|
|
|
|
ifndef AR_NAME
|
|
AR_NAME = avr-ar
|
|
endif
|
|
|
|
ifndef SIZE_NAME
|
|
SIZE_NAME = avr-size
|
|
endif
|
|
|
|
ifndef NM_NAME
|
|
NM_NAME = avr-nm
|
|
endif
|
|
|
|
ifndef AVR_TOOLS_DIR
|
|
|
|
BUNDLED_AVR_TOOLS_DIR := $(call dir_if_exists,$(ARDUINO_DIR)/hardware/tools/avr)
|
|
ifdef BUNDLED_AVR_TOOLS_DIR
|
|
AVR_TOOLS_DIR = $(BUNDLED_AVR_TOOLS_DIR)
|
|
$(call show_config_variable,AVR_TOOLS_DIR,[BUNDLED],(in Arduino distribution))
|
|
|
|
# In Linux distribution of Arduino, the path to avrdude and avrdude.conf are different
|
|
# More details at https://github.com/sudar/Arduino-Makefile/issues/48 and
|
|
# https://groups.google.com/a/arduino.cc/d/msg/developers/D_m97jGr8Xs/uQTt28KO_8oJ
|
|
ifeq ($(CURRENT_OS),LINUX)
|
|
|
|
ifndef AVRDUDE
|
|
AVRDUDE = $(AVR_TOOLS_DIR)/../avrdude
|
|
endif
|
|
|
|
ifndef AVRDUDE_CONF
|
|
AVRDUDE_CONF = $(AVR_TOOLS_DIR)/../avrdude.conf
|
|
endif
|
|
|
|
else
|
|
|
|
ifndef AVRDUDE_CONF
|
|
AVRDUDE_CONF = $(AVR_TOOLS_DIR)/etc/avrdude.conf
|
|
endif
|
|
|
|
endif
|
|
|
|
else
|
|
|
|
SYSTEMPATH_AVR_TOOLS_DIR := $(call dir_if_exists,$(abspath $(dir $(shell which $(CC_NAME)))/..))
|
|
ifdef SYSTEMPATH_AVR_TOOLS_DIR
|
|
AVR_TOOLS_DIR = $(SYSTEMPATH_AVR_TOOLS_DIR)
|
|
$(call show_config_variable,AVR_TOOLS_DIR,[AUTODETECTED],(found in $$PATH))
|
|
else
|
|
echo $(error No AVR tools directory found)
|
|
endif # SYSTEMPATH_AVR_TOOLS_DIR
|
|
|
|
endif # BUNDLED_AVR_TOOLS_DIR
|
|
|
|
else
|
|
$(call show_config_variable,AVR_TOOLS_DIR,[USER])
|
|
endif #ndef AVR_TOOLS_DIR
|
|
|
|
ifndef AVR_TOOLS_PATH
|
|
AVR_TOOLS_PATH = $(AVR_TOOLS_DIR)/bin
|
|
endif
|
|
|
|
ARDUINO_LIB_PATH = $(ARDUINO_DIR)/libraries
|
|
$(call show_config_variable,ARDUINO_LIB_PATH,[COMPUTED],(from ARDUINO_DIR))
|
|
ifndef ARDUINO_CORE_PATH
|
|
ARDUINO_CORE_PATH = $(ARDUINO_DIR)/hardware/arduino/cores/arduino
|
|
$(call show_config_variable,ARDUINO_CORE_PATH,[DEFAULT])
|
|
else
|
|
$(call show_config_variable,ARDUINO_CORE_PATH,[USER])
|
|
endif
|
|
|
|
# Third party hardware and core like ATtiny or ATmega 16
|
|
ifdef ALTERNATE_CORE
|
|
$(call show_config_variable,ALTERNATE_CORE,[USER])
|
|
|
|
ifndef ALTERNATE_CORE_PATH
|
|
ALTERNATE_CORE_PATH = $(ARDUINO_SKETCHBOOK)/hardware/$(ALTERNATE_CORE)
|
|
endif
|
|
endif
|
|
|
|
ifdef ALTERNATE_CORE_PATH
|
|
|
|
ifdef ALTERNATE_CORE
|
|
$(call show_config_variable,ALTERNATE_CORE_PATH,[COMPUTED], (from ARDUINO_SKETCHBOOK and ALTERNATE_CORE))
|
|
else
|
|
$(call show_config_variable,ALTERNATE_CORE_PATH,[USER])
|
|
endif
|
|
|
|
ifndef ARDUINO_VAR_PATH
|
|
ARDUINO_VAR_PATH = $(ALTERNATE_CORE_PATH)/variants
|
|
$(call show_config_variable,ARDUINO_VAR_PATH,[COMPUTED],(from ALTERNATE_CORE_PATH))
|
|
endif
|
|
|
|
ifndef BOARDS_TXT
|
|
BOARDS_TXT = $(ALTERNATE_CORE_PATH)/boards.txt
|
|
$(call show_config_variable,BOARDS_TXT,[COMPUTED],(from ALTERNATE_CORE_PATH))
|
|
endif
|
|
|
|
else
|
|
|
|
ifndef ARDUINO_VAR_PATH
|
|
ARDUINO_VAR_PATH = $(ARDUINO_DIR)/hardware/arduino/variants
|
|
$(call show_config_variable,ARDUINO_VAR_PATH,[COMPUTED],(from ARDUINO_DIR))
|
|
else
|
|
$(call show_config_variable,ARDUINO_VAR_PATH,[USER])
|
|
endif
|
|
|
|
ifndef BOARDS_TXT
|
|
BOARDS_TXT = $(ARDUINO_DIR)/hardware/arduino/boards.txt
|
|
$(call show_config_variable,BOARDS_TXT,[COMPUTED],(from ARDUINO_DIR))
|
|
else
|
|
$(call show_config_variable,BOARDS_TXT,[USER])
|
|
endif
|
|
|
|
endif
|
|
|
|
########################################################################
|
|
# Miscellaneous
|
|
|
|
ifndef USER_LIB_PATH
|
|
USER_LIB_PATH = $(ARDUINO_SKETCHBOOK)/libraries
|
|
$(call show_config_variable,USER_LIB_PATH,[DEFAULT],(in user sketchbook))
|
|
else
|
|
$(call show_config_variable,USER_LIB_PATH,[USER])
|
|
endif
|
|
|
|
########################################################################
|
|
# boards.txt parsing
|
|
|
|
ifndef BOARD_TAG
|
|
BOARD_TAG = uno
|
|
$(call show_config_variable,BOARD_TAG,[DEFAULT])
|
|
else
|
|
# Strip the board tag of any extra whitespace, since it was causing the makefile to fail
|
|
# https://github.com/sudar/Arduino-Makefile/issues/57
|
|
BOARD_TAG := $(strip $(BOARD_TAG))
|
|
$(call show_config_variable,BOARD_TAG,[USER])
|
|
endif
|
|
|
|
ifndef PARSE_BOARD
|
|
# result = $(call READ_BOARD_TXT, 'boardname', 'parameter')
|
|
PARSE_BOARD = $(shell grep -v "^\#" $(BOARDS_TXT) | grep $(1).$(2) | cut -d = -f 2 )
|
|
endif
|
|
|
|
# If NO_CORE is set, then we don't have to parse boards.txt file
|
|
# But the user might have to define MCU, F_CPU etc
|
|
ifeq ($(strip $(NO_CORE)),)
|
|
|
|
# Which variant ? This affects the include path
|
|
ifndef VARIANT
|
|
VARIANT = $(call PARSE_BOARD,$(BOARD_TAG),build.variant)
|
|
endif
|
|
|
|
# see if we are a caterina device like leonardo or micro
|
|
CATERINA = $(findstring caterina,$(call PARSE_BOARD,$(BOARD_TAG),bootloader.path))
|
|
|
|
# processor stuff
|
|
ifndef MCU
|
|
MCU = $(call PARSE_BOARD,$(BOARD_TAG),build.mcu)
|
|
endif
|
|
|
|
ifndef F_CPU
|
|
F_CPU = $(call PARSE_BOARD,$(BOARD_TAG),build.f_cpu)
|
|
endif
|
|
|
|
ifneq ($(CATERINA),)
|
|
# USB IDs for the caterina devices like leonardo or micro
|
|
ifndef USB_VID
|
|
USB_VID = $(call PARSE_BOARD,$(BOARD_TAG),build.vid)
|
|
endif
|
|
|
|
ifndef USB_PID
|
|
USB_PID = $(call PARSE_BOARD,$(BOARD_TAG),build.pid)
|
|
endif
|
|
endif
|
|
|
|
# normal programming info
|
|
ifndef AVRDUDE_ARD_PROGRAMMER
|
|
AVRDUDE_ARD_PROGRAMMER = $(call PARSE_BOARD,$(BOARD_TAG),upload.protocol)
|
|
endif
|
|
|
|
ifndef AVRDUDE_ARD_BAUDRATE
|
|
AVRDUDE_ARD_BAUDRATE = $(call PARSE_BOARD,$(BOARD_TAG),upload.speed)
|
|
endif
|
|
|
|
# fuses if you're using e.g. ISP
|
|
ifndef ISP_LOCK_FUSE_PRE
|
|
ISP_LOCK_FUSE_PRE = $(call PARSE_BOARD,$(BOARD_TAG),bootloader.unlock_bits)
|
|
endif
|
|
|
|
ifndef ISP_HIGH_FUSE
|
|
ISP_HIGH_FUSE = $(call PARSE_BOARD,$(BOARD_TAG),bootloader.high_fuses)
|
|
endif
|
|
|
|
ifndef ISP_LOW_FUSE
|
|
ISP_LOW_FUSE = $(call PARSE_BOARD,$(BOARD_TAG),bootloader.low_fuses)
|
|
endif
|
|
|
|
ifndef ISP_EXT_FUSE
|
|
ISP_EXT_FUSE = $(call PARSE_BOARD,$(BOARD_TAG),bootloader.extended_fuses)
|
|
endif
|
|
|
|
ifndef BOOTLOADER_PATH
|
|
BOOTLOADER_PATH = $(call PARSE_BOARD,$(BOARD_TAG),bootloader.path)
|
|
endif
|
|
|
|
ifndef BOOTLOADER_FILE
|
|
BOOTLOADER_FILE = $(call PARSE_BOARD,$(BOARD_TAG),bootloader.file)
|
|
endif
|
|
|
|
ifndef ISP_LOCK_FUSE_POST
|
|
ISP_LOCK_FUSE_POST = $(call PARSE_BOARD,$(BOARD_TAG),bootloader.lock_bits)
|
|
endif
|
|
|
|
ifndef HEX_MAXIMUM_SIZE
|
|
HEX_MAXIMUM_SIZE = $(call PARSE_BOARD,$(BOARD_TAG),upload.maximum_size)
|
|
endif
|
|
|
|
endif
|
|
|
|
# Everything gets built in here (include BOARD_TAG now)
|
|
ifndef OBJDIR
|
|
OBJDIR = build-$(BOARD_TAG)
|
|
$(call show_config_variable,OBJDIR,[COMPUTED],(from BOARD_TAG))
|
|
else
|
|
$(call show_config_variable,OBJDIR,[USER])
|
|
endif
|
|
|
|
########################################################################
|
|
# Reset
|
|
|
|
ifndef RESET_CMD
|
|
ifneq ($(CATERINA),)
|
|
RESET_CMD = $(ARDMK_PATH)/ard-reset-arduino --caterina \
|
|
$(ARD_RESET_OPTS) $(call get_monitor_port)
|
|
else
|
|
RESET_CMD = $(ARDMK_PATH)/ard-reset-arduino \
|
|
$(ARD_RESET_OPTS) $(call get_monitor_port)
|
|
endif
|
|
endif
|
|
|
|
ifneq ($(CATERINA),)
|
|
ERROR_ON_CATERINA = $(error On $(BOARD_TAG), raw_xxx operation is not supported)
|
|
else
|
|
ERROR_ON_CATERINA =
|
|
endif
|
|
|
|
########################################################################
|
|
# Local sources
|
|
|
|
LOCAL_C_SRCS ?= $(wildcard *.c)
|
|
LOCAL_CPP_SRCS ?= $(wildcard *.cpp)
|
|
LOCAL_CC_SRCS ?= $(wildcard *.cc)
|
|
LOCAL_PDE_SRCS ?= $(wildcard *.pde)
|
|
LOCAL_INO_SRCS ?= $(wildcard *.ino)
|
|
LOCAL_AS_SRCS ?= $(wildcard *.S)
|
|
LOCAL_SRCS = $(LOCAL_C_SRCS) $(LOCAL_CPP_SRCS) \
|
|
$(LOCAL_CC_SRCS) $(LOCAL_PDE_SRCS) \
|
|
$(LOCAL_INO_SRCS) $(LOCAL_AS_SRCS)
|
|
LOCAL_OBJ_FILES = $(LOCAL_C_SRCS:.c=.o) $(LOCAL_CPP_SRCS:.cpp=.o) \
|
|
$(LOCAL_CC_SRCS:.cc=.o) $(LOCAL_PDE_SRCS:.pde=.o) \
|
|
$(LOCAL_INO_SRCS:.ino=.o) $(LOCAL_AS_SRCS:.S=.o)
|
|
LOCAL_OBJS = $(patsubst %,$(OBJDIR)/%,$(LOCAL_OBJ_FILES))
|
|
|
|
ifeq ($(words $(LOCAL_SRCS)), 0)
|
|
$(error Atleast one source file (*.ino, *.pde, *.cpp, *c, *cc, *.S) is needed)
|
|
endif
|
|
|
|
ifeq ($(strip $(NO_CORE)),)
|
|
|
|
# Ideally, this should just check if there are more than one file
|
|
ifneq ($(words $(LOCAL_PDE_SRCS) $(LOCAL_INO_SRCS)), 1)
|
|
ifeq ($(words $(LOCAL_PDE_SRCS) $(LOCAL_INO_SRCS)), 0)
|
|
$(call show_config_info,No .pde or .ino files found. If you are compiling .c or .cpp files then you need to explicitly include Arduino header files)
|
|
else
|
|
#TODO: Support more than one file. https://github.com/sudar/Arduino-Makefile/issues/49
|
|
$(error Need exactly one .pde or .ino file. This makefile doesn't support multiple .ino/.pde files yet)
|
|
endif
|
|
endif
|
|
|
|
endif
|
|
|
|
# core sources
|
|
ifeq ($(strip $(NO_CORE)),)
|
|
ifdef ARDUINO_CORE_PATH
|
|
CORE_C_SRCS = $(wildcard $(ARDUINO_CORE_PATH)/*.c)
|
|
CORE_CPP_SRCS = $(wildcard $(ARDUINO_CORE_PATH)/*.cpp)
|
|
|
|
ifneq ($(strip $(NO_CORE_MAIN_CPP)),)
|
|
CORE_CPP_SRCS := $(filter-out %main.cpp, $(CORE_CPP_SRCS))
|
|
$(call show_config_info,NO_CORE_MAIN_CPP set so core library will not include main.cpp,[MANUAL])
|
|
endif
|
|
|
|
CORE_OBJ_FILES = $(CORE_C_SRCS:.c=.o) $(CORE_CPP_SRCS:.cpp=.o)
|
|
CORE_OBJS = $(patsubst $(ARDUINO_CORE_PATH)/%, \
|
|
$(OBJDIR)/%,$(CORE_OBJ_FILES))
|
|
endif
|
|
else
|
|
$(call show_config_info,NO_CORE set so core library will not be built,[MANUAL])
|
|
endif
|
|
|
|
########################################################################
|
|
# Determine ARDUINO_LIBS automatically
|
|
|
|
ifndef ARDUINO_LIBS
|
|
# automatically determine included libraries
|
|
ARDUINO_LIBS += $(filter $(notdir $(wildcard $(ARDUINO_DIR)/libraries/*)), \
|
|
$(shell sed -ne "s/^ *\# *include *[<\"]\(.*\)\.h[>\"]/\1/p" $(LOCAL_SRCS)))
|
|
ARDUINO_LIBS += $(filter $(notdir $(wildcard $(ARDUINO_SKETCHBOOK)/libraries/*)), \
|
|
$(shell sed -ne "s/^ *\# *include *[<\"]\(.*\)\.h[>\"]/\1/p" $(LOCAL_SRCS)))
|
|
endif
|
|
|
|
########################################################################
|
|
# Serial monitor (just a screen wrapper)
|
|
|
|
# Quite how to construct the monitor command seems intimately tied
|
|
# to the command we're using (here screen). So, read the screen docs
|
|
# for more information (search for 'character special device').
|
|
|
|
ifeq ($(strip $(NO_CORE)),)
|
|
ifndef MONITOR_BAUDRATE
|
|
ifeq ($(words $(LOCAL_PDE_SRCS) $(LOCAL_INO_SRCS)), 1)
|
|
SPEED = $(shell egrep -h 'Serial.begin\([0-9]+\)' $(LOCAL_PDE_SRCS) $(LOCAL_INO_SRCS) | sed -e 's/[^0-9]//g'| head -n1)
|
|
MONITOR_BAUDRATE = $(findstring $(SPEED),300 1200 2400 4800 9600 14400 19200 28800 38400 57600 115200)
|
|
endif
|
|
|
|
ifeq ($(MONITOR_BAUDRATE),)
|
|
MONITOR_BAUDRATE = 9600
|
|
$(call show_config_variable,MONITOR_BAUDRATE,[ASSUMED])
|
|
else
|
|
$(call show_config_variable,MONITOR_BAUDRATE,[DETECTED], (in sketch))
|
|
endif
|
|
else
|
|
$(call show_config_variable,MONITOR_BAUDRATE, [USER])
|
|
endif
|
|
|
|
ifndef MONITOR_CMD
|
|
MONITOR_CMD = screen
|
|
endif
|
|
endif
|
|
|
|
########################################################################
|
|
# Include file to use for old .pde files
|
|
|
|
ifndef ARDUINO_HEADER
|
|
# We should check for Arduino version, if the file is .pde because a
|
|
# .pde file might be used in Arduino 1.0
|
|
ifeq ($(shell expr $(ARDUINO_VERSION) '<' 100), 1)
|
|
ARDUINO_HEADER=WProgram.h
|
|
else
|
|
ARDUINO_HEADER=Arduino.h
|
|
endif
|
|
endif
|
|
|
|
########################################################################
|
|
# Rules for making stuff
|
|
|
|
# The name of the main targets
|
|
TARGET_HEX = $(OBJDIR)/$(TARGET).hex
|
|
TARGET_ELF = $(OBJDIR)/$(TARGET).elf
|
|
TARGET_EEP = $(OBJDIR)/$(TARGET).eep
|
|
TARGETS = $(OBJDIR)/$(TARGET).*
|
|
CORE_LIB = $(OBJDIR)/libcore.a
|
|
|
|
# Names of executables
|
|
CC = $(AVR_TOOLS_PATH)/$(CC_NAME)
|
|
CXX = $(AVR_TOOLS_PATH)/$(CXX_NAME)
|
|
AS = $(AVR_TOOLS_PATH)/$(AS_NAME)
|
|
OBJCOPY = $(AVR_TOOLS_PATH)/$(OBJCOPY_NAME)
|
|
OBJDUMP = $(AVR_TOOLS_PATH)/$(OBJDUMP_NAME)
|
|
AR = $(AVR_TOOLS_PATH)/$(AR_NAME)
|
|
SIZE = $(AVR_TOOLS_PATH)/$(SIZE_NAME)
|
|
NM = $(AVR_TOOLS_PATH)/$(NM_NAME)
|
|
REMOVE = rm -rf
|
|
MV = mv -f
|
|
CAT = cat
|
|
ECHO = echo
|
|
MKDIR = mkdir -p
|
|
|
|
# General arguments
|
|
USER_LIBS = $(wildcard $(patsubst %,$(USER_LIB_PATH)/%,$(ARDUINO_LIBS)))
|
|
USER_LIB_NAMES = $(patsubst $(USER_LIB_PATH)/%,%,$(USER_LIBS))
|
|
|
|
# Let user libraries override system ones.
|
|
SYS_LIBS = $(wildcard $(patsubst %,$(ARDUINO_LIB_PATH)/%,$(filter-out $(USER_LIB_NAMES),$(ARDUINO_LIBS))))
|
|
SYS_LIB_NAMES = $(patsubst $(ARDUINO_LIB_PATH)/%,%,$(SYS_LIBS))
|
|
|
|
# Error here if any are missing.
|
|
LIBS_NOT_FOUND = $(filter-out $(USER_LIB_NAMES) $(SYS_LIB_NAMES),$(ARDUINO_LIBS))
|
|
ifneq (,$(strip $(LIBS_NOT_FOUND)))
|
|
$(error The following libraries specified in ARDUINO_LIBS could not be found (searched USER_LIB_PATH and ARDUINO_LIB_PATH): $(LIBS_NOT_FOUND))
|
|
endif
|
|
|
|
SYS_LIBS := $(wildcard $(SYS_LIBS) $(addsuffix /utility,$(SYS_LIBS)))
|
|
USER_LIBS := $(wildcard $(USER_LIBS) $(addsuffix /utility,$(USER_LIBS)))
|
|
SYS_INCLUDES = $(patsubst %,-I%,$(SYS_LIBS))
|
|
USER_INCLUDES = $(patsubst %,-I%,$(USER_LIBS))
|
|
LIB_C_SRCS = $(wildcard $(patsubst %,%/*.c,$(SYS_LIBS)))
|
|
LIB_CPP_SRCS = $(wildcard $(patsubst %,%/*.cpp,$(SYS_LIBS)))
|
|
USER_LIB_CPP_SRCS = $(wildcard $(patsubst %,%/*.cpp,$(USER_LIBS)))
|
|
USER_LIB_C_SRCS = $(wildcard $(patsubst %,%/*.c,$(USER_LIBS)))
|
|
LIB_OBJS = $(patsubst $(ARDUINO_LIB_PATH)/%.c,$(OBJDIR)/libs/%.o,$(LIB_C_SRCS)) \
|
|
$(patsubst $(ARDUINO_LIB_PATH)/%.cpp,$(OBJDIR)/libs/%.o,$(LIB_CPP_SRCS))
|
|
USER_LIB_OBJS = $(patsubst $(USER_LIB_PATH)/%.cpp,$(OBJDIR)/libs/%.o,$(USER_LIB_CPP_SRCS)) \
|
|
$(patsubst $(USER_LIB_PATH)/%.c,$(OBJDIR)/libs/%.o,$(USER_LIB_C_SRCS))
|
|
|
|
# Dependency files
|
|
DEPS = $(LOCAL_OBJS:.o=.d) $(LIB_OBJS:.o=.d) $(USER_LIB_OBJS:.o=.d) $(CORE_OBJS:.o=.d)
|
|
|
|
# Optimization level for the compiler.
|
|
# You can get the list of options at http://www.nongnu.org/avr-libc/user-manual/using_tools.html#gcc_optO
|
|
# Also read http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_optflags
|
|
ifndef OPTIMIZATION_LEVEL
|
|
OPTIMIZATION_LEVEL=s
|
|
$(call show_config_variable,OPTIMIZATION_LEVEL,[DEFAULT])
|
|
else
|
|
$(call show_config_variable,OPTIMIZATION_LEVEL,[USER])
|
|
endif
|
|
|
|
ifndef MCU_FLAG_NAME
|
|
MCU_FLAG_NAME = mmcu
|
|
$(call show_config_variable,MCU_FLAG_NAME,[DEFAULT])
|
|
else
|
|
$(call show_config_variable,MCU_FLAG_NAME,[USER])
|
|
endif
|
|
|
|
# Using += instead of =, so that CPPFLAGS can be set per sketch level
|
|
CPPFLAGS += -$(MCU_FLAG_NAME)=$(MCU) -DF_CPU=$(F_CPU) -DARDUINO=$(ARDUINO_VERSION) \
|
|
-I. -I$(ARDUINO_CORE_PATH) -I$(ARDUINO_VAR_PATH)/$(VARIANT) \
|
|
$(SYS_INCLUDES) $(USER_INCLUDES) -Wall -ffunction-sections \
|
|
-fdata-sections
|
|
|
|
ifdef DEBUG
|
|
CPPFLAGS += -O0 -g
|
|
else
|
|
CPPFLAGS += -O$(OPTIMIZATION_LEVEL)
|
|
endif
|
|
|
|
# USB IDs for the Caterina devices like leonardo or micro
|
|
ifneq ($(CATERINA),)
|
|
CPPFLAGS += -DUSB_VID=$(USB_VID) -DUSB_PID=$(USB_PID)
|
|
endif
|
|
|
|
ifndef CFLAGS_STD
|
|
CFLAGS_STD = -std=gnu99
|
|
$(call show_config_variable,CFLAGS_STD,[DEFAULT])
|
|
else
|
|
$(call show_config_variable,CFLAGS_STD,[USER])
|
|
endif
|
|
|
|
CFLAGS += $(EXTRA_FLAGS) $(EXTRA_CFLAGS)
|
|
CXXFLAGS += -fno-exceptions $(EXTRA_FLAGS) $(EXTRA_CXXFLAGS)
|
|
ASFLAGS += -$(MCU_FLAG_NAME)=$(MCU) -I. -x assembler-with-cpp
|
|
LDFLAGS += -$(MCU_FLAG_NAME)=$(MCU) -Wl,--gc-sections -O$(OPTIMIZATION_LEVEL) $(EXTRA_FLAGS) $(EXTRA_CXXFLAGS) $(EXTRA_LDFLAGS)
|
|
SIZEFLAGS ?= --mcu=$(MCU) -C
|
|
|
|
# for backwards compatibility, grab ARDUINO_PORT if the user has it set
|
|
MONITOR_PORT ?= $(ARDUINO_PORT)
|
|
|
|
# Returns the Arduino port (first wildcard expansion) if it exists, otherwise it errors.
|
|
get_monitor_port = $(if $(wildcard $(MONITOR_PORT)),$(firstword $(wildcard $(MONITOR_PORT))),$(error Arduino port $(MONITOR_PORT) not found!))
|
|
|
|
# Returns the ISP port (first wildcard expansion) if it exists, otherwise it errors.
|
|
get_isp_port = $(if $(wildcard $(ISP_PORT)),$(firstword $(wildcard $(ISP_PORT))),$(error ISP port $(ISP_PORT) not found!))
|
|
|
|
# Command for avr_size: do $(call avr_size,elffile,hexfile)
|
|
ifneq (,$(findstring AVR,$(shell $(SIZE) --help)))
|
|
# We have a patched version of binutils that mentions AVR - pass the MCU
|
|
# and the elf to get nice output.
|
|
avr_size = $(SIZE) $(SIZEFLAGS) --format=avr $(1)
|
|
$(call show_config_info,Size utility: AVR-aware for enhanced output,[AUTODETECTED])
|
|
else
|
|
# We have a plain-old binutils version - just give it the hex.
|
|
avr_size = $(SIZE) $(2)
|
|
$(call show_config_info,Size utility: Basic (not AVR-aware),[AUTODETECTED])
|
|
endif
|
|
|
|
ifneq (,$(strip $(ARDUINO_LIBS)))
|
|
$(call arduino_output,-)
|
|
$(call show_config_info,ARDUINO_LIBS =)
|
|
endif
|
|
|
|
ifneq (,$(strip $(USER_LIB_NAMES)))
|
|
$(foreach lib,$(USER_LIB_NAMES),$(call show_config_info, $(lib),[USER]))
|
|
endif
|
|
|
|
ifneq (,$(strip $(SYS_LIB_NAMES)))
|
|
$(foreach lib,$(SYS_LIB_NAMES),$(call show_config_info, $(lib),[SYSTEM]))
|
|
endif
|
|
|
|
# end of config output
|
|
$(call show_separator)
|
|
|
|
# Implicit rules for building everything (needed to get everything in
|
|
# the right directory)
|
|
#
|
|
# Rather than mess around with VPATH there are quasi-duplicate rules
|
|
# here for building e.g. a system C++ file and a local C++
|
|
# file. Besides making things simpler now, this would also make it
|
|
# easy to change the build options in future
|
|
|
|
# library sources
|
|
$(OBJDIR)/libs/%.o: $(ARDUINO_LIB_PATH)/%.c
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -MMD -c $(CPPFLAGS) $(CFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/libs/%.o: $(ARDUINO_LIB_PATH)/%.cpp
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -MMD -c $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/libs/%.o: $(USER_LIB_PATH)/%.cpp
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -MMD -c $(CPPFLAGS) $(CFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/libs/%.o: $(USER_LIB_PATH)/%.c
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -MMD -c $(CPPFLAGS) $(CFLAGS) $< -o $@
|
|
|
|
ifdef COMMON_DEPS
|
|
COMMON_DEPS := $(COMMON_DEPS) Makefile
|
|
else
|
|
COMMON_DEPS := Makefile
|
|
endif
|
|
|
|
# normal local sources
|
|
$(OBJDIR)/%.o: %.c $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -MMD -c $(CPPFLAGS) $(CFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/%.o: %.cc $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CXX) -MMD -c $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/%.o: %.cpp $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CXX) -MMD -c $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/%.o: %.S $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -MMD -c $(CPPFLAGS) $(ASFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/%.o: %.s $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -c $(CPPFLAGS) $(ASFLAGS) $< -o $@
|
|
|
|
# the pde -> o file
|
|
$(OBJDIR)/%.o: %.pde $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CXX) -x c++ -include $(ARDUINO_HEADER) -MMD -c $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
# the ino -> o file
|
|
$(OBJDIR)/%.o: %.ino $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CXX) -x c++ -include Arduino.h -MMD -c $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
# generated assembly
|
|
$(OBJDIR)/%.s: %.pde $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CXX) -x c++ -include $(ARDUINO_HEADER) -MMD -S -fverbose-asm $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/%.s: %.ino $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CXX) -x c++ -include Arduino.h -MMD -S -fverbose-asm $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
#$(OBJDIR)/%.lst: $(OBJDIR)/%.s
|
|
# $(AS) -$(MCU_FLAG_NAME)=$(MCU) -alhnd $< > $@
|
|
|
|
# core files
|
|
$(OBJDIR)/%.o: $(ARDUINO_CORE_PATH)/%.c $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CC) -MMD -c $(CPPFLAGS) $(CFLAGS) $< -o $@
|
|
|
|
$(OBJDIR)/%.o: $(ARDUINO_CORE_PATH)/%.cpp $(COMMON_DEPS) | $(OBJDIR)
|
|
@$(MKDIR) $(dir $@)
|
|
$(CXX) -MMD -c $(CPPFLAGS) $(CXXFLAGS) $< -o $@
|
|
|
|
# various object conversions
|
|
$(OBJDIR)/%.hex: $(OBJDIR)/%.elf $(COMMON_DEPS)
|
|
@$(MKDIR) $(dir $@)
|
|
$(OBJCOPY) -O ihex -R .eeprom $< $@
|
|
@$(ECHO)
|
|
$(call avr_size,$<,$@)
|
|
ifneq ($(strip $(HEX_MAXIMUM_SIZE)),)
|
|
@if [ `$(SIZE) $@ | awk 'FNR == 2 {print $$2}'` -le $(HEX_MAXIMUM_SIZE) ]; then touch $@.sizeok; fi
|
|
else
|
|
@$(ECHO) Maximum flash memory of $(BOARD_TAG) is not specified. Make sure the size of $@ is less than $(BOARD_TAG)\'s flash memory
|
|
@touch $@.sizeok
|
|
endif
|
|
|
|
$(OBJDIR)/%.eep: $(OBJDIR)/%.elf $(COMMON_DEPS)
|
|
@$(MKDIR) $(dir $@)
|
|
-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
|
|
--change-section-lma .eeprom=0 -O ihex $< $@
|
|
|
|
$(OBJDIR)/%.lss: $(OBJDIR)/%.elf $(COMMON_DEPS)
|
|
@$(MKDIR) $(dir $@)
|
|
$(OBJDUMP) -h --source --demangle --wide $< > $@
|
|
|
|
$(OBJDIR)/%.sym: $(OBJDIR)/%.elf $(COMMON_DEPS)
|
|
@$(MKDIR) $(dir $@)
|
|
$(NM) --size-sort --demangle --reverse-sort --line-numbers $< > $@
|
|
|
|
########################################################################
|
|
# Avrdude
|
|
|
|
# If avrdude is installed separately, it can find its own config file
|
|
ifndef AVRDUDE
|
|
AVRDUDE = $(AVR_TOOLS_PATH)/avrdude
|
|
endif
|
|
|
|
# Default avrdude options
|
|
# -V Do not verify
|
|
# -q - suppress progress output
|
|
# -D - Disable auto erase for flash memory
|
|
# (-D is needed for Mega boards. See https://github.com/sudar/Arduino-Makefile/issues/114#issuecomment-25011005)
|
|
ifndef AVRDUDE_OPTS
|
|
AVRDUDE_OPTS = -q -V -D
|
|
endif
|
|
|
|
AVRDUDE_COM_OPTS = $(AVRDUDE_OPTS) -p $(MCU)
|
|
ifdef AVRDUDE_CONF
|
|
AVRDUDE_COM_OPTS += -C $(AVRDUDE_CONF)
|
|
endif
|
|
|
|
AVRDUDE_ARD_OPTS = -c $(AVRDUDE_ARD_PROGRAMMER) -b $(AVRDUDE_ARD_BAUDRATE) -P $(call get_monitor_port)
|
|
|
|
ifndef ISP_PROG
|
|
ifneq ($(strip $(AVRDUDE_ARD_PROGRAMMER)),)
|
|
ISP_PROG = $(AVRDUDE_ARD_PROGRAMMER)
|
|
else
|
|
ISP_PROG = stk500v1
|
|
endif
|
|
endif
|
|
|
|
ifndef AVRDUDE_ISP_BAUDRATE
|
|
ifneq ($(strip $(AVRDUDE_ARD_BAUDRATE)),)
|
|
AVRDUDE_ISP_BAUDRATE = $(AVRDUDE_ARD_BAUDRATE)
|
|
else
|
|
AVRDUDE_ISP_BAUDRATE = 19200
|
|
endif
|
|
endif
|
|
|
|
# Fuse settings copied from Arduino IDE.
|
|
# https://github.com/arduino/Arduino/blob/master/app/src/processing/app/debug/AvrdudeUploader.java#L254
|
|
|
|
# Pre fuse settings
|
|
ifndef AVRDUDE_ISP_FUSES_PRE
|
|
ifneq ($(strip $(ISP_LOCK_FUSE_PRE)),)
|
|
AVRDUDE_ISP_FUSES_PRE += -U lock:w:$(ISP_LOCK_FUSE_PRE):m
|
|
endif
|
|
|
|
ifneq ($(strip $(ISP_EXT_FUSE)),)
|
|
AVRDUDE_ISP_FUSES_PRE += -U efuse:w:$(ISP_EXT_FUSE):m
|
|
endif
|
|
|
|
ifneq ($(strip $(ISP_HIGH_FUSE)),)
|
|
AVRDUDE_ISP_FUSES_PRE += -U hfuse:w:$(ISP_HIGH_FUSE):m
|
|
endif
|
|
|
|
ifneq ($(strip $(ISP_LOW_FUSE)),)
|
|
AVRDUDE_ISP_FUSES_PRE += -U lfuse:w:$(ISP_LOW_FUSE):m
|
|
endif
|
|
endif
|
|
|
|
# Bootloader file settings
|
|
# TODO: Handle relative bootloader file path as well
|
|
ifndef AVRDUDE_ISP_BURN_BOOTLOADER
|
|
ifneq ($(strip $(BOOTLOADER_PATH)),)
|
|
ifneq ($(strip $(BOOTLOADER_FILE)),)
|
|
AVRDUDE_ISP_BURN_BOOTLOADER += -U flash:w:$(BOOTLOADER_PATH)/$(BOOTLOADER_FILE):i
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# Post fuse settings
|
|
ifndef AVRDUDE_ISP_FUSES_POST
|
|
ifneq ($(strip $(ISP_LOCK_FUSE_POST)),)
|
|
AVRDUDE_ISP_FUSES_POST += -U lock:w:$(ISP_LOCK_FUSE_POST):m
|
|
endif
|
|
endif
|
|
|
|
AVRDUDE_ISP_OPTS = -c $(ISP_PROG) -b $(AVRDUDE_ISP_BAUDRATE)
|
|
|
|
ifneq ($(strip $(ISP_PROG)),usbasp)
|
|
AVRDUDE_ISP_OPTS += -P $(call get_isp_port)
|
|
endif
|
|
|
|
ifndef ISP_EEPROM
|
|
ISP_EEPROM = 0
|
|
endif
|
|
|
|
AVRDUDE_UPLOAD_HEX = -U flash:w:$(TARGET_HEX):i
|
|
AVRDUDE_UPLOAD_EEP = -U eeprom:w:$(TARGET_EEP):i
|
|
AVRDUDE_ISPLOAD_OPTS = $(AVRDUDE_UPLOAD_HEX)
|
|
|
|
ifneq ($(ISP_EEPROM), 0)
|
|
AVRDUDE_ISPLOAD_OPTS += $(AVRDUDE_UPLOAD_EEP)
|
|
endif
|
|
|
|
########################################################################
|
|
# Explicit targets start here
|
|
|
|
all: $(TARGET_EEP) $(TARGET_HEX)
|
|
|
|
# Rule to create $(OBJDIR) automatically. All rules with recipes that
|
|
# create a file within it, but do not already depend on a file within it
|
|
# should depend on this rule. They should use a "order-only
|
|
# prerequisite" (e.g., put "| $(OBJDIR)" at the end of the prerequisite
|
|
# list) to prevent remaking the target when any file in the directory
|
|
# changes.
|
|
$(OBJDIR):
|
|
$(MKDIR) $(OBJDIR)
|
|
|
|
$(TARGET_ELF): $(LOCAL_OBJS) $(CORE_LIB) $(OTHER_OBJS)
|
|
$(CC) $(LDFLAGS) -o $@ $(LOCAL_OBJS) $(CORE_LIB) $(OTHER_OBJS) -lc -lm
|
|
|
|
$(CORE_LIB): $(CORE_OBJS) $(LIB_OBJS) $(USER_LIB_OBJS)
|
|
$(AR) rcs $@ $(CORE_OBJS) $(LIB_OBJS) $(USER_LIB_OBJS)
|
|
|
|
error_on_caterina:
|
|
$(ERROR_ON_CATERINA)
|
|
|
|
# Use submake so we can guarantee the reset happens
|
|
# before the upload, even with make -j
|
|
upload: $(TARGET_HEX) verify_size
|
|
$(MAKE) reset
|
|
$(MAKE) do_upload
|
|
|
|
raw_upload: $(TARGET_HEX) verify_size
|
|
$(MAKE) error_on_caterina
|
|
$(MAKE) do_upload
|
|
|
|
do_upload:
|
|
$(AVRDUDE) $(AVRDUDE_COM_OPTS) $(AVRDUDE_ARD_OPTS) \
|
|
$(AVRDUDE_UPLOAD_HEX)
|
|
|
|
do_eeprom: $(TARGET_EEP) $(TARGET_HEX)
|
|
$(AVRDUDE) $(AVRDUDE_COM_OPTS) $(AVRDUDE_ARD_OPTS) \
|
|
$(AVRDUDE_UPLOAD_EEP)
|
|
|
|
eeprom: $(TARGET_HEX) verify_size
|
|
$(MAKE) reset
|
|
$(MAKE) do_eeprom
|
|
|
|
raw_eeprom: $(TARGET_HEX) verify_size
|
|
$(MAKE) error_on_caterina
|
|
$(MAKE) do_eeprom
|
|
|
|
reset:
|
|
$(call arduino_output,Resetting Arduino...)
|
|
$(RESET_CMD)
|
|
|
|
# stty on MacOS likes -F, but on Debian it likes -f redirecting
|
|
# stdin/out appears to work but generates a spurious error on MacOS at
|
|
# least. Perhaps it would be better to just do it in perl ?
|
|
reset_stty:
|
|
for STTYF in 'stty -F' 'stty --file' 'stty -f' 'stty <' ; \
|
|
do $$STTYF /dev/tty >/dev/null 2>&1 && break ; \
|
|
done ; \
|
|
$$STTYF $(call get_monitor_port) hupcl ; \
|
|
(sleep 0.1 2>/dev/null || sleep 1) ; \
|
|
$$STTYF $(call get_monitor_port) -hupcl
|
|
|
|
ispload: $(TARGET_EEP) $(TARGET_HEX) verify_size
|
|
$(AVRDUDE) $(AVRDUDE_COM_OPTS) $(AVRDUDE_ISP_OPTS) \
|
|
$(AVRDUDE_ISPLOAD_OPTS)
|
|
|
|
burn_bootloader:
|
|
ifneq ($(strip $(AVRDUDE_ISP_FUSES_PRE)),)
|
|
$(AVRDUDE) $(AVRDUDE_COM_OPTS) $(AVRDUDE_ISP_OPTS) -e $(AVRDUDE_ISP_FUSES_PRE)
|
|
endif
|
|
ifneq ($(strip $(AVRDUDE_ISP_BURN_BOOTLOADER)),)
|
|
$(AVRDUDE) $(AVRDUDE_COM_OPTS) $(AVRDUDE_ISP_OPTS) $(AVRDUDE_ISP_BURN_BOOTLOADER)
|
|
endif
|
|
ifneq ($(strip $(AVRDUDE_ISP_FUSES_POST)),)
|
|
$(AVRDUDE) $(AVRDUDE_COM_OPTS) $(AVRDUDE_ISP_OPTS) $(AVRDUDE_ISP_FUSES_POST)
|
|
endif
|
|
|
|
clean:
|
|
$(REMOVE) $(LOCAL_OBJS) $(CORE_OBJS) $(LIB_OBJS) $(CORE_LIB) $(TARGETS) $(DEPS) $(USER_LIB_OBJS) ${OBJDIR}
|
|
|
|
size: $(TARGET_HEX)
|
|
$(call avr_size,$(TARGET_ELF),$(TARGET_HEX))
|
|
|
|
show_boards:
|
|
@cat $(BOARDS_TXT) | grep -E "^[[:alnum:]]" | cut -d . -f 1 | uniq
|
|
|
|
monitor:
|
|
$(MONITOR_CMD) $(call get_monitor_port) $(MONITOR_BAUDRATE)
|
|
|
|
disasm: $(OBJDIR)/$(TARGET).lss
|
|
@$(ECHO) The compiled ELF file has been disassembled to $(OBJDIR)/$(TARGET).lss
|
|
|
|
symbol_sizes: $(OBJDIR)/$(TARGET).sym
|
|
@$(ECHO) A symbol listing sorted by their size have been dumped to $(OBJDIR)/$(TARGET).sym
|
|
|
|
verify_size:
|
|
ifeq ($(strip $(HEX_MAXIMUM_SIZE)),)
|
|
@$(ECHO)
|
|
@$(ECHO) Maximum flash memory of $(BOARD_TAG) is not specified. Make sure the size of $(TARGET_HEX) is less than $(BOARD_TAG)\'s flash memory
|
|
@$(ECHO)
|
|
endif
|
|
@if [ ! -f $(TARGET_HEX).sizeok ]; then echo >&2 "\nThe size of the compiled binary file is greater than the $(BOARD_TAG)'s flash memory. \
|
|
See http://www.arduino.cc/en/Guide/Troubleshooting#size for tips on reducing it."; false; fi
|
|
|
|
generate_assembly: $(OBJDIR)/$(TARGET).s
|
|
@$(ECHO) Compiler-generated assembly for the main input source has been dumped to $(OBJDIR)/$(TARGET).s
|
|
|
|
generated_assembly: generate_assembly
|
|
@$(ECHO) "generated_assembly" target is deprecated. Use "generate_assembly" target instead
|
|
|
|
help:
|
|
@$(ECHO) "\nAvailable targets:\n\
|
|
make - no upload\n\
|
|
make upload - upload\n\
|
|
make clean - remove all our dependencies\n\
|
|
make depends - update dependencies\n\
|
|
make reset - reset the Arduino by tickling DTR on the serial port\n\
|
|
make raw_upload - upload without first resetting\n\
|
|
make show_boards - list all the boards defined in boards.txt\n\
|
|
make monitor - connect to the Arduino's serial port\n\
|
|
make size - show the size of the compiled output (relative to\n\
|
|
resources, if you have a patched avr-size)\n\
|
|
make disasm - generate a .lss file in build-cli that contains\n\
|
|
disassembly of the compiled file interspersed\n\
|
|
with your original source code.\n\
|
|
make verify_size - Verify that the size of the final file is less than\n\
|
|
the capacity of the micro controller.\n\
|
|
make eeprom - upload the eep file\n\
|
|
make raw_eeprom - upload the eep file without first resetting\n\
|
|
make burn_bootloader - Burn bootloader and/or fuses\n\
|
|
make help - show this help\n\
|
|
"
|
|
@$(ECHO) "Please refer to $(ARDMK_FILE) for more details."
|
|
|
|
.PHONY: all upload raw_upload raw_eeprom error_on_caterina reset reset_stty ispload \
|
|
clean depends size show_boards monitor disasm symbol_sizes generated_assembly \
|
|
generate_assembly verify_size burn_bootloader help
|
|
|
|
# added - in the beginning, so that we don't get an error if the file is not present
|
|
-include $(DEPS)
|