# openocd_args.extend([
# "-f",
# "scripts/temp/openocd_%s.cfg" %("gdlink" if upload_protocol == "gd-link" else "jlink") # .cfg in a temp path
# ])
openocd_args.extend(
debug_tools.get(upload_protocol).get("server").get("arguments", []))
openocd_args.extend([
"-c", "init; halt;", "-c",
"flash protect 0 0 last off; program {$SOURCE} verify; mww 0xe004200c 0x4b5a6978; mww 0xe0042008 0x01; resume; exit 0;"
])
env.Replace(UPLOADER="openocd",
UPLOADERFLAGS=openocd_args,
UPLOADCMD="$UPLOADER $UPLOADERFLAGS")
upload_source = target_elf
upload_actions = [env.VerboseAction("$UPLOADCMD", "Uploading $SOURCE")]
# custom upload tool
elif upload_protocol == "custom":
upload_actions = [env.VerboseAction("$UPLOADCMD", "Uploading $SOURCE")]
else:
sys.stderr.write("Warning! Unknown upload protocol %s\n" % upload_protocol)
AlwaysBuild(env.Alias("upload", upload_source, upload_actions))
#
# Setup default targets
#
Default([target_buildprog, target_buildhex, target_size])
env.Append(BUILDERS={'IVerilog': iverilog, 'VCD': vcd})
#
# Target: Verify verilog code
#
vout = env.IVerilog(TARGET, src_synth)
target_verify = env.Alias('verify', vout)
AlwaysBuild(target_verify)
#
# Target: Simulate testbench
#
sout = env.IVerilog(TARGET_SIM, src_sim)
vcd_file = env.VCD(sout)
target_sim = env.Alias('sim', vcd_file, 'gtkwave {0} {1}.gtkw'.format(
vcd_file[0], join(env.subst('$PROJECT_SRC_DIR'), SIMULNAME)))
AlwaysBuild(target_sim)
#
# Setup default targets
#
Default([binf])
#
# Target: Clean generated files
#
if GetOption('clean'):
env.Default([t, vout, sout, vcd_file])
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 not (set(["nobuild", "sizedata"])
& set(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")
if "compiledb" in COMMAND_LINE_TARGETS:
env.Alias("compiledb", env.CompilationDatabase("$COMPILATIONDB_PATH"))
# Print configured protocols
env.AddPreAction(
["upload", "program"],
env.VerboseAction(
lambda source, target, env: env.PrintUploadInfo(),
"Configuring upload protocol...",
),
)
AS="armv6l-linux-gnueabihf-as",
CC="armv6l-linux-gnueabihf-gcc",
CXX="armv6l-linux-gnueabihf-g++",
GDB="armv6l-linux-gnueabihf-gdb",
OBJCOPY="armv6l-linux-gnueabihf-objcopy",
RANLIB="armv6l-linux-gnueabihf-ranlib",
SIZETOOL="armv6l-linux-gnueabihf-size",
SIZEPRINTCMD='$SIZETOOL $SOURCES'
)
#
# 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])
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
#
disable_msd = ((platform.system() == "Darwin"
and platform.release().startswith("14."))
or env.subst("$UPLOAD_PROTOCOL"))
if "mbed" in env.subst("$FRAMEWORK") and not disable_msd:
upload = env.Alias(["upload", "uploadlazy"], target_firm, env.UploadToDisk)
else:
upload = env.Alias(["upload", "uploadlazy"], target_firm, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Define targets
#
Default([target_firm, target_size])
# Target: Upload
env.Replace(UPLOAD_PORT='"Launchpad Pro"')
upload = env.VerboseAction(
' '.join(['python3', '$SENDSYSEX', '-p', '$UPLOAD_PORT', '$SOURCE']),
'Uploading $SOURCE')
env.AddPlatformTarget(
'upload',
target_syx,
upload,
'Upload',
'Send firmware to Launchpad Pro over MIDI',
)
# Target: Restore
env.AddPlatformTarget(
'restore',
join(PLATFORM_DIR, 'resources/Launchpad Pro.syx'),
upload,
'Restore',
'Restore Launchpad Pro original firmware',
)
# Default Targets
Default([target_syx, target_size])
"$UPLOAD_SPEED",
"-p",
'"$UPLOAD_PORT"',
],
UPLOADCMD='$UPLOADER $UPLOADERFLAGS $SOURCE')
upload_source = target_firm
upload_actions = [env.VerboseAction("$UPLOADCMD", "Uploading $SOURCE")]
if "windows" not in get_systype() or board.get("build.mcu") == "MT2625":
env.Append(UPLOADERFLAGS=[
"-m",
'"${__get_board_mcu()}"',
])
if "windows" in get_systype(
) and board.get("build.mcu") != "MT2625" and env.subst("$UPLOAD_PORT") == "":
env.Append(UPLOADERFLAGS=["-u"], REFLASH_FLAGS=["-u"])
else:
upload_actions.insert(
0,
env.VerboseAction(env.AutodetectUploadPort,
"Looking for upload port..."))
AlwaysBuild(env.Alias("upload", upload_source, upload_actions))
#
# Setup default targets
#
Default([target_buildprog, target_buildota, target_size])
LINKFLAGS=[],
CPPDEFINES=[
"PART_apollo3", "AM_PACKAGE_BGA", "AM_PART_APOLLO3",
"ARDUINO_ARCH_APOLLO3"
],
LIBS=[],
BUILDERS=dict(ElfToBin=Builder(action=" ".join(
["$OBJCOPY", "-O", "binary", "$SOURCES", "$TARGET"]),
suffix=".bin")))
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .bin file
#
target_bin = env.ElfToBin(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Upload firmware
#
upload = env.Alias(["upload"], target_bin, "$UPLOADCMD")
AlwaysBuild(upload)
#
# Target: Define targets
#
Default(target_bin)
"-nostdlib",
"-nodefaultlibs", \
"-Wl,--gc-sections,--no-warn-mismatch,--build-id=none"],
CPPDEFINES=["VERSION=\"v1.0\""],
PROGNAME="firmware",
PROGSUFFIX=".elf",
)
env.Append(BUILDERS=dict(ElfToHex=Builder(action=" ".join(
["$OBJCOPY", "-O", "ihex", "$SOURCES", "$TARGET"]),
suffix=".hex")))
# The source code of "platformio-build-tool" is here
# https://github.com/platformio/platformio-core/blob/develop/platformio/builder/tools/platformio.py
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .hex file
#
target_hex = env.ElfToHex(join("$BUILD_DIR", "firmware"), target_elf)
#
# Target: Define targets
#
Default(target_hex)
"loadbin %s, %s" % (source, board.get(
"upload.offset_address", "0x08000000")),
"r",
"q"
]
with open(script_path, "w") as fp:
fp.write("\n".join(commands))
return script_path
env.Replace(
__jlink_cmd_script=_jlink_cmd_script,
UPLOADER="JLink.exe" if system() == "Windows" else "JLinkExe",
UPLOADERFLAGS=[
"-device", board.get("debug", {}).get("jlink_device"),
"-speed", env.GetProjectOption("debug_speed", "4000"),
"-if", ("jtag" if upload_protocol == "jlink-jtag" else "swd"),
"-autoconnect", "1",
"-NoGui", "1"
],
UPLOADCMD='$UPLOADER $UPLOADERFLAGS -CommanderScript "${__jlink_cmd_script(__env__, SOURCE)}"'
)
upload_actions = [env.VerboseAction("$UPLOADCMD", "Uploading $SOURCE")]
upload = env.Alias("upload", upload_source, upload_actions)
AlwaysBuild(upload)
#
# Target: Define targets
#
Default(target_firm)
# http://www.wizio.eu/
# https://github.com/Wiz-IO
#
# 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() +
" 2019 Georgi Angelov >>>>>>>>>>>>" + Fore.BLACK)
####################################################
# 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("$UPLOADCMD", "\n"),
env.VerboseAction("", "\n")])
AlwaysBuild(upload)
Default(src)
target_bin,
sizePrintCMD,
"Program Size",
"Calculate program size",
)
#
# Target: Upload firmware
#
upload_protocol = env.subst("$UPLOAD_PROTOCOL")
upload_port = env.subst("$UPLOAD_PORT")
upload_actions = []
if upload_protocol == "easy-pdk-programmer":
env.Replace(UPLOADER="easypdkprog",
UPLOADERFLAGS=['-n', board_config.get("build.mcu")],
UPLOADCMD='"$UPLOADER" $UPLOADERFLAGS write $SOURCE')
if upload_port:
env.Append(UPLOADERFLAGS=["--port", upload_port])
upload_actions = [env.VerboseAction("$UPLOADCMD", "Uploading $SOURCE")]
else:
sys.stderr.write("Warning! Unknown upload protocol %s\n" % upload_protocol)
AlwaysBuild(env.Alias("upload", target_ihx, upload_actions))
#
# Target: Define targets
#
Default(target_bin, target_size)
