def BuildProgram(env):
def _append_pio_macros():
env.AppendUnique(CPPDEFINES=[("PLATFORMIO",
int("{0:02d}{1:02d}{2:02d}".format(
*pioversion_to_intstr())))])
_append_pio_macros()
env.PrintConfiguration()
# fix ASM handling under non case-sensitive OS
if not Util.case_sensitive_suffixes(".s", ".S"):
env.Replace(AS="$CC", ASCOM="$ASPPCOM")
if set(["__debug", "debug"]) & set(COMMAND_LINE_TARGETS):
env.ProcessDebug()
# process extra flags from board
if "BOARD" in env and "build.extra_flags" in env.BoardConfig():
env.ProcessFlags(env.BoardConfig().get("build.extra_flags"))
# apply user flags
env.ProcessFlags(env.get("BUILD_FLAGS"))
# process framework scripts
env.BuildFrameworks(env.get("PIOFRAMEWORK"))
# restore PIO macros if it was deleted by framework
_append_pio_macros()
# remove specified flags
env.ProcessUnFlags(env.get("BUILD_UNFLAGS"))
if "__test" in COMMAND_LINE_TARGETS:
env.ProcessTest()
# build project with dependencies
_build_project_deps(env)
# append into the beginning a main LD script
if (env.get("LDSCRIPT_PATH")
and not any("-Wl,-T" in f for f in env['LINKFLAGS'])):
env.Prepend(LINKFLAGS=["-T", "$LDSCRIPT_PATH"])
# enable "cyclic reference" for linker
if env.get("LIBS") and env.GetCompilerType() == "gcc":
env.Prepend(_LIBFLAGS="-Wl,--start-group ")
env.Append(_LIBFLAGS=" -Wl,--end-group")
program = env.Program(join("$BUILD_DIR", env.subst("$PROGNAME")),
env['PIOBUILDFILES'])
env.Replace(PIOMAINPROG=program)
AlwaysBuild(
env.Alias(
"checkprogsize", program,
env.VerboseAction(env.CheckUploadSize,
"Checking size $PIOMAINPROG")))
return program
def BuildProgram(env):
env.ProcessProgramDeps()
env.ProcessProjectDeps()
# append into the beginning a main LD script
if env.get("LDSCRIPT_PATH") and not any("-Wl,-T" in f
for f in env["LINKFLAGS"]):
env.Prepend(LINKFLAGS=["-T", env.subst("$LDSCRIPT_PATH")])
# enable "cyclic reference" for linker
if (env.get("LIBS") and env.GetCompilerType() == "gcc"
and (env.PioPlatform().is_embedded() or not MACOS)):
env.Prepend(_LIBFLAGS="-Wl,--start-group ")
env.Append(_LIBFLAGS=" -Wl,--end-group")
program = env.Program(os.path.join("$BUILD_DIR", env.subst("$PROGNAME")),
env["PIOBUILDFILES"])
env.Replace(PIOMAINPROG=program)
AlwaysBuild(
env.Alias(
"checkprogsize",
program,
env.VerboseAction(env.CheckUploadSize,
"Checking size $PIOMAINPROG"),
))
print("Building in %s mode" % env.GetBuildType())
return program
def __call__(self, env, libraries):
if not self._add_dependents:
logger.warn(
"BoostSharedLibrary() is deprecated, use BoostSharedLibs() or BoostSharedLib() instead"
)
libraries = Flatten([libraries])
if not 'boost' in env['BUILD_WITH']:
env.BuildWith('boost')
Boost = env['dependencies']['boost'](env)
for library in libraries:
if library.startswith('log'):
env.AppendUnique(CPPDEFINES='BOOST_LOG_DYN_LINK')
elif library == 'chrono':
env.AppendUnique(CPPDEFINES='BOOST_CHRONO_DYN_LINK')
elif library == 'filesystem':
env.AppendUnique(CPPDEFINES='BOOST_FILESYSTEM_DYN_LINK')
elif library == 'date_time':
env.AppendUnique(CPPDEFINES='BOOST_DATE_TIME_DYN_LINK')
elif library == 'regex':
env.AppendUnique(CPPDEFINES='BOOST_REGEX_DYN_LINK')
elif library == 'system':
env.AppendUnique(CPPDEFINES='BOOST_SYSTEM_DYN_LINK')
library = BoostLibraryBuilder(Boost,
add_dependents=self._add_dependents,
verbose_build=self._verbose_build,
verbose_config=self._verbose_config)(
env, None, None, libraries, 'shared')
if self._build_always:
return AlwaysBuild(library)
else:
return library
def __call__(self, env, library):
if not 'boost' in env['BUILD_WITH']:
env.BuildWith('boost')
Boost = env['dependencies']['boost']
library = BoostLibraryBuilder(Boost,
verbose=self._verbose)(env, None, None,
library, 'shared')
if self._build_once:
return library
else:
return AlwaysBuild(library)
def AddPlatformTarget(
env,
name,
dependencies,
actions,
title=None,
description=None,
always_build=True,
):
target = env.Alias(name, dependencies, actions)
if always_build:
AlwaysBuild(target)
return target
def AddTarget( # pylint: disable=too-many-arguments
env,
name,
dependencies,
actions,
title=None,
description=None,
group="Generic",
always_build=True,
):
if "__PIO_TARGETS" not in env:
env["__PIO_TARGETS"] = {}
assert name not in env["__PIO_TARGETS"]
env["__PIO_TARGETS"][name] = dict(name=name,
title=title,
description=description,
group=group)
target = env.Alias(name, dependencies, actions)
if always_build:
AlwaysBuild(target)
return target
def __call__( self, env, libraries ):
if not self._add_dependents:
logger.warn( "BoostStaticLibrary() is deprecated, use BoostStaticLibs() or BoostStaticLib() instead" )
libraries = Flatten( [ libraries ] )
if not 'boost' in env['BUILD_WITH']:
env.BuildWith( 'boost' )
Boost = env['dependencies']['boost']( env )
logger.trace( "Build static libraries [{}]".format( colour_items( libraries ) ) )
library = BoostLibraryBuilder(
Boost,
add_dependents = self._add_dependents,
verbose_build = self._verbose_build,
verbose_config = self._verbose_config )( env, None, None, libraries, 'static' )
if self._build_always:
return AlwaysBuild( library )
else:
return library
def ZephyrBuildProgram(env):
env["LDSCRIPT_PATH"] = None
env.ProcessProgramDeps()
env.ProcessProjectDeps()
# append into the beginning a main LD script
env.Prepend(LINKFLAGS=["-T", "$LDSCRIPT_PATH"])
# enable "cyclic reference" for linker
if env.get("LIBS") and env.GetCompilerType() == "gcc":
env.Prepend(_LIBFLAGS="-Wl,--start-group ")
env.Append(_LIBFLAGS=" -Wl,--end-group")
program_pre = env.Program(os.path.join("$BUILD_DIR", "firmware-pre"),
env["PIOBUILDFILES"],
LDSCRIPT_PATH=os.path.join(
"$BUILD_DIR", "zephyr", "linker.cmd"))
# Force execution of offset header target before compiling project sources
env.Depends(env["PIOBUILDFILES"], env["__ZEPHYR_OFFSET_HEADER_CMD"])
program = env.Program(os.path.join("$BUILD_DIR", env.subst("$PROGNAME")),
env["PIOBUILDFILES"] +
env["_EXTRA_ZEPHYR_PIOBUILDFILES"],
LDSCRIPT_PATH=os.path.join("$BUILD_DIR", "zephyr",
"linker_pass_final.cmd"))
env.Replace(PIOMAINPROG=program)
AlwaysBuild(
env.Alias(
"checkprogsize",
program,
env.VerboseAction(env.CheckUploadSize,
"Checking size $PIOMAINPROG"),
))
print("Building in %s mode" % env.GetBuildType())
return program
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,
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])
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])
#
# 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
#
AlwaysBuild(env.Alias("test", [target_firm, target_size]))
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 )
# 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
#
from SCons.Script import ARGUMENTS, AlwaysBuild
Import('env')
# Run the linker with "-g", to prevent stripping of debugging symbols
env.Append(
LINKFLAGS=[
"-g"
]
)
# Don't try to upload the firmware
env.Replace(UPLOADHEXCMD="echo Upload is not supported for ${PIOENV}. Skipping")
pioenv = env.get("PIOENV")
progname = env.get("PROGNAME")
def simulate_callback(*args, **kwargs):
env.Execute("./simduino/simduino .pioenvs/" + pioenv + "/" + progname + ".elf")
AlwaysBuild(env.Alias("simulate", "", simulate_callback))
if "zephyr" in pioframework:
env.SConscript(
join(platform.get_package_dir(
"framework-zephyr"), "scripts", "platformio", "platformio-build-pre.py"),
exports={"env": env}
)
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_elf = join("$BUILD_DIR", "${PROGNAME}.elf")
target_hex = join("$BUILD_DIR", "${PROGNAME}.hex")
else:
target_elf = env.BuildProgram()
target_hex = env.ElfToHex(join("$BUILD_DIR", "${PROGNAME}"), target_elf)
AlwaysBuild(env.Alias("nobuild", target_hex))
target_buildprog = env.Alias("buildprog", target_hex, target_hex)
#
# 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
#
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)
'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',
src_suffix='.v')
def show_progress(env):
import sys
from SCons.Script import Progress, Command, AlwaysBuild
screen = sys.stdout
# Progress reporting is not available in non-TTY environments since it
# messes with the output (for example, when writing to a file)
show_progress = env["progress"] and sys.stdout.isatty()
node_count = 0
node_count_max = 0
node_count_interval = 1
node_count_fname = str(env.Dir("#")) + "/.scons_node_count"
import time, math
class cache_progress:
# The default is 1 GB cache and 12 hours half life
def __init__(self, path=None, limit=1073741824, half_life=43200):
self.path = path
self.limit = limit
self.exponent_scale = math.log(2) / half_life
if env["verbose"] and path != None:
screen.write(
"Current cache limit is {} (used: {})\n".format(
self.convert_size(limit), self.convert_size(self.get_size(path))
)
)
self.delete(self.file_list())
def __call__(self, node, *args, **kw):
nonlocal node_count, node_count_max, node_count_interval, node_count_fname, show_progress
if show_progress:
# Print the progress percentage
node_count += node_count_interval
if node_count_max > 0 and node_count <= node_count_max:
screen.write("\r[%3d%%] " % (node_count * 100 / node_count_max))
screen.flush()
elif node_count_max > 0 and node_count > node_count_max:
screen.write("\r[100%] ")
screen.flush()
else:
screen.write("\r[Initial build] ")
screen.flush()
def delete(self, files):
if len(files) == 0:
return
if env["verbose"]:
# Utter something
screen.write("\rPurging %d %s from cache...\n" % (len(files), len(files) > 1 and "files" or "file"))
[os.remove(f) for f in files]
def file_list(self):
if self.path is None:
# Nothing to do
return []
# Gather a list of (filename, (size, atime)) within the
# cache directory
file_stat = [(x, os.stat(x)[6:8]) for x in glob.glob(os.path.join(self.path, "*", "*"))]
if file_stat == []:
# Nothing to do
return []
# Weight the cache files by size (assumed to be roughly
# proportional to the recompilation time) times an exponential
# decay since the ctime, and return a list with the entries
# (filename, size, weight).
current_time = time.time()
file_stat = [(x[0], x[1][0], (current_time - x[1][1])) for x in file_stat]
# Sort by the most recently accessed files (most sensible to keep) first
file_stat.sort(key=lambda x: x[2])
# Search for the first entry where the storage limit is
# reached
sum, mark = 0, None
for i, x in enumerate(file_stat):
sum += x[1]
if sum > self.limit:
mark = i
break
if mark is None:
return []
else:
return [x[0] for x in file_stat[mark:]]
def convert_size(self, size_bytes):
if size_bytes == 0:
return "0 bytes"
size_name = ("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
i = int(math.floor(math.log(size_bytes, 1024)))
p = math.pow(1024, i)
s = round(size_bytes / p, 2)
return "%s %s" % (int(s) if i == 0 else s, size_name[i])
def get_size(self, start_path="."):
total_size = 0
for dirpath, dirnames, filenames in os.walk(start_path):
for f in filenames:
fp = os.path.join(dirpath, f)
total_size += os.path.getsize(fp)
return total_size
def progress_finish(target, source, env):
nonlocal node_count, progressor
try:
with open(node_count_fname, "w") as f:
f.write("%d\n" % node_count)
progressor.delete(progressor.file_list())
except Exception:
pass
try:
with open(node_count_fname) as f:
node_count_max = int(f.readline())
except Exception:
pass
cache_directory = os.environ.get("SCONS_CACHE")
# Simple cache pruning, attached to SCons' progress callback. Trim the
# cache directory to a size not larger than cache_limit.
cache_limit = float(os.getenv("SCONS_CACHE_LIMIT", 1024)) * 1024 * 1024
progressor = cache_progress(cache_directory, cache_limit)
Progress(progressor, interval=node_count_interval)
progress_finish_command = Command("progress_finish", [], progress_finish)
AlwaysBuild(progress_finish_command)
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 Victor Fragoso >>>>>>>>>>>>")
####################################################
# 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)
#### vffs ####
print "Building project"
print os.getcwd()
userpath = (os.path.expanduser('~'))
platformiopath = (userpath + "\\.platformio")
# 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",
# 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 )
)
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# Target: Build the .hex or SPIFFS image
#
if set(["uploadfs", "uploadfsota"]) & set(COMMAND_LINE_TARGETS):
target_firm = env.DataToBin(
join("$BUILD_DIR", "spiffs"), "$PROJECTDATA_DIR")
AlwaysBuild(target_firm)
elif "uploadlazy" in COMMAND_LINE_TARGETS:
if "PIOFRAMEWORK" not in env:
target_firm = [
join("$BUILD_DIR", "firmware_00000.bin"),
join("$BUILD_DIR", "firmware_40000.bin")
]
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: 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"))
"-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
#
["$OBJDUMP", "-S", "-d", "$SOURCES", ">$TARGET"]),
suffix=".lst"),
ElfToHex=Builder(action=env.VerboseAction(
" ".join(
["$OBJCOPY", "-O", "ihex", "$SOURCES", "$TARGET"]),
"Building $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()
AlwaysBuild(target_elf)
#
# Target: Build the .bin file
#
_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)
)
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
#
#
# 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)
def BuildProgram(env):
def _append_pio_macros():
env.AppendUnique(CPPDEFINES=[("PLATFORMIO",
int("{0:02d}{1:02d}{2:02d}".format(
*pioversion_to_intstr())))])
_append_pio_macros()
# fix ASM handling under non-casitive OS
if not case_sensitive_suffixes(".s", ".S"):
env.Replace(AS="$CC", ASCOM="$ASPPCOM")
if "__debug" in COMMAND_LINE_TARGETS:
env.ProcessDebug()
# process extra flags from board
if "BOARD" in env and "build.extra_flags" in env.BoardConfig():
env.ProcessFlags(env.BoardConfig().get("build.extra_flags"))
# remove base flags
env.ProcessUnFlags(env.get("BUILD_UNFLAGS"))
# apply user flags
env.ProcessFlags(env.get("BUILD_FLAGS"))
# process framework scripts
env.BuildFrameworks(env.get("PIOFRAMEWORK"))
# restore PIO macros if it was deleted by framework
_append_pio_macros()
# build dependent libs
env.Append(LIBS=env.BuildProjectLibraries())
# 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"'])
# enable "cyclic reference" for linker
if env.get("LIBS") and env.GetCompilerType() == "gcc":
env.Prepend(_LIBFLAGS="-Wl,--start-group ")
env.Append(_LIBFLAGS=" -Wl,--end-group")
# Handle SRC_BUILD_FLAGS
env.ProcessFlags(env.get("SRC_BUILD_FLAGS"))
env.Append(LIBPATH=["$BUILD_DIR"],
PIOBUILDFILES=env.CollectBuildFiles(
"$BUILDSRC_DIR",
"$PROJECTSRC_DIR",
src_filter=env.get("SRC_FILTER"),
duplicate=False))
if "__test" in COMMAND_LINE_TARGETS:
env.Append(PIOBUILDFILES=env.ProcessTest())
if not env['PIOBUILDFILES'] and not COMMAND_LINE_TARGETS:
sys.stderr.write(
"Error: Nothing to build. Please put your source code files "
"to '%s' folder\n" % env.subst("$PROJECTSRC_DIR"))
env.Exit(1)
program = env.Program(join("$BUILD_DIR", env.subst("$PROGNAME")),
env['PIOBUILDFILES'])
checksize_action = Action(env.CheckUploadSize, "Checking program size")
AlwaysBuild(env.Alias("checkprogsize", program, checksize_action))
if set(["upload", "program"]) & set(COMMAND_LINE_TARGETS):
env.AddPostAction(program, checksize_action)
return program
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
#
