def autobuild_arm_program(elfname, test_dir=os.path.join('firmware', 'test'), patch=True):
"""
Build the an ARM module for all targets and build all unit tests. If pcb files are given, also build those.
"""
try:
#Build for all targets
family = utilities.get_family('module_settings.json')
family.for_all_targets(family.tile.short_name, lambda x: arm.build_program(family.tile, elfname, x, patch=patch))
#Build all unit tests
unit_test.build_units(os.path.join('firmware','test'), family.targets(family.tile.short_name))
Alias('release', os.path.join('build', 'output'))
Alias('test', os.path.join('build', 'test', 'output'))
Default(['release', 'test'])
autobuild_release(family)
if os.path.exists('doc'):
autobuild_documentation(family.tile)
except IOTileException as e:
print(e.format())
sys.exit(1)
def autobuild_release(family=None):
"""Copy necessary files into build/output so that this component can be used by others
Args:
family (ArchitectureGroup): The architecture group that we are targeting. If not
provided, it is assumed that we are building in the current directory and the
module_settings.json file is read to create an ArchitectureGroup
"""
if family is None:
family = utilities.get_family('module_settings.json')
env = Environment(tools=[])
env['TILE'] = family.tile
target = env.Command(['#build/output/module_settings.json'], ['#module_settings.json'], action=env.Action(create_release_settings_action, "Creating release manifest"))
env.AlwaysBuild(target)
# Copy over release notes if they exist
if os.path.exists('RELEASE.md'):
env.Command(['build/output/RELEASE.md'], ['RELEASE.md'], Copy("$TARGET", "$SOURCE"))
#Now copy across the build products that are not copied automatically
copy_include_dirs(family.tile)
copy_tilebus_definitions(family.tile)
copy_dependency_docs(family.tile)
copy_linker_scripts(family.tile)
# Allow users to specify a hide_dependency_images flag that does not copy over all firmware images
if not family.tile.settings.get('hide_dependency_images', False):
copy_dependency_images(family.tile)
copy_extra_files(family.tile)
build_python_distribution(family.tile)
def ensure_image_is_hex(input_path):
"""Return a path to a hex version of a firmware image.
If the input file is already in hex format then input_path
is returned and nothing is done. If it is not in hex format
then an SCons action is added to convert it to hex and the
target output file path is returned.
A cache is kept so that each file is only converted once.
Args:
input_path (str): A path to a firmware image.
Returns:
str: The path to a hex version of input_path, this may
be equal to input_path if it is already in hex format.
"""
family = utilities.get_family('module_settings.json')
target = family.platform_independent_target()
build_dir = target.build_dirs()['build']
if platform.system() == 'Windows':
env = Environment(tools=['mingw'], ENV=os.environ)
else:
env = Environment(tools=['default'], ENV=os.environ)
input_path = str(input_path)
image_name = os.path.basename(input_path)
root, ext = os.path.splitext(image_name)
if len(ext) == 0:
raise BuildError(
"Unknown file format or missing file extension in ensure_image_is_hex",
file_name=input_path)
file_format = ext[1:]
if file_format == 'hex':
return input_path
if file_format == 'elf':
new_file = os.path.join(build_dir, root + '.hex')
if new_file not in CONVERTED_HEX_FILES:
env.Command(new_file,
input_path,
action=Action(
"arm-none-eabi-objcopy -O ihex $SOURCE $TARGET",
"Creating intel hex file from: $SOURCE"))
CONVERTED_HEX_FILES.add(new_file)
return new_file
raise BuildError("Unknown file format extension in ensure_image_is_hex",
file_name=input_path,
extension=file_format)
def autobuild_docproject():
"""Autobuild a project that only contains documentation"""
try:
#Build only release information
family = utilities.get_family('module_settings.json')
autobuild_release(family)
autobuild_documentation(family.tile)
except unit_test.IOTileException as e:
print(e.format())
Exit(1)
def autobuild_onlycopy():
"""Autobuild a project that does not require building firmware, pcb or documentation
"""
try:
#Build only release information
family = utilities.get_family('module_settings.json')
autobuild_release(family)
Alias('release', os.path.join('build', 'output'))
Default(['release'])
except unit_test.IOTileException as e:
print(e.format())
Exit(1)
def autobuild_pic24(module, test_dir='test', modulefile=None, postprocess_hex=None):
"""
Build the given pic24 module for all targets.
"""
try:
family = utilities.get_family('mib24', modulefile=modulefile)
family.for_all_targets(module, lambda x: pic24.build_module(module, x, postprocess_hex=postprocess_hex))
Alias('release', os.path.join('build', 'output'))
Alias('test', os.path.join('build', 'test', 'output'))
Default('release')
except MoMoException as e:
print e.format()
sys.exit(1)
def autobuild_bootstrap_file(file_name, image_list):
"""Combine multiple firmware images into a single bootstrap hex file.
The files listed in image_list must be products of either this tile or any
dependency tile and should correspond exactly with the base name listed on
the products section of the module_settings.json file of the corresponding
tile. They must be listed as firmware_image type products.
This function keeps a global map of all of the intermediate files that it
has had to create so that we don't try to build them multiple times.
Args:
file_name(str): Full name of the output bootstrap hex file.
image_list(list of str): List of files that will be combined into a
single hex file that will be used to flash a chip.
"""
family = utilities.get_family('module_settings.json')
target = family.platform_independent_target()
resolver = ProductResolver.Create()
env = Environment(tools=[])
output_dir = target.build_dirs()['output']
build_dir = target.build_dirs()['build']
build_output_name = os.path.join(build_dir, file_name)
full_output_name = os.path.join(output_dir, file_name)
processed_input_images = []
for image_name in image_list:
image_info = resolver.find_unique('firmware_image', image_name)
image_path = image_info.full_path
hex_path = arm.ensure_image_is_hex(image_path)
processed_input_images.append(hex_path)
env.Command(
build_output_name,
processed_input_images,
action=Action(
arm.merge_hex_executables,
"Merging %d hex files into $TARGET" % len(processed_input_images)))
env.Command(full_output_name, build_output_name,
Copy("$TARGET", "$SOURCE"))
def autobuild_pic12(module, test_dir='test', modulefile=None):
"""
Build the given module for all targets and build all unit tests.
targets are determined from /config/build_settings.json using
the module name and the tests are found automatically and built
using their builtin metadata
"""
try:
family = utilities.get_family('mib12', modulefile=modulefile)
family.for_all_targets(module, lambda x: pic12.build_module(module, x))
unit_test.build_units(test_dir, family.targets(module))
Alias('release', os.path.join('build', 'output'))
Alias('test', os.path.join('build', 'test', 'output'))
Default('release')
except MoMoException as e:
print e.format()
sys.exit(1)
def autobuild_arm_library(libname):
try:
#Build for all targets
family = utilities.get_family('module_settings.json')
family.for_all_targets(family.tile.short_name, lambda x: arm.build_library(family.tile, libname, x))
#Build all unit tests
unit_test.build_units(os.path.join('firmware','test'), family.targets(family.tile.short_name))
Alias('release', os.path.join('build', 'output'))
Alias('test', os.path.join('build', 'test', 'output'))
Default(['release', 'test'])
autobuild_release(family)
if os.path.exists('doc'):
autobuild_documentation(family.tile)
except unit_test.IOTileException as e:
print(e.format())
Exit(1)
