#
# Target: Build executable and linkable firmware
#
if "zephyr" in env.get("PIOFRAMEWORK", []):
env.SConscript(join(platform.get_package_dir("framework-zephyr"),
"scripts", "platformio", "platformio-build-pre.py"),
exports={"env": env})
upload_protocol = env.subst("$UPLOAD_PROTOCOL")
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()
if "SOFTDEVICEHEX" in env:
target_firm = env.MergeHex(
join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToHex(join("$BUILD_DIR", "userfirmware"), target_elf))
elif "nrfutil" == upload_protocol and use_adafruit:
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)
elif "sam-ba" == upload_protocol:
target_firm = env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"),
target_elf)
RANLIB="arm-none-eabi-ranlib",
SIZETOOL="arm-none-eabi-size",
ARFLAGS=["rc"],
SIZEPROGREGEXP=r"^(?:\.text|\.data|\.bootloader)\s+(\d+).*",
SIZEDATAREGEXP=r"^(?:\.data|\.bss|\.noinit)\s+(\d+).*",
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"),
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])
# parse manually SDCC flags
if env.get("BUILD_FLAGS"):
_parsed, _unparsed = _parseSdccFlags(env.get("BUILD_FLAGS"))
env.Append(CCFLAGS=_parsed)
env['BUILD_FLAGS'] = _unparsed
project_sdcc_flags = None
if env.get("SRC_BUILD_FLAGS"):
project_sdcc_flags, _unparsed = _parseSdccFlags(env.get("SRC_BUILD_FLAGS"))
env['SRC_BUILD_FLAGS'] = _unparsed
#
# Target: Build executable and linkable firmware
#
target_firm = env.BuildProgram()
if project_sdcc_flags:
env.Import("projenv")
projenv.Append(CCFLAGS=project_sdcc_flags)
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_firm,
env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"))
]
uploading = [
env.VerboseAction(
BTAsize_create,
"Generating " + join(env.subst("$BUILD_DIR"), "BTAsize.gdb")),
env.VerboseAction(
fwsize_create,
"Generating " + join(env.subst("$BUILD_DIR"), "fwsize.gdb")),
env.VerboseAction(
replace_rtl, "Generating " +
join(env.subst("$BUILD_DIR"), "rtl_gdb_flash_write.txt")),
env.VerboseAction(
"$CP $BOOTALL_BIN " + join(env.subst("$BUILD_DIR"), "boot_all.bin"),
'.'),
env.VerboseAction(
env.subst("$UPLOADCMD").replace("\\", "\\\\") + env["OPENOCD_KILL"],
"Uploading binary to flash"),
]
env.Append(BUILDERS=dict(Manipulate=Builder(
action=env.VerboseAction(manipulating, "Manipulating images")), ))
program_b = env.BuildProgram()
manipulate_images_b = env.Manipulate("$BUILD_DIR/image2_all_ota1.bin",
[program_b])
upload = env.Alias("upload", manipulate_images_b, uploading)
AlwaysBuild(upload)
Default([manipulate_images_b])
if not env.get("PIOFRAMEWORK"):
env.SConscript("frameworks/_bare.py")
#
# Target: Build executable and linkable firmware
#
target_firm_elf = None
target_firm_hex = None
object_dump_dis = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_firm_elf = join("$BUILD_DIR", "${PROGNAME}.elf")
target_firm_hex = join("$BUILD_DIR", "${PROGNAME}.hex")
target_firm = join("$BUILD_DIR", "${PROGNAME}.bin")
else:
target_firm_elf = env.BuildProgram()
if "SOFTDEVICEHEX" in env:
merged_softdevice_hex = env.MergeHex(
join("$BUILD_DIR", "${PROGNAME}"),
env.ElfToHex(join("$BUILD_DIR", "user_${PROGNAME}"),
target_firm_elf))
target_firm_hex = join("$BUILD_DIR", "user_${PROGNAME}.hex")
else:
target_firm_hex = env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"),
target_firm_elf)
object_dump_dis = env.ObjectDump(join("$BUILD_DIR", "${PROGNAME}"),
target_firm_elf)
target_firm = env.ElfToBin(join("$BUILD_DIR", "${PROGNAME}"),
target_firm_elf)
SIZEPROGREGEXP=
r"^(?:CODE|GSINIT|GSFINAL|CONST|HOME|RSEG0|SSEG|HEADER1|HEADER3|PREG2)[^=]*\D+(\d+).*",
SIZEDATAREGEXP=r"^(?:DATA)[^=]*\D+(\d+).*",
PROGNAME="firmware",
PROGSUFFIX=".ihx")
#
# Target: Build executable and linkable firmware
#
#target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_ihx = join("$BUILD_DIR", "${PROGNAME}.elf")
target_bin = join("$BUILD_DIR", "${PROGNAME}.bin")
else:
target_ihx = env.BuildProgram()
target_bin = env.Command(join("$BUILD_DIR", "${PROGNAME}.bin"), target_ihx,
"$OBJCOPY -p $SOURCES $TARGET")
#
# Target: Print binary size
#
target_size = env.AddPlatformTarget(
"size",
target_bin,
sizePrintCMD,
"Program Size",
"Calculate program size",
)
# A full list with the available variables
# http://www.scons.org/doc/production/HTML/scons-user.html#app-variables
env.Replace(
AR="mips-openwrt-linux-ar",
AS="mips-openwrt-linux-as",
CC="mips-openwrt-linux-gcc",
CXX="mips-openwrt-linux-g++",
OBJCOPY="mips-openwrt-linux-objcopy",
RANLIB="mips-openwrt-linux-ranlib",
SIZETOOL="mips-openwrt-linux-size"
)
env.PrependENVPath(
"PATH",
"/home/andrew/develop/k5/sentrifarm/software/openwrt/openwrt/staging_dir/toolchain-mips_34kc_gcc-4.8-linaro_uClibc-0.9.33.2/bin"
)
env['ENV']['STAGING_DIR'] = "/home/andrew/develop/k5/sentrifarm/software/openwrt/openwrt/staging_dir"
#
# Target: Build executable and linkable firmware
#
target_bin = env.BuildProgram() # BuildFirmware()
#
# Target: Define targets
#
Default(target_bin)
