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"),