env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"), target_elf))
elif "nrfjprog" == upload_protocol:
target_firm = env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"),
target_elf)
elif "sam-ba" == upload_protocol:
target_firm = env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"),
target_elf)
else:
if "DFUBOOTHEX" in env:
target_firm = env.SignBin(
join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"), target_elf))
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"),
target_elf)
env.Depends(target_firm, "checkprogsize")
AlwaysBuild(env.Alias("nobuild", target_firm))
target_buildprog = env.Alias("buildprog", target_firm, target_firm)
if "DFUBOOTHEX" in env:
env.Append(
# Check the linker script for the correct location
BOOT_SETTING_ADDR=board.get("build.bootloader.settings_addr",
"0x7F000"))
env.AddPlatformTarget(
"dfu",
env.PackageDfu(
join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"), target_elf),
for d in flatten_cppdefines:
if str(d).startswith("VTABLES_IN_"):
current_vtables = d
if not current_vtables:
current_vtables = "VTABLES_IN_FLASH"
env.Append(CPPDEFINES=[current_vtables])
assert current_vtables
# Build the eagle.app.v6.common.ld linker file
app_ld = env.Command(
join("$BUILD_DIR", "ld", "local.eagle.app.v6.common.ld"),
join(FRAMEWORK_DIR, "tools", "sdk", "ld", "eagle.app.v6.common.ld.h"),
env.VerboseAction(
"$CC -CC -E -P -D%s $SOURCE -o $TARGET" % current_vtables,
"Generating LD script $TARGET"))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", app_ld)
#
# Dynamic core_version.h for staging builds
#
def platform_txt_version(default):
with open(join(FRAMEWORK_DIR, "platform.txt"), "r") as platform_txt:
for line in platform_txt:
if not line:
continue
k, delim, v = line.partition("=")
if not delim:
continue
if k == "version":
return v.strip()
envsafe = env.Clone()
libs.append(
envsafe.BuildLibrary(
join("$BUILD_DIR", "FrameworkArduino"),
join(FRAMEWORK_DIR, "cores",
env.BoardConfig().get("build.core"))))
env.Prepend(LIBS=libs)
#
# Generate partition table
#
fwpartitions_dir = join(FRAMEWORK_DIR, "tools", "partitions")
partitions_csv = env.BoardConfig().get("build.arduino.partitions",
"default.csv")
if "build.partitions" in env.BoardConfig():
partitions_csv = env.BoardConfig().get("build.partitions")
env.Replace(PARTITIONS_TABLE_CSV=abspath(
join(fwpartitions_dir, partitions_csv) if isfile(
join(fwpartitions_dir, partitions_csv)) else partitions_csv))
partition_table = env.Command(
join("$BUILD_DIR", "partitions.bin"), "$PARTITIONS_TABLE_CSV",
env.VerboseAction(
'"$PYTHONEXE" "%s" -q $SOURCE $TARGET' %
join(FRAMEWORK_DIR, "tools", "gen_esp32part.py"),
"Generating partitions $TARGET"))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", partition_table)
"-ua", # upload address
"90000" if is_1mb_version else "100000",
"-ra", # run address
"10100" if is_1mb_version else "10100",
"-df", # generate debug firmware
"-o", # output,
"$BUILD_DIR/wm_w600"
],
WM_IMAGE_CMD="$WM_IMAGE_TOOL $WM_IMAGE_TOOL_FLAGS")
imaging_action = env.Alias(
"imaging", target_firm,
env.VerboseAction("$WM_IMAGE_CMD", "Creating images from $SOURCE"))
# special case for upload: somehow the uploader doesn't trigger the "AlwaysBuild" options.
# it still needs to know that if it wants the wm_w600.fls file, it needs to execute the imaging command
env.Depends(join("$BUILD_DIR", "wm_w600.fls"), imaging_action)
# always build during normal build
AlwaysBuild(imaging_action)
#
# Target: Print binary size
#
target_size = env.Alias(
"size", target_elf,
env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"))
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
LIBPATH=[join(FRAMEWORK_DIR, "lib")])
if board.get("build.cpu", "") in ("cortex-m4", "cortex-m7"):
fpv_version = "4-sp"
if MCU.startswith("stm32h7"):
fpv_version = "5"
elif board.get("build.cpu", "") == "cortex-m7":
fpv_version = "5-sp"
env.Append(CCFLAGS=["-mfloat-abi=hard",
"-mfpu=fpv%s-d16" % fpv_version],
LINKFLAGS=["-mfloat-abi=hard",
"-mfpu=fpv%s-d16" % fpv_version])
# copy CCFLAGS to ASFLAGS (-x assembler-with-cpp mode)
env.Append(ASFLAGS=env.get("CCFLAGS", [])[:])
if not board.get("build.ldscript", ""):
ldscript = generate_ldscript(get_ld_device(platform))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", ldscript)
env.Replace(LDSCRIPT_PATH=ldscript[0])
env.VariantDir(join("$BUILD_DIR", "FrameworkLibOpenCM3"),
FRAMEWORK_DIR,
duplicate=False)
env.Append(LIBS=[
env.Library(join("$BUILD_DIR", "FrameworkLibOpenCM3"),
get_source_files(root_dir))
])
for d in flatten_cppdefines:
if str(d).startswith("VTABLES_IN_"):
current_vtables = d
if not current_vtables:
current_vtables = "VTABLES_IN_FLASH"
env.Append(CPPDEFINES=[current_vtables])
assert current_vtables
# Build the eagle.app.v6.common.ld linker file
app_ld = env.Command(
join("$BUILD_DIR", "ld", "local.eagle.app.v6.common.ld"),
join(FRAMEWORK_DIR, "tools", "sdk", "ld", "eagle.app.v6.common.ld.h"),
env.VerboseAction(
"$CC -CC -E -P -D%s $SOURCE -o $TARGET" % current_vtables,
"Generating LD script $TARGET"))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", app_ld)
#
# Target: Build Core Library
#
libs = []
if "build.variant" in env.BoardConfig():
env.Append(
CPPPATH=[
join(FRAMEWORK_DIR, "variants",
env.BoardConfig().get("build.variant"))
]
)
env.SConscript("$BUILD_SCRIPT")
if "UPLOAD_FLAGS" in env:
env.Prepend(UPLOADERFLAGS=["$UPLOAD_FLAGS"])
if env.GetProjectOption("upload_command"):
env.Replace(UPLOADCMD=env.GetProjectOption("upload_command"))
for item in env.GetExtraScripts("post"):
env.SConscript(item, exports="env")
##############################################################################
# Checking program size
if env.get("SIZETOOL") and "nobuild" not in COMMAND_LINE_TARGETS:
env.Depends(["upload", "program"], "checkprogsize")
# Replace platform's "size" target with our
_new_targets = [t for t in DEFAULT_TARGETS if str(t) != "size"]
Default(None)
Default(_new_targets)
Default("checkprogsize")
# Print configured protocols
env.AddPreAction(
["upload", "program"],
env.VerboseAction(
lambda source, target, env: env.PrintUploadInfo(),
"Configuring upload protocol...",
),
)
if not board.get("build.ldscript", ""):
linker_script = env.Command(
os.path.join("$BUILD_DIR", "%s_out.ld" % idf_variant),
board.get(
"build.esp-idf.ldscript",
os.path.join(FRAMEWORK_DIR, "components", idf_variant, "ld",
"%s.ld" % idf_variant),
),
env.VerboseAction(
'$CC -I"$BUILD_DIR/config" -C -P -x c -E $SOURCE -o $TARGET',
"Generating LD script $TARGET",
),
)
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
env.Replace(LDSCRIPT_PATH="%s_out.ld" % idf_variant)
#
# Generate partition table
#
fwpartitions_dir = os.path.join(FRAMEWORK_DIR, "components", "partition_table")
partitions_csv = board.get("build.partitions", "partitions_singleapp.csv")
env.Replace(PARTITIONS_TABLE_CSV=os.path.abspath(
os.path.join(fwpartitions_dir, partitions_csv) if os.path.isfile(
os.path.join(fwpartitions_dir, partitions_csv)) else partitions_csv))
partition_table = env.Command(
os.path.join("$BUILD_DIR", "partitions.bin"),
"$PARTITIONS_TABLE_CSV",
env.Replace(
OUTLD_CFLAGS=[
"-DAPP_OFFSET=CONFIG_APP1_OFFSET",
"-DAPP_SIZE=CONFIG_APP1_SIZE",
]
)
linker_script = env.Command(
join("$BUILD_DIR", "esp8266_out.ld"),
join(FRAMEWORK_DIR, "components", "esp8266", "ld", "esp8266.ld"),
env.VerboseAction(
# $(CC) $(OUTLD_CFLAGS) -I ../include -C -P -x c -E $< -o $@ #origin
'$CC $OUTLD_CFLAGS -I"$PROJECTSRC_DIR" -P -x c -E $SOURCE -o $TARGET',
"Generating LD script $TARGET")
)
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
linker_script = env.Command(
join("$BUILD_DIR", "esp8266_common_out.ld"),
join(FRAMEWORK_DIR, "components", "esp8266", "ld", "esp8266.common.ld"),
env.VerboseAction(
# $(CC) -I ../include -C -P -x c -E $< -o $@ #origin
'$CC -I"$PROJECTSRC_DIR" -P -x c -E $SOURCE -o $TARGET',
"Generating LD script $TARGET")
)
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
env.PrependUnique(
CPPPATH=[
join("$PROJECTSRC_DIR"),
join(FRAMEWORK_DIR, "components"),
env.Replace(PROGNAME="firmware")
#
# Target: Build executable and linkable firmware
#
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_elf = join("$BUILD_DIR", "${PROGNAME}.elf")
target_firm = join("$BUILD_DIR", "${PROGNAME}.ihx")
else:
target_elf = env.BuildProgram()
target_firm = env.Command(
join("$BUILD_DIR", "${PROGNAME}.ihx"), env['PIOBUILDFILES'],
env['LINKCOM'].replace("$LINKFLAGS", "$ldflags_for_hex"))
env.Depends(target_firm, target_elf)
AlwaysBuild(env.Alias("nobuild", target_firm))
target_buildprog = env.Alias("buildprog", target_firm, target_firm)
#
# Target: Print binary size
#
target_size = env.Alias(
"size", target_elf,
env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"))
AlwaysBuild(target_size)
#
# Target: Upload firmware
"--sub",
"__FS_START__",
"$FS_START",
"--sub",
"__FS_END__",
"$FS_END",
"--sub",
"__RAM_LENGTH__",
"%dk" % (ram_size // 1024),
]), "Generating linkerscript $BUILD_DIR/memmap_default.ld"))
# if no custom linker script is provided, we use the command that we prepared to generate one.
if not board.get("build.ldscript", ""):
# execute fetch filesystem info stored in env to alawys have that info ready
env["fetch_fs_size"](env)
env.Depends("$BUILD_DIR/${PROGNAME}.elf", linkerscript_cmd)
env.Replace(LDSCRIPT_PATH=os.path.join("$BUILD_DIR", "memmap_default.ld"))
libs = []
variant = board.get("build.arduino.earlephilhower.variant",
board.get("build.variant", ""))
if variant != "":
env.Append(CPPPATH=[os.path.join(FRAMEWORK_DIR, "variants", variant)])
libs.append(
env.BuildLibrary(os.path.join("$BUILD_DIR", "FrameworkArduinoVariant"),
os.path.join(FRAMEWORK_DIR, "variants", variant)))
libs.append(
def __tmp_hook_before_pio_3_2():
env.ProcessFlags(env.get("BUILD_FLAGS"))
# append specified LD_SCRIPT
if ("LDSCRIPT_PATH" in env and
not any(["-Wl,-T" in f for f in env['LINKFLAGS']])):
env.Append(LINKFLAGS=['-Wl,-T"$LDSCRIPT_PATH"'])
target_elf = env.BuildProgram()
if "PIOFRAMEWORK" in env:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
if "espidf" in env.subst("$PIOFRAMEWORK"):
target_boot = env.ElfToBin(
join("$BUILD_DIR", "bootloader"), build_espidf_bootloader())
env.Depends(target_firm, target_boot)
target_buildprog = env.Alias("buildprog", target_firm, target_firm)
#
# Target: Print binary size
#
target_size = env.Alias(
"size", target_elf,
env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"))
AlwaysBuild(target_size)
#
# Target: Upload firmware or SPIFFS image
