mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-04-14 10:07:39 +08:00
9f391b1867
In the upstream tree ringbuffer.h includes the method implementations in the header file which causes multiple definitions in the link for other targets. Changed so ringbuffer.cpp is build separately for other platforms and is included by ringbuffer.h on NuttX. uORB changes do not link without uORBTest_UnitTest.cpp enabled for the NuttX build. px4_getopt was not exported and wasn't visible in NuttX build. The makefiles were restored to be as close as possible to upstream so the NuttX build builtin's work again. The code will have to be refactored after the merge. Signed-off-by: Mark Charlebois <charlebm@gmail.com>
559 lines
18 KiB
Makefile
559 lines
18 KiB
Makefile
#
|
|
# Copyright (C) 2012 PX4 Development Team. All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
#
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in
|
|
# the documentation and/or other materials provided with the
|
|
# distribution.
|
|
# 3. Neither the name PX4 nor the names of its contributors may be
|
|
# used to endorse or promote products derived from this software
|
|
# without specific prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
|
|
#
|
|
# Generic Makefile for PX4 firmware images.
|
|
#
|
|
# Requires:
|
|
#
|
|
# BOARD
|
|
# Must be set to a board name known to the PX4 distribution (as
|
|
# we need a corresponding NuttX export archive to link with).
|
|
#
|
|
# Optional:
|
|
#
|
|
# MODULES
|
|
# Contains a list of module paths or path fragments used
|
|
# to find modules. The names listed here are searched in
|
|
# the following directories:
|
|
# <absolute path>
|
|
# $(MODULE_SEARCH_DIRS)
|
|
# WORK_DIR
|
|
# MODULE_SRC
|
|
# PX4_MODULE_SRC
|
|
#
|
|
# Application directories are expected to contain a module.mk
|
|
# file which provides build configuration for the module. See
|
|
# makefiles/module.mk for more details.
|
|
#
|
|
# BUILTIN_COMMANDS
|
|
# Contains a list of built-in commands not explicitly provided
|
|
# by modules / libraries. Each entry in this list is formatted
|
|
# as <command>.<priority>.<stacksize>.<entrypoint>
|
|
#
|
|
# PX4_BASE:
|
|
# Points to a PX4 distribution. Normally determined based on the
|
|
# path to this file.
|
|
#
|
|
# CONFIG:
|
|
# Used when searching for the configuration file, and available
|
|
# to module Makefiles to select optional features.
|
|
# If not set, CONFIG_FILE must be set and CONFIG will be derived
|
|
# automatically from it.
|
|
#
|
|
# CONFIG_FILE:
|
|
# If set, overrides the configuration file search logic. Sets
|
|
# CONFIG to the name of the configuration file, strips any
|
|
# leading config_ prefix and any suffix. e.g. config_board_foo.mk
|
|
# results in CONFIG being set to 'board_foo'.
|
|
#
|
|
# WORK_DIR:
|
|
# Sets the directory in which the firmware will be built. Defaults
|
|
# to the directory 'build' under the directory containing the
|
|
# parent Makefile.
|
|
#
|
|
# ROMFS_ROOT:
|
|
# If set to the path to a directory, a ROMFS image will be generated
|
|
# containing the files under the directory and linked into the final
|
|
# image.
|
|
#
|
|
# MODULE_SEARCH_DIRS:
|
|
# Extra directories to search first for MODULES before looking in the
|
|
# usual places.
|
|
#
|
|
|
|
################################################################################
|
|
# Paths and configuration
|
|
################################################################################
|
|
|
|
#
|
|
# Work out where this file is, so we can find other makefiles in the
|
|
# same directory.
|
|
#
|
|
# If PX4_BASE wasn't set previously, work out what it should be
|
|
# and set it here now.
|
|
#
|
|
MK_DIR ?= $(dir $(lastword $(MAKEFILE_LIST)))
|
|
ifeq ($(PX4_BASE),)
|
|
export PX4_BASE := $(abspath $(MK_DIR)/..)
|
|
endif
|
|
$(info % PX4_BASE = $(PX4_BASE))
|
|
ifneq ($(words $(PX4_BASE)),1)
|
|
$(error Cannot build when the PX4_BASE path contains one or more space characters.)
|
|
endif
|
|
|
|
$(info % GIT_DESC = $(GIT_DESC))
|
|
|
|
#
|
|
# Set a default target so that included makefiles or errors here don't
|
|
# cause confusion.
|
|
#
|
|
# XXX We could do something cute here with $(DEFAULT_GOAL) if it's not one
|
|
# of the maintenance targets and set CONFIG based on it.
|
|
#
|
|
all: firmware
|
|
|
|
#
|
|
# Get path and tool config
|
|
#
|
|
include $(MK_DIR)/setup.mk
|
|
|
|
#
|
|
# Locate the configuration file
|
|
#
|
|
ifneq ($(CONFIG_FILE),)
|
|
CONFIG := $(subst config_,,$(basename $(notdir $(CONFIG_FILE))))
|
|
else
|
|
CONFIG_FILE := $(wildcard $(PX4_MK_DIR)/$(PX4_TARGET_OS)/config_$(CONFIG).mk)
|
|
endif
|
|
ifeq ($(CONFIG),)
|
|
$(error Missing configuration name or file (specify with CONFIG=<config>))
|
|
endif
|
|
export CONFIG
|
|
include $(CONFIG_FILE)
|
|
$(info % CONFIG = $(CONFIG))
|
|
|
|
#
|
|
# Sanity-check the BOARD variable and then get the board config.
|
|
# If BOARD was not set by the configuration, extract it automatically.
|
|
#
|
|
# The board config in turn will fetch the toolchain configuration.
|
|
#
|
|
ifeq ($(BOARD),)
|
|
BOARD := $(firstword $(subst _, ,$(CONFIG)))
|
|
endif
|
|
BOARD_FILE := $(wildcard $(PX4_MK_DIR)/$(PX4_TARGET_OS)/board_$(BOARD).mk)
|
|
ifeq ($(BOARD_FILE),)
|
|
$(error Config $(CONFIG) references board $(BOARD), but no board definition file found)
|
|
endif
|
|
export BOARD
|
|
export BOARD_FILE
|
|
include $(BOARD_FILE)
|
|
$(info % BOARD = $(BOARD))
|
|
|
|
#
|
|
# If WORK_DIR is not set, create a 'build' directory next to the
|
|
# parent Makefile.
|
|
#
|
|
PARENT_MAKEFILE := $(lastword $(filter-out $(lastword $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
|
|
ifeq ($(WORK_DIR),)
|
|
export WORK_DIR := $(dir $(PARENT_MAKEFILE))build/
|
|
endif
|
|
$(info % WORK_DIR = $(WORK_DIR))
|
|
|
|
#
|
|
# Things that, if they change, might affect everything
|
|
#
|
|
GLOBAL_DEPS += $(MAKEFILE_LIST)
|
|
|
|
#
|
|
# Extra things we should clean
|
|
#
|
|
EXTRA_CLEANS =
|
|
|
|
|
|
#
|
|
# Append the per-board driver directory to the header search path.
|
|
#
|
|
INCLUDE_DIRS += $(PX4_MODULE_SRC)drivers/boards/$(BOARD)
|
|
|
|
################################################################################
|
|
# OS specific libraries and paths
|
|
################################################################################
|
|
|
|
include $(PX4_MK_DIR)/$(PX4_TARGET_OS).mk
|
|
|
|
################################################################################
|
|
# Modules
|
|
################################################################################
|
|
|
|
# where to look for modules
|
|
MODULE_SEARCH_DIRS += $(WORK_DIR) $(MODULE_SRC) $(PX4_MODULE_SRC)
|
|
|
|
# sort and unique the modules list
|
|
MODULES := $(sort $(MODULES))
|
|
|
|
# locate the first instance of a module by full path or by looking on the
|
|
# module search path
|
|
define MODULE_SEARCH
|
|
$(firstword $(abspath $(wildcard $(1)/module.mk)) \
|
|
$(abspath $(foreach search_dir,$(MODULE_SEARCH_DIRS),$(wildcard $(search_dir)/$(1)/module.mk))) \
|
|
MISSING_$1)
|
|
endef
|
|
|
|
# make a list of module makefiles and check that we found them all
|
|
MODULE_MKFILES := $(foreach module,$(MODULES),$(call MODULE_SEARCH,$(module)))
|
|
MISSING_MODULES := $(subst MISSING_,,$(filter MISSING_%,$(MODULE_MKFILES)))
|
|
ifneq ($(MISSING_MODULES),)
|
|
$(error Cant find module(s): $(MISSING_MODULES))
|
|
endif
|
|
|
|
# Make a list of the object files we expect to build from modules
|
|
# Note that this path will typically contain a double-slash at the WORK_DIR boundary; this must be
|
|
# preserved as it is used below to get the absolute path for the module.mk file correct.
|
|
#
|
|
MODULE_OBJS := $(foreach path,$(dir $(MODULE_MKFILES)),$(WORK_DIR)$(path)module.pre.o)
|
|
|
|
# rules to build module objects
|
|
.PHONY: $(MODULE_OBJS)
|
|
$(MODULE_OBJS): relpath = $(patsubst $(WORK_DIR)%,%,$@)
|
|
$(MODULE_OBJS): mkfile = $(patsubst %module.pre.o,%module.mk,$(relpath))
|
|
$(MODULE_OBJS): workdir = $(@D)
|
|
$(MODULE_OBJS): $(GLOBAL_DEPS) $(NUTTX_CONFIG_HEADER)
|
|
$(Q) $(MKDIR) -p $(workdir)
|
|
$(Q) $(MAKE) -r -f $(PX4_MK_DIR)module.mk \
|
|
-C $(workdir) \
|
|
MODULE_WORK_DIR=$(workdir) \
|
|
MODULE_OBJ=$@ \
|
|
MODULE_MK=$(mkfile) \
|
|
MODULE_NAME=$(lastword $(subst /, ,$(workdir))) \
|
|
module
|
|
|
|
# make a list of phony clean targets for modules
|
|
MODULE_CLEANS := $(foreach path,$(dir $(MODULE_MKFILES)),$(WORK_DIR)$(path)/clean)
|
|
|
|
# rules to clean modules
|
|
.PHONY: $(MODULE_CLEANS)
|
|
$(MODULE_CLEANS): relpath = $(patsubst $(WORK_DIR)%,%,$@)
|
|
$(MODULE_CLEANS): mkfile = $(patsubst %clean,%module.mk,$(relpath))
|
|
$(MODULE_CLEANS):
|
|
@$(ECHO) %% cleaning using $(mkfile)
|
|
$(Q) $(MAKE) -r -f $(PX4_MK_DIR)module.mk \
|
|
MODULE_WORK_DIR=$(dir $@) \
|
|
MODULE_MK=$(mkfile) \
|
|
clean
|
|
|
|
################################################################################
|
|
# Libraries
|
|
################################################################################
|
|
|
|
# where to look for libraries
|
|
LIBRARY_SEARCH_DIRS += $(WORK_DIR) $(MODULE_SRC) $(PX4_MODULE_SRC)
|
|
|
|
# sort and unique the library list
|
|
LIBRARIES := $(sort $(LIBRARIES))
|
|
|
|
# locate the first instance of a library by full path or by looking on the
|
|
# library search path
|
|
define LIBRARY_SEARCH
|
|
$(firstword $(abspath $(wildcard $(1)/library.mk)) \
|
|
$(abspath $(foreach search_dir,$(LIBRARY_SEARCH_DIRS),$(wildcard $(search_dir)/$(1)/library.mk))) \
|
|
MISSING_$1)
|
|
endef
|
|
|
|
# make a list of library makefiles and check that we found them all
|
|
LIBRARY_MKFILES := $(foreach library,$(LIBRARIES),$(call LIBRARY_SEARCH,$(library)))
|
|
MISSING_LIBRARIES := $(subst MISSING_,,$(filter MISSING_%,$(LIBRARY_MKFILES)))
|
|
ifneq ($(MISSING_LIBRARIES),)
|
|
$(error Cant find library(s): $(MISSING_LIBRARIES))
|
|
endif
|
|
|
|
# Make a list of the archive files we expect to build from libraries
|
|
# Note that this path will typically contain a double-slash at the WORK_DIR boundary; this must be
|
|
# preserved as it is used below to get the absolute path for the library.mk file correct.
|
|
#
|
|
LIBRARY_LIBS := $(foreach path,$(dir $(LIBRARY_MKFILES)),$(WORK_DIR)$(path)library.a)
|
|
|
|
# rules to build module objects
|
|
.PHONY: $(LIBRARY_LIBS)
|
|
$(LIBRARY_LIBS): relpath = $(patsubst $(WORK_DIR)%,%,$@)
|
|
$(LIBRARY_LIBS): mkfile = $(patsubst %library.a,%library.mk,$(relpath))
|
|
$(LIBRARY_LIBS): workdir = $(@D)
|
|
$(LIBRARY_LIBS): $(GLOBAL_DEPS) $(NUTTX_CONFIG_HEADER)
|
|
$(Q) $(MKDIR) -p $(workdir)
|
|
$(Q) $(MAKE) -r -f $(PX4_MK_DIR)library.mk \
|
|
-C $(workdir) \
|
|
LIBRARY_WORK_DIR=$(workdir) \
|
|
LIBRARY_LIB=$@ \
|
|
LIBRARY_MK=$(mkfile) \
|
|
LIBRARY_NAME=$(lastword $(subst /, ,$(workdir))) \
|
|
library
|
|
|
|
# make a list of phony clean targets for modules
|
|
LIBRARY_CLEANS := $(foreach path,$(dir $(LIBRARY_MKFILES)),$(WORK_DIR)$(path)/clean)
|
|
|
|
# rules to clean modules
|
|
.PHONY: $(LIBRARY_CLEANS)
|
|
$(LIBRARY_CLEANS): relpath = $(patsubst $(WORK_DIR)%,%,$@)
|
|
$(LIBRARY_CLEANS): mkfile = $(patsubst %clean,%library.mk,$(relpath))
|
|
$(LIBRARY_CLEANS):
|
|
@$(ECHO) %% cleaning using $(mkfile)
|
|
$(Q) $(MAKE) -r -f $(PX4_MK_DIR)library.mk \
|
|
LIBRARY_WORK_DIR=$(dir $@) \
|
|
LIBRARY_MK=$(mkfile) \
|
|
clean
|
|
|
|
ifeq ($(PX4_TARGET_OS),nuttx)
|
|
################################################################################
|
|
# ROMFS generation
|
|
################################################################################
|
|
|
|
ifneq ($(ROMFS_ROOT),)
|
|
ifeq ($(wildcard $(ROMFS_ROOT)),)
|
|
$(error ROMFS_ROOT specifies a directory that does not exist)
|
|
endif
|
|
|
|
#
|
|
# Note that there is no support for more than one root directory or constructing
|
|
# a root from several templates. That would be a nice feature.
|
|
#
|
|
|
|
# Add dependencies on anything in the ROMFS root directory
|
|
ROMFS_FILES += $(wildcard \
|
|
$(ROMFS_ROOT)/* \
|
|
$(ROMFS_ROOT)/*/* \
|
|
$(ROMFS_ROOT)/*/*/* \
|
|
$(ROMFS_ROOT)/*/*/*/* \
|
|
$(ROMFS_ROOT)/*/*/*/*/* \
|
|
$(ROMFS_ROOT)/*/*/*/*/*/*)
|
|
ifeq ($(ROMFS_FILES),)
|
|
$(error ROMFS_ROOT $(ROMFS_ROOT) specifies a directory containing no files)
|
|
endif
|
|
ROMFS_DEPS += $(ROMFS_FILES)
|
|
|
|
# Extra files that may be copied into the ROMFS /extras directory
|
|
# ROMFS_EXTRA_FILES are required, ROMFS_OPTIONAL_FILES are optional
|
|
ROMFS_EXTRA_FILES += $(wildcard $(ROMFS_OPTIONAL_FILES))
|
|
ROMFS_DEPS += $(ROMFS_EXTRA_FILES)
|
|
|
|
ROMFS_IMG = romfs.img
|
|
ROMFS_SCRATCH = romfs_scratch
|
|
ROMFS_CSRC = $(ROMFS_IMG:.img=.c)
|
|
ROMFS_OBJ = $(ROMFS_CSRC:.c=.o)
|
|
LIBS += $(ROMFS_OBJ)
|
|
LINK_DEPS += $(ROMFS_OBJ)
|
|
|
|
# Remove all comments from startup and mixer files
|
|
ROMFS_PRUNER = $(PX4_BASE)/Tools/px_romfs_pruner.py
|
|
|
|
# Turn the ROMFS image into an object file
|
|
$(ROMFS_OBJ): $(ROMFS_IMG) $(GLOBAL_DEPS)
|
|
$(call BIN_TO_OBJ,$<,$@,romfs_img)
|
|
|
|
# Generate the ROMFS image from the root
|
|
$(ROMFS_IMG): $(ROMFS_SCRATCH) $(ROMFS_DEPS) $(GLOBAL_DEPS)
|
|
@$(ECHO) "ROMFS: $@"
|
|
$(Q) $(GENROMFS) -f $@ -d $(ROMFS_SCRATCH) -V "NSHInitVol"
|
|
|
|
# Construct the ROMFS scratch root from the canonical root
|
|
$(ROMFS_SCRATCH): $(ROMFS_DEPS) $(GLOBAL_DEPS)
|
|
$(Q) $(MKDIR) -p $(ROMFS_SCRATCH)
|
|
$(Q) $(COPYDIR) $(ROMFS_ROOT)/* $(ROMFS_SCRATCH)
|
|
# delete all files in ROMFS_SCRATCH which start with a . or end with a ~
|
|
$(Q) $(RM) $(ROMFS_SCRATCH)/*/.[!.]* $(ROMFS_SCRATCH)/*/*~
|
|
ifneq ($(ROMFS_EXTRA_FILES),)
|
|
$(Q) $(MKDIR) -p $(ROMFS_SCRATCH)/extras
|
|
$(Q) $(COPY) $(ROMFS_EXTRA_FILES) $(ROMFS_SCRATCH)/extras
|
|
endif
|
|
$(Q) $(PYTHON) -u $(ROMFS_PRUNER) --folder $(ROMFS_SCRATCH)
|
|
|
|
EXTRA_CLEANS += $(ROMGS_OBJ) $(ROMFS_IMG)
|
|
|
|
endif
|
|
|
|
################################################################################
|
|
# Builtin command list generation
|
|
################################################################################
|
|
|
|
#
|
|
# Builtin commands can be generated by the configuration, in which case they
|
|
# must refer to commands that already exist, or indirectly generated by modules
|
|
# when they are built.
|
|
#
|
|
# The configuration supplies builtin command information in the BUILTIN_COMMANDS
|
|
# variable. Applications make empty files in $(WORK_DIR)/builtin_commands whose
|
|
# filename contains the same information.
|
|
#
|
|
# In each case, the command information consists of four fields separated with a
|
|
# period. These fields are the command's name, its thread priority, its stack size
|
|
# and the name of the function to call when starting the thread.
|
|
#
|
|
BUILTIN_CSRC = $(WORK_DIR)builtin_commands.c
|
|
|
|
# command definitions from modules (may be empty at Makefile parsing time...)
|
|
MODULE_COMMANDS = $(subst COMMAND.,,$(notdir $(wildcard $(WORK_DIR)builtin_commands/COMMAND.*)))
|
|
|
|
# We must have at least one pre-defined builtin command in order to generate
|
|
# any of this.
|
|
#
|
|
ifneq ($(BUILTIN_COMMANDS),)
|
|
|
|
# (BUILTIN_PROTO,<cmdspec>,<outputfile>)
|
|
define BUILTIN_PROTO
|
|
$(ECHO) 'extern int $(word 4,$1)(int argc, char *argv[]);' >> $2;
|
|
endef
|
|
|
|
# (BUILTIN_DEF,<cmdspec>,<outputfile>)
|
|
define BUILTIN_DEF
|
|
$(ECHO) ' {"$(word 1,$1)", $(word 2,$1), $(word 3,$1), $(word 4,$1)},' >> $2;
|
|
endef
|
|
|
|
# Don't generate until modules have updated their command files
|
|
$(BUILTIN_CSRC): $(GLOBAL_DEPS) $(MODULE_OBJS) $(MODULE_MKFILES) $(BUILTIN_COMMAND_FILES)
|
|
@$(ECHO) "CMDS: $@"
|
|
$(Q) $(ECHO) '/* builtin command list - automatically generated, do not edit */' > $@
|
|
$(Q) $(ECHO) '#include <nuttx/config.h>' >> $@
|
|
$(Q) $(ECHO) '#include <nuttx/binfmt/builtin.h>' >> $@
|
|
$(Q) $(foreach spec,$(BUILTIN_COMMANDS),$(call BUILTIN_PROTO,$(subst ., ,$(spec)),$@))
|
|
$(Q) $(foreach spec,$(MODULE_COMMANDS),$(call BUILTIN_PROTO,$(subst ., ,$(spec)),$@))
|
|
$(Q) $(ECHO) 'const struct builtin_s g_builtins[] = {' >> $@
|
|
$(Q) $(foreach spec,$(BUILTIN_COMMANDS),$(call BUILTIN_DEF,$(subst ., ,$(spec)),$@))
|
|
$(Q) $(foreach spec,$(MODULE_COMMANDS),$(call BUILTIN_DEF,$(subst ., ,$(spec)),$@))
|
|
$(Q) $(ECHO) ' {NULL, 0, 0, NULL}' >> $@
|
|
$(Q) $(ECHO) '};' >> $@
|
|
$(Q) $(ECHO) 'const int g_builtin_count = $(words $(BUILTIN_COMMANDS) $(MODULE_COMMANDS));' >> $@
|
|
|
|
SRCS += $(BUILTIN_CSRC)
|
|
|
|
EXTRA_CLEANS += $(BUILTIN_CSRC)
|
|
|
|
endif
|
|
endif
|
|
|
|
################################################################################
|
|
# Default SRCS generation
|
|
################################################################################
|
|
|
|
#
|
|
# If there are no SRCS, the build will fail; in that case, generate an empty
|
|
# source file.
|
|
#
|
|
ifeq ($(SRCS),)
|
|
EMPTY_SRC = $(WORK_DIR)empty.c
|
|
$(EMPTY_SRC):
|
|
$(Q) $(ECHO) '/* this is an empty file */' > $@
|
|
|
|
SRCS += $(EMPTY_SRC)
|
|
endif
|
|
|
|
################################################################################
|
|
# Build rules
|
|
################################################################################
|
|
|
|
ifeq ($(PX4_TARGET_OS),nuttx)
|
|
#
|
|
# What we're going to build.
|
|
#
|
|
PRODUCT_BUNDLE = $(WORK_DIR)firmware.px4
|
|
PRODUCT_BIN = $(WORK_DIR)firmware.bin
|
|
PRODUCT_ELF = $(WORK_DIR)firmware.elf
|
|
PRODUCT_PARAMXML = $(WORK_DIR)/parameters.xml
|
|
|
|
.PHONY: firmware
|
|
firmware: $(PRODUCT_BUNDLE)
|
|
endif
|
|
|
|
#
|
|
# Object files we will generate from sources
|
|
#
|
|
OBJS := $(foreach src,$(SRCS),$(WORK_DIR)$(src).o)
|
|
|
|
#
|
|
# SRCS -> OBJS rules
|
|
#
|
|
|
|
$(OBJS): $(GLOBAL_DEPS)
|
|
|
|
$(filter %.c.o,$(OBJS)): $(WORK_DIR)%.c.o: %.c $(GLOBAL_DEPS)
|
|
$(call COMPILE,$<,$@)
|
|
|
|
$(filter %.cpp.o,$(OBJS)): $(WORK_DIR)%.cpp.o: %.cpp $(GLOBAL_DEPS)
|
|
$(call COMPILEXX,$<,$@)
|
|
|
|
$(filter %.S.o,$(OBJS)): $(WORK_DIR)%.S.o: %.S $(GLOBAL_DEPS)
|
|
$(call ASSEMBLE,$<,$@)
|
|
|
|
ifeq ($(PX4_TARGET_OS),nuttx)
|
|
#
|
|
# Built product rules
|
|
#
|
|
|
|
$(PRODUCT_BUNDLE): $(PRODUCT_BIN)
|
|
@$(ECHO) %% Generating $@
|
|
ifdef GEN_PARAM_XML
|
|
$(Q) $(PYTHON) $(PX4_BASE)/Tools/px_process_params.py --src-path $(PX4_BASE)/src --board CONFIG_ARCH_BOARD_$(CONFIG_BOARD) --xml
|
|
$(Q) $(MKFW) --prototype $(IMAGE_DIR)/$(BOARD).prototype \
|
|
--git_identity $(PX4_BASE) \
|
|
--parameter_xml $(PRODUCT_PARAMXML) \
|
|
--image $< > $@
|
|
else
|
|
$(Q) $(MKFW) --prototype $(IMAGE_DIR)/$(BOARD).prototype \
|
|
--git_identity $(PX4_BASE) \
|
|
--image $< > $@
|
|
endif
|
|
|
|
$(PRODUCT_BIN): $(PRODUCT_ELF)
|
|
$(call SYM_TO_BIN,$<,$@)
|
|
|
|
$(PRODUCT_ELF): $(OBJS) $(MODULE_OBJS) $(LIBRARY_LIBS) $(GLOBAL_DEPS) $(LINK_DEPS) $(MODULE_MKFILES)
|
|
$(call LINK,$@,$(OBJS) $(MODULE_OBJS) $(LIBRARY_LIBS))
|
|
|
|
#
|
|
# Utility rules
|
|
#
|
|
|
|
.PHONY: upload
|
|
upload: $(PRODUCT_BUNDLE) $(PRODUCT_BIN)
|
|
$(Q) $(MAKE) -f $(PX4_MK_DIR)/upload.mk \
|
|
METHOD=serial \
|
|
CONFIG=$(CONFIG) \
|
|
BOARD=$(BOARD) \
|
|
BUNDLE=$(PRODUCT_BUNDLE) \
|
|
BIN=$(PRODUCT_BIN)
|
|
|
|
.PHONY: clean
|
|
clean: $(MODULE_CLEANS)
|
|
@$(ECHO) %% cleaning
|
|
$(Q) $(REMOVE) $(PRODUCT_BUNDLE) $(PRODUCT_BIN) $(PRODUCT_ELF)
|
|
$(Q) $(REMOVE) $(OBJS) $(DEP_INCLUDES) $(EXTRA_CLEANS)
|
|
$(Q) $(RMDIR) $(NUTTX_EXPORT_DIR)
|
|
endif
|
|
|
|
# Include the OS specific build rules
|
|
# The rules must define the "firmware" make target
|
|
#
|
|
|
|
ifeq ($(PX4_TARGET_OS),nuttx)
|
|
# TODO
|
|
# Move above nuttx specific rules to $(MK_DIR)/nuttx_romfs.mk
|
|
endif
|
|
ifeq ($(PX4_TARGET_OS),posix)
|
|
include $(MK_DIR)/posix_elf.mk
|
|
endif
|
|
ifeq ($(PX4_TARGET_OS),qurt)
|
|
include $(MK_DIR)/qurt_elf.mk
|
|
endif
|
|
|
|
#
|
|
# DEP_INCLUDES is defined by the toolchain include in terms of $(OBJS)
|
|
#
|
|
-include $(DEP_INCLUDES)
|