link_args = extract_link_args(elf_config)
app_includes = get_app_includes(elf_config)
project_lib_includes = get_project_lib_includes(env)
#
# Compile bootloader
#
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", build_bootloader())
#
# Target: ESP-IDF menuconfig
#
AlwaysBuild(
env.Alias("menuconfig", None,
[env.VerboseAction(RunMenuconfig, "Running menuconfig...")]))
#
# Process main parts of the framework
#
libs = find_lib_deps(framework_components_map, elf_config, link_args,
[project_target_name])
# Extra flags which need to be explicitly specified in LINKFLAGS section because SCons
# cannot merge them correctly
extra_flags = filter_args(link_args["LINKFLAGS"], ["-T", "-u"])
link_args["LINKFLAGS"] = sorted(
list(set(link_args["LINKFLAGS"]) - set(extra_flags)))
# remove the main linker script flags '-T esp32_out.ld'
"-U%s:w:%s:m" % (k, v)
for k, v in env.BoardConfig().get("fuses", {}).items()
]))
#
# Target: Build executable and linkable firmware
#
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "${PROGNAME}.hex")
else:
target_elf = env.BuildProgram()
target_firm = env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"), 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 by default .hex file
#
)
if not env.get("PIOFRAMEWORK"):
env.SConscript("frameworks/_bare.py")
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_elf = join("$BUILD_DIR", "${PROGNAME}.elf")
target_firm = join("$BUILD_DIR", "${PROGNAME}.bin")
else:
target_elf = env.BuildProgram()
target_firm = env.ElfToBin(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)
#
# 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
#
# Target: Build executable and linkable firmware
#
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_elf = os.path.join("$BUILD_DIR", "${PROGNAME}.elf")
target_bin = os.path.join("$BUILD_DIR", "${PROGNAME}.bin")
target_vh = os.path.join("$BUILD_DIR", "${PROGNAME}.vh")
else:
target_elf = env.BuildProgram()
target_bin = env.ElfToBin(os.path.join("$BUILD_DIR", "${PROGNAME}"),
target_elf)
target_vh = env.BinToVh(os.path.join("$BUILD_DIR", "${PROGNAME}"),
target_bin)
AlwaysBuild(env.Alias("nobuild", target_bin))
target_buildprog = env.Alias("buildprog", target_bin, target_bin)
env.AddPostAction(
target_elf,
env.VerboseAction(generate_disassembly, "Generating disassembly"))
#
# Target: Print binary size
#
target_size = env.AddPlatformTarget(
"size",
target_elf,
env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"),
"Program Size",
else:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
if "PIOFRAMEWORK" not in env:
target_firm = env.ElfToBin(
[join("$BUILD_DIR", "firmware_00000"),
join("$BUILD_DIR", "firmware_40000")], target_elf)
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# 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
#
target_upload = env.Alias(
["upload", "uploadlazy", "uploadfs"], target_firm,
[env.VerboseAction(env.AutodetectUploadPort, "Looking for upload port..."),
env.VerboseAction("$UPLOADCMD", "Uploading $SOURCE")])
env.AlwaysBuild(target_upload)
#
SIZECHECKCMD="$SIZETOOL -A -d $SOURCES",
SIZEPRINTCMD='$SIZETOOL --mcu=$BOARD_MCU -C -d $SOURCES',
PROGSUFFIX=".elf",
UPLOADNAME=join("$BUILD_DIR", "${PROGNAME}.cfg"),
)
####################################################
# Target: Build executable and linkable program
####################################################
elf = None
elf = env.BuildProgram()
src = env.GFH(
join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"), elf),
)
AlwaysBuild( env.Alias("nobuild", src) )
####################################################
# Target: Upload BC66
####################################################
target_upload = env.Alias("upload", src, [
env.VerboseAction(env.AutodetectUploadPort, "Looking for upload port..."),
env.VerboseAction("", "--- WAITING MODULE ---"),
env.VerboseAction("$UPLOADCMD", "RESET BOARD TO START FLASHING"),
env.VerboseAction("", "POWER ON BOARD"),
])
AlwaysBuild( target_upload )
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
upload = env.Alias(["upload", "uploadlazy"], target_firm, env.UploadToDisk)
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])
env.SConscript("frameworks/_bare.py")
#
# Target: Build executable and linkable firmware
#
target_elf = None
target_firm = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_elf = join("$BUILD_DIR", "${PROGNAME}.elf")
target_firm = join("$BUILD_DIR", "${PROGNAME}.bin")
else:
target_elf = env.BuildProgram()
target_firm = env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"), target_elf)
AlwaysBuild(env.Alias("nobuild", target_firm))
target_buildprog = env.Alias("buildprog", target_firm, target_firm)
#
# Target: Create compressed images for uplaoding
#
path_wm_tool = platform.get_package_dir("tool-w60x-download") or ""
if path_wm_tool == "":
print("ERROR: Failed to find W60x tools!")
sys.exit(-1)
# for 1MB target
#IMGTYPE=1M
#UPDADDR=90000
#RUNADDR=10100
# for 2MB target
"-c", "$UPLOAD_PROTOCOL"
],
UPLOADHEXCMD='"$UPLOADER" $UPLOADERFLAGS -U flash:w:$SOURCES:i',
UPLOADEEPCMD='"$UPLOADER" $UPLOADERFLAGS -U eeprom:w:$SOURCES:i')
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildFirmware()
#
# Target: Extract EEPROM data (from EEMEM directive) to .eep file
#
target_eep = env.Alias(
"eep", env.ElfToEep(join("$BUILD_DIR", "firmware"), target_elf))
#
# Target: Build the .hex file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.hex")
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
env.Replace(UPLOADER=_upload_tool,
UPLOADERFLAGS=["$UPLOAD_PORT"] + _upload_flags,
UPLOADCMD=('$UPLOADER $UPLOADERFLAGS $PROJECT_DIR/$SOURCES'))
#
# Target: Build executable and linkable firmware
#
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_elf = env.BuildProgram()
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), 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 by default .bin file
#
env.BoardConfig().get('build.type', 'hx'),
env.BoardConfig().get('build.size', '1k'),
env.BoardConfig().get('build.pack', 'tq144')
),
suffix='.rpt',
src_suffix='.asc')
env.Append(BUILDERS={
'Synth': synth, 'PnR': pnr, 'Bin': bitstream, 'Time': time_rpt})
blif = env.Synth(TARGET, [src_synth])
asc = env.PnR(TARGET, [blif, PCF])
binf = env.Bin(TARGET, asc)
upload = env.Alias('upload', binf, 'iceprog $SOURCE')
AlwaysBuild(upload)
# -- Target for calculating the time (.rpt)
rpt = env.Time(asc)
t = env.Alias('time', rpt)
AlwaysBuild(t)
# -- Icarus Verilog builders
iverilog = Builder(
action='iverilog {0} -o $TARGET {1} -D VCD_OUTPUT={2} $SOURCES'.format(
IVER_PATH, VLIB_PATH, TARGET_SIM),
suffix='.out',
src_suffix='.v')
# NOTE: output file name is defined in the iverilog call using VCD_OUTPUT macro
# Configure extra library source directories for LDF
if util.get_project_optional_dir("lib_extra_dirs"):
env.Prepend(LIBSOURCE_DIRS=[
l.strip()
for l in util.get_project_optional_dir("lib_extra_dirs").split(", ")
if l.strip()
])
env.Prepend(LIBSOURCE_DIRS=env.get("LIB_EXTRA_DIRS", []))
env.LoadPioPlatform(commonvars)
env.SConscriptChdir(0)
env.SConsignFile(join("$PROJECTPIOENVS_DIR", ".sconsign.dblite"))
env.SConscript("$BUILD_SCRIPT")
AlwaysBuild(env.Alias("__test", DEFAULT_TARGETS + ["size"]))
if "UPLOAD_FLAGS" in env:
env.Append(UPLOADERFLAGS=["$UPLOAD_FLAGS"])
if env.get("EXTRA_SCRIPT"):
env.SConscript(env.get("EXTRA_SCRIPT"), exports="env")
if "envdump" in COMMAND_LINE_TARGETS:
print env.Dump()
env.Exit(0)
if "idedata" in COMMAND_LINE_TARGETS:
print "\n%s\n" % json.dumps(env.DumpIDEData())
env.Exit(0)
# 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...",
),
)
AlwaysBuild(env.Alias("debug", DEFAULT_TARGETS))
AlwaysBuild(env.Alias("__test", DEFAULT_TARGETS))
##############################################################################
if "envdump" in COMMAND_LINE_TARGETS:
click.echo(env.Dump())
env.Exit(0)
if "idedata" in COMMAND_LINE_TARGETS:
Import("projenv")
click.echo("\n%s\n" % dump_json_to_unicode(projenv.DumpIDEData() # pylint: disable=undefined-variable
))
env.Exit(0)
if "sizedata" in COMMAND_LINE_TARGETS:
#
# 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}.bin")
target_firm_fota = join("$BUILD_DIR", "fota_${PROGNAME}.bin")
else:
target_elf = env.BuildProgram()
target_firm = env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"), target_elf)
target_firm_fota = env.BinToFOTA(join("$BUILD_DIR", "fota_${PROGNAME}"),
target_firm)
AlwaysBuild(env.Alias("nobuild", target_firm))
target_buildprog = env.Alias("buildprog", target_firm, target_firm)
#
# Target: Build FOTA Binary
#
target_buildota = env.Alias("buildfota", target_firm_fota, target_firm_fota)
AlwaysBuild(target_buildota)
#
# Target: Print binary size
#
target_size = env.Alias(
"size", target_elf,
CXX="${_BINPREFIX}g++",
GDB="${_BINPREFIX}gdb",
OBJCOPY="${_BINPREFIX}objcopy",
RANLIB="${_BINPREFIX}ranlib",
SIZETOOL="${_BINPREFIX}size",
SIZEPRINTCMD='$SIZETOOL $SOURCES')
if get_systype() == "darwin_x86_64":
env.Replace(_BINPREFIX="x86_64-pc-linux-")
#
# Target: Build executable program
#
target_bin = env.BuildProgram()
#
# Target: Print binary size
#
target_size = env.Alias(
"size", target_bin,
env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"))
AlwaysBuild(target_size)
#
# Default targets
#
Default([target_bin])
# copy CCFLAGS to ASFLAGS (-x assembler-with-cpp mode)
env.Append(ASFLAGS=env.get("CCFLAGS", [])[:])
#
# Target: Build executable and linkable firmware
#
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "${PROGNAME}.bin")
else:
target_elf = env.BuildProgram()
target_firm = env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"), 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
#
CORELIBS = env.ProcessGeneral()
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildFirmware(CORELIBS + ["m"])
#
# Target: Build the .hex
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_hex = join("$BUILD_DIR", "firmware.hex")
else:
target_hex = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Upload firmware
#
upload = env.Alias(["upload", "uploadlazy"], target_hex, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Define targets
#
Default(target_hex)
'Synth': synth,
'PnR': pnr,
'Bin': bitstream,
'Time': time_rpt
})
blif = env.Synth(TARGET, [src_synth])
asc = env.PnR(TARGET, [blif, PCF])
binf = env.Bin(TARGET, asc)
#
# Target: Time analysis (.rpt)
#
rpt = env.Time(asc)
target_time = env.Alias('time', rpt)
AlwaysBuild(target_time)
#
# Target: Upload bitstream
#
target_upload = env.Alias('upload', binf, '$UPLOADBINCMD')
AlwaysBuild(target_upload)
#
# Builders: Icarus Verilog
#
iverilog = Builder(
action='iverilog {0} -o $TARGET -D VCD_OUTPUT={1} {2} $SOURCES'.format(
IVER_PATH, TARGET_SIM, VLIB_FILES),
suffix='.out',
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
if env.subst("$BOARD") == "zero":
upload = env.Alias(["upload", "uploadlazy"], target_firm, "$UPLOADCMD")
else:
upload = env.Alias(["upload", "uploadlazy"], target_firm,
[env.AutodetectUploadPort, BeforeUpload, "$UPLOADCMD"])
AlwaysBuild(upload)
#
# WizIO 2021 Georgi Angelov
# http://www.wizio.eu/
# https://github.com/Wiz-IO/wizio-pico
from __future__ import print_function
from os.path import join
from SCons.Script import (AlwaysBuild, Builder, COMMAND_LINE_TARGETS, Default, DefaultEnvironment)
from colorama import Fore
from pioasm import dev_pioasm
env = DefaultEnvironment()
print( '<<<<<<<<<<<< ' + env.BoardConfig().get("name").upper() + " 2021 Georgi Angelov >>>>>>>>>>>>" )
dev_pioasm(env)
elf = env.BuildProgram()
src = env.ElfToBin( join("$BUILD_DIR", "${PROGNAME}"), elf )
prg = env.Alias( "buildprog", src, [ env.VerboseAction("", "DONE") ] )
AlwaysBuild( prg )
upload = env.Alias("upload", prg, [
env.VerboseAction("$UPLOADCMD", "Uploading..."),
env.VerboseAction("", " DONE"),
])
AlwaysBuild( upload )
Default( prg )
else:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
if "FRAMEWORK" not in env:
target_firm = env.ElfToBin([
join("$BUILD_DIR", "firmware_00000"),
join("$BUILD_DIR", "firmware_40000")
], target_elf)
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload firmware or SPIFFS image
#
target_upload = env.Alias(
["upload", "uploadlazy", "uploadfs"], target_firm,
[lambda target, source, env: env.AutodetectUploadPort(), "$UPLOADCMD"])
env.AlwaysBuild(target_upload)
#
# Target: Define targets
#
# Target: Build executable and linkable firmware or SPIFFS image
#
target_elf = env.BuildProgram()
if "nobuild" in COMMAND_LINE_TARGETS:
if set(["uploadfs", "uploadfsota"]) & set(COMMAND_LINE_TARGETS):
fetch_spiffs_size(env)
target_firm = join("$BUILD_DIR", "spiffs.bin")
else:
target_firm = join("$BUILD_DIR", "${PROGNAME}.bin")
else:
if set(["buildfs", "uploadfs", "uploadfsota"]) & set(COMMAND_LINE_TARGETS):
target_firm = env.DataToBin(join("$BUILD_DIR", "spiffs"),
"$PROJECTDATA_DIR")
AlwaysBuild(target_firm)
AlwaysBuild(env.Alias("buildfs", target_firm))
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"),
target_elf)
AlwaysBuild(env.Alias("nobuild", target_firm))
target_buildprog = env.Alias("buildprog", target_firm, target_firm)
# update max upload size based on CSV file
if env.get("PIOMAINPROG"):
env.AddPreAction(
"checkprogsize",
env.VerboseAction(
lambda source, target, env: _update_max_upload_size(env),
"Retrieving maximum program size $SOURCES"))
# remove after PIO Core 3.6 release
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.bin")
else:
target_firm = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload by default .bin file
#
upload = env.Alias(["upload", "uploadlazy"], target_firm,
[BeforeUpload, "$UPLOADCMD"])
AlwaysBuild(upload)
#
# Target: Unit Testing
#
#
_name = env.get("PROGNAME")
target_bin = env.ElfToBin(join("$BUILD_DIR", _name), target_elf)
# Target: Build the .hex file
#
target_hex = env.ElfToHex(join("$BUILD_DIR", _name), target_elf)
# Target: Build the .lst file
#
target_lst = env.ElfToLst(join("$BUILD_DIR", _name), target_elf)
#
# Target: Upload firmware
#
upload = env.Alias(["upload"], target_bin, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Print binary size
#
target_size = env.Alias(
"size", target_elf,
env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"))
AlwaysBuild(target_size)
AlwaysBuild(target_lst)
AlwaysBuild(target_hex)
AlwaysBuild(target_bin)
CXX="${_BINPREFIX}g++",
OBJCOPY="${_BINPREFIX}objcopy",
RANLIB="${_BINPREFIX}ranlib",
SIZETOOL="${_BINPREFIX}size",
SIZEPRINTCMD='"$SIZETOOL" $SOURCES',
PROGSUFFIX=".exe")
if get_systype() == "darwin_x86_64":
env.Replace(_BINPREFIX="i586-mingw32-")
elif get_systype() in ("linux_x86_64", "linux_i686"):
env.Replace(_BINPREFIX="i686-w64-mingw32-")
#
# Target: Build executable program
#
target_bin = env.BuildProgram()
#
# Target: Print binary size
#
target_size = env.Alias("size", target_bin, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Define targets
#
Default([target_bin])
#
# Support: Comet Electronics
# https://www.comet.bg/?cid=92
##########################################################################
from os.path import join
from SCons.Script import (AlwaysBuild, Builder, COMMAND_LINE_TARGETS, Default,
DefaultEnvironment)
from colorama import Fore
env = DefaultEnvironment()
print(Fore.GREEN + '<<<<<<<<<<<< ' + env.BoardConfig().get("name").upper() +
" 2018 Georgi Angelov >>>>>>>>>>>>")
####################################################
# Build executable and linkable program
####################################################
elf = env.BuildProgram()
src = env.MakeHeader(join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"), elf))
AlwaysBuild(src)
upload = env.Alias("upload", src, [
env.VerboseAction(env.AutodetectUploadPort, "Looking for upload port..."),
env.VerboseAction("$UPLOADCMD", '\033[93m' + "Uploading: $PROGNAME"),
env.VerboseAction("", '\033[93m' + "Ready"),
])
AlwaysBuild(upload)
Default(src)
target_elf = env.BuildProgram()
#
# Target: Build the .hex
#
if "uploadlazy" in COMMAND_LINE_TARGETS:
target_firm = join("$BUILD_DIR", "firmware.hex")
else:
target_firm = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Print binary size
#
target_size = env.Alias("size", target_elf, "$SIZEPRINTCMD")
AlwaysBuild(target_size)
#
# Target: Upload firmware
#
upload = env.Alias(["upload", "uploadlazy"], target_firm, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])
if not env.get("PIOFRAMEWORK"):
env.SConscript("frameworks/_bare.py", exports="env")
#
# 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}.hex")
else:
target_elf = env.BuildProgram()
target_firm = env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"), 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 by default .hex file
#
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),
),
target_firm,
if "nrfutil" == upload_protocol:
target_firm = env.PackageDfu(
join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"), target_elf))
elif "nrfjprog" == upload_protocol:
target_firm = env.ElfToHex(
join("$BUILD_DIR", "${PROGNAME}"), target_elf)
else:
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)
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")
)
AlwaysBuild(env.Alias("dfu", env.PackageDfu(
join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"), target_elf))))
AlwaysBuild(env.Alias("bootloader", None, [
env.VerboseAction("nrfjprog --program $DFUBOOTHEX -f nrf52 --chiperase", "Uploading $DFUBOOTHEX"),
env.VerboseAction("nrfjprog --erasepage $BOOT_SETTING_ADDR -f nrf52", "Erasing bootloader config"),
