def main():
"""Entry Point"""
try:
# Parse Options
parser = ArgumentParser()
parser.add_argument("-S", "--supported-toolchains",
action="store_true",
dest="supported_toolchains",
default=False,
help="Displays supported matrix of"
" targets and toolchains")
parser.add_argument('-f', '--filter',
dest='general_filter_regex',
default=None,
help='Filter targets')
parser.add_argument("-v", "--verbose",
action="store_true",
dest="verbose",
default=False,
help="Verbose diagnostic output")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
print(mcu_toolchain_matrix(
platform_filter=options.general_filter_regex))
exit(0)
# If auto_detect attribute is present, we assume other auto-detection
# parameters like 'toolchains_filter' are also set.
muts = get_autodetected_MUTS_list()
mcu_filter = options.general_filter_regex or ".*"
count = 0
for mut in muts.values():
if re.match(mcu_filter, mut['mcu'] or "Unknown"):
interface_version = get_interface_version(mut['disk'])
print("")
print("[mbed] Detected %s, port %s, mounted %s, interface "
"version %s:" %
(mut['mcu'], mut['port'], mut['disk'], interface_version))
print("[mbed] Supported toolchains for %s" % mut['mcu'])
print(mcu_toolchain_matrix(platform_filter=mut['mcu']))
count += 1
if count == 0:
print("[mbed] No mbed targets were detected on your system.")
except KeyboardInterrupt:
print("\n[CTRL+c] exit")
except Exception as exc:
import traceback
traceback.print_exc(file=sys.stdout)
print("[ERROR] %s" % str(exc))
sys.exit(1)
def main():
"""Entry Point"""
try:
# Parse Options
parser = ArgumentParser()
parser.add_argument("-S", "--supported-toolchains",
action="store_true",
dest="supported_toolchains",
default=False,
help="Displays supported matrix of"
" targets and toolchains")
parser.add_argument('-f', '--filter',
dest='general_filter_regex',
default=None,
help='Filter targets')
parser.add_argument("-v", "--verbose",
action="store_true",
dest="verbose",
default=False,
help="Verbose diagnostic output")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
print(mcu_toolchain_matrix(
platform_filter=options.general_filter_regex))
exit(0)
# If auto_detect attribute is present, we assume other auto-detection
# parameters like 'toolchains_filter' are also set.
muts = get_autodetected_MUTS_list()
mcu_filter = options.general_filter_regex or ".*"
count = 0
for mut in muts.values():
if re.match(mcu_filter, mut['mcu'] or "Unknown"):
interface_version = get_interface_version(mut['disk'])
print("")
print("[mbed] Detected %s, port %s, mounted %s, interface "
"version %s:" %
(mut['mcu'], mut['port'], mut['disk'], interface_version))
print("[mbed] Supported toolchains for %s" % mut['mcu'])
print(mcu_toolchain_matrix(platform_filter=mut['mcu']))
count += 1
if count == 0:
print("[mbed] No mbed targets were detected on your system.")
except KeyboardInterrupt:
print("\n[CTRL+c] exit")
except Exception as exc:
import traceback
traceback.print_exc(file=sys.stdout)
print("[ERROR] %s" % str(exc))
sys.exit(1)
help="Dump build_data to this file")
# Specify a different linker script
parser.add_argument("-l",
"--linker",
dest="linker_script",
type=argparse_filestring_type,
default=None,
help="use the specified linker script")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
if options.supported_toolchains == "matrix":
print mcu_toolchain_matrix(
platform_filter=options.general_filter_regex)
elif options.supported_toolchains == "toolchains":
toolchain_list = mcu_toolchain_list()
# Only print the lines that matter
for line in toolchain_list.split("\n"):
if not "mbed" in line:
print line
elif options.supported_toolchains == "targets":
print mcu_target_list()
exit(0)
# Print available tests in order and exit
if options.list_tests is True:
print '\n'.join(map(str, sorted(TEST_MAP.values())))
sys.exit()
action="store_true",
dest="silent",
default=False,
help="Silent diagnostic output (no copy, compile notification)")
parser.add_argument("-x", "--extra-verbose-notifications",
action="store_true",
dest="extra_verbose_notify",
default=False,
help="Makes compiler more verbose, CI friendly.")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
print mcu_toolchain_matrix(platform_filter=options.general_filter_regex)
exit(0)
# Get target list
targets = options.mcu if options.mcu else TARGET_NAMES
# Get toolchains list
toolchains = options.tool if options.tool else TOOLCHAINS
if options.color:
# This import happens late to prevent initializing colorization when we don't need it
import colorize
if options.verbose:
notify = mbedToolchain.print_notify_verbose
else:
notify = mbedToolchain.print_notify
if opts.test_case_report:
test_case_report_cols = [
'id', 'automated', 'description', 'peripherals', 'host_test',
'duration', 'source_dir'
]
print(
get_avail_tests_summary_table(
cols=test_case_report_cols,
result_summary=False,
join_delim='\n',
platform_filter=opts.general_filter_regex))
exit(0)
# Only prints matrix of supported toolchains
if opts.supported_toolchains:
print(mcu_toolchain_matrix(platform_filter=opts.general_filter_regex))
exit(0)
test_spec = None
MUTs = None
if hasattr(opts, 'auto_detect') and opts.auto_detect:
# If auto_detect attribute is present, we assume other auto-detection
# parameters like 'toolchains_filter' are also set.
print("MBEDLS: Detecting connected mbed-enabled devices... ")
MUTs = get_autodetected_MUTS_list()
for mut in MUTs.values():
print("MBEDLS: Detected %s, port: %s, mounted: %s" %
(mut['mcu_unique'] if 'mcu_unique' in mut else mut['mcu'],
def main():
start = time()
# Parse Options
parser = get_default_options_parser()
parser.add_argument("--source", dest="source_dir", type=argparse_filestring_type,
default=None, help="The source (input) directory", action="append")
parser.add_argument("--build", dest="build_dir", type=argparse_dir_not_parent(ROOT),
default=None, help="The build (output) directory")
parser.add_argument("--no-archive", dest="no_archive", action="store_true",
default=False, help="Do not produce archive (.ar) file, but rather .o")
# Extra libraries
parser.add_argument("-r", "--rtos",
action="store_true",
dest="rtos",
default=False,
help="Compile the rtos")
parser.add_argument("--rpc",
action="store_true",
dest="rpc",
default=False,
help="Compile the rpc library")
parser.add_argument("-u", "--usb",
action="store_true",
dest="usb",
default=False,
help="Compile the USB Device library")
parser.add_argument("-d", "--dsp",
action="store_true",
dest="dsp",
default=False,
help="Compile the DSP library")
parser.add_argument( "--cpputest",
action="store_true",
dest="cpputest_lib",
default=False,
help="Compiles 'cpputest' unit test library (library should be on the same directory level as mbed repository)")
parser.add_argument("-D",
action="append",
dest="macros",
help="Add a macro definition")
parser.add_argument("-S", "--supported-toolchains",
action="store_true",
dest="supported_toolchains",
default=False,
help="Displays supported matrix of MCUs and toolchains")
parser.add_argument('-f', '--filter',
dest='general_filter_regex',
default=None,
help='For some commands you can use filter to filter out results')
parser.add_argument("-j", "--jobs", type=int, dest="jobs",
default=0, help="Number of concurrent jobs. Default: 0/auto (based on host machine's number of CPUs)")
parser.add_argument("-N", "--artifact-name", dest="artifact_name",
default=None, help="The built project's name")
parser.add_argument("-v", "--verbose",
action="store_true",
dest="verbose",
default=False,
help="Verbose diagnostic output")
parser.add_argument("--silent",
action="store_true",
dest="silent",
default=False,
help="Silent diagnostic output (no copy, compile notification)")
parser.add_argument("-x", "--extra-verbose-notifications",
action="store_true",
dest="extra_verbose_notify",
default=False,
help="Makes compiler more verbose, CI friendly.")
parser.add_argument("--ignore", dest="ignore", type=argparse_many(str),
default=None, help="Comma separated list of patterns to add to mbedignore (eg. ./main.cpp)")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
print(mcu_toolchain_matrix(platform_filter=options.general_filter_regex))
exit(0)
# Get target list
targets = extract_mcus(parser, options) if options.mcu else TARGET_NAMES
# Get toolchains list
toolchains = options.tool if options.tool else TOOLCHAINS
if options.source_dir and not options.build_dir:
args_error(parser, "argument --build is required by argument --source")
# Get libraries list
libraries = []
# Additional Libraries
if options.rpc:
libraries.extend(["rpc"])
if options.usb:
libraries.append("usb")
if options.dsp:
libraries.extend(["dsp"])
if options.cpputest_lib:
libraries.extend(["cpputest"])
# Build results
failures = []
successes = []
skipped = []
end_warnings = []
if options.clean:
clean_psa_autogen()
for toolchain in toolchains:
for target_name in targets:
target = Target.get_target(target_name)
try:
toolchain_name, internal_tc_name, end_warnings = find_valid_toolchain(
target, toolchain
)
except NoValidToolchainException as e:
print_end_warnings(e.end_warnings)
args_error(parser, str(e))
tt_id = "%s::%s" % (internal_tc_name, target_name)
if not target_supports_toolchain(target, toolchain_name):
# Log this later
print("%s skipped: toolchain not supported" % tt_id)
skipped.append(tt_id)
else:
try:
notifier = TerminalNotifier(options.verbose, options.silent)
profile = extract_profile(parser, options, internal_tc_name)
if options.source_dir:
if target.is_PSA_target:
generate_psa_sources(
source_dirs=options.source_dir,
ignore_paths=[options.build_dir]
)
resource_filter = None
if target.is_PSA_secure_target:
resource_filter = OsAndSpeResourceFilter()
lib_build_res = build_library(
options.source_dir, options.build_dir, target, toolchain_name,
jobs=options.jobs,
clean=options.clean,
archive=(not options.no_archive),
macros=options.macros,
name=options.artifact_name,
build_profile=profile,
ignore=options.ignore,
notify=notifier,
resource_filter=resource_filter
)
else:
lib_build_res = build_mbed_libs(
target, toolchain_name,
jobs=options.jobs,
clean=options.clean,
macros=options.macros,
build_profile=profile,
ignore=options.ignore,
notify=notifier,
)
for lib_id in libraries:
build_lib(
lib_id, target, toolchain_name,
clean=options.clean,
macros=options.macros,
jobs=options.jobs,
build_profile=profile,
ignore=options.ignore,
)
if lib_build_res:
successes.append(tt_id)
else:
skipped.append(tt_id)
except KeyboardInterrupt as e:
print("\n[CTRL+c] exit")
print_end_warnings(end_warnings)
sys.exit(0)
except Exception as e:
if options.verbose:
import traceback
traceback.print_exc(file=sys.stdout)
print_end_warnings(end_warnings)
sys.exit(1)
failures.append(tt_id)
print(e)
# Write summary of the builds
print("\nCompleted in: (%.2f)s\n" % (time() - start))
for report, report_name in [(successes, "Build successes:"),
(skipped, "Build skipped:"),
(failures, "Build failures:"),
]:
if report:
print(print_build_results(report, report_name))
print_end_warnings(end_warnings)
if failures:
sys.exit(1)
dest='general_filter_regex',
default=None,
help='Filter targets')
parser.add_argument("-v",
"--verbose",
action="store_true",
dest="verbose",
default=False,
help="Verbose diagnostic output")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
print mcu_toolchain_matrix(
platform_filter=options.general_filter_regex)
exit(0)
# If auto_detect attribute is present, we assume other auto-detection
# parameters like 'toolchains_filter' are also set.
MUTs = get_autodetected_MUTS_list()
count = 0
for mut in MUTs.values():
print ""
print "[mbed] Detected %s, port %s, mounted %s" % (
mut['mcu'], mut['port'], mut['disk'])
print "[mbed] Supported toolchains for %s" % mut['mcu']
print mcu_toolchain_matrix(platform_filter=r'^' + mut['mcu'] + '$')
count += 1
# Specify a different linker script
parser.add_argument("-l",
"--linker",
dest="linker_script",
type=argparse_filestring_type,
default=None,
help="use the specified linker script")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
if options.supported_toolchains == "matrix":
print(
mcu_toolchain_matrix(
platform_filter=options.general_filter_regex,
release_version=None))
elif options.supported_toolchains == "toolchains":
toolchain_list = mcu_toolchain_list()
# Only print the lines that matter
for line in toolchain_list.split("\n"):
if not "mbed" in line:
print(line)
elif options.supported_toolchains == "targets":
print(mcu_target_list())
exit(0)
# Print available tests in order and exit
if options.list_tests is True:
print('\n'.join(map(str, sorted(TEST_MAP.values()))))
sys.exit()
def main():
# Parse Options
parser = get_default_options_parser(add_app_config=True)
group = parser.add_mutually_exclusive_group(required=False)
group.add_argument("-p",
type=argparse_many(test_known),
dest="program",
help="The index of the desired test program: [0-%d]" %
(len(TESTS) - 1))
group.add_argument("-n",
type=argparse_many(test_name_known),
dest="program",
help="The name of the desired test program")
group.add_argument("-L",
"--list-tests",
action="store_true",
dest="list_tests",
default=False,
help="List available tests in order and exit")
group.add_argument("-S",
"--supported-toolchains",
dest="supported_toolchains",
default=False,
const="matrix",
choices=["matrix", "toolchains", "targets"],
nargs="?",
help="Displays supported matrix of MCUs and toolchains")
parser.add_argument("-j",
"--jobs",
type=int,
dest="jobs",
default=0,
help="Number of concurrent jobs. Default: 0/auto "
"(based on host machine's number of CPUs)")
parser.add_argument("-v",
"--verbose",
action="store_true",
dest="verbose",
default=False,
help="Verbose diagnostic output")
parser.add_argument(
"--silent",
action="store_true",
dest="silent",
default=False,
help="Silent diagnostic output (no copy, compile notification)")
parser.add_argument("-D",
action="append",
dest="macros",
help="Add a macro definition")
parser.add_argument(
'-f',
'--filter',
dest='general_filter_regex',
default=None,
help='For some commands you can use filter to filter out results')
parser.add_argument("--stats-depth",
type=int,
dest="stats_depth",
default=2,
help="Depth level for static memory report")
parser.add_argument("--automated",
action="store_true",
dest="automated",
default=False,
help="Automated test")
parser.add_argument("--host",
dest="host_test",
default=None,
help="Host test")
parser.add_argument("--extra",
dest="extra",
default=None,
help="Extra files")
parser.add_argument("--peripherals",
dest="peripherals",
default=None,
help="Required peripherals")
parser.add_argument("--dep",
dest="dependencies",
default=None,
help="Dependencies")
parser.add_argument("--source",
dest="source_dir",
type=argparse_filestring_type,
default=None,
action="append",
help="The source (input) directory")
parser.add_argument("--duration",
type=int,
dest="duration",
default=None,
help="Duration of the test")
parser.add_argument("--build",
dest="build_dir",
type=argparse_dir_not_parent(ROOT),
default=None,
help="The build (output) directory")
parser.add_argument("-N",
"--artifact-name",
dest="artifact_name",
default=None,
help="The built project's name")
parser.add_argument(
"--ignore",
dest="ignore",
type=argparse_many(str),
default=None,
help="Comma separated list of patterns to add to mbedignore "
"(eg. ./main.cpp)")
parser.add_argument("-b",
"--baud",
type=int,
dest="baud",
default=None,
help="The mbed serial baud rate")
parser.add_argument("--rpc",
action="store_true",
dest="rpc",
default=False,
help="Link with RPC library")
parser.add_argument("--usb",
action="store_true",
dest="usb",
default=False,
help="Link with USB Device library")
parser.add_argument("--dsp",
action="store_true",
dest="dsp",
default=False,
help="Link with DSP library")
parser.add_argument("--testlib",
action="store_true",
dest="testlib",
default=False,
help="Link with mbed test library")
parser.add_argument("--build-data",
dest="build_data",
default=None,
help="Dump build_data to this file")
parser.add_argument("-l",
"--linker",
dest="linker_script",
type=argparse_filestring_type,
default=None,
help="use the specified linker script")
options = parser.parse_args()
end_warnings = []
if options.supported_toolchains:
if options.supported_toolchains == "matrix":
print_large_string(
mcu_toolchain_matrix(
platform_filter=options.general_filter_regex,
release_version=None))
elif options.supported_toolchains == "toolchains":
print('\n'.join(get_toolchain_list()))
elif options.supported_toolchains == "targets":
print_large_string(mcu_target_list())
elif options.list_tests is True:
print('\n'.join(map(str, sorted(TEST_MAP.values()))))
else:
# Target
if options.mcu is None:
args_error(parser, "argument -m/--mcu is required")
mcu = extract_mcus(parser, options)[0]
# Toolchain
if options.tool is None:
args_error(parser, "argument -t/--tool is required")
toolchain = options.tool[0]
target = Target.get_target(mcu)
if (options.program is None) and (not options.source_dir):
args_error(parser, "one of -p, -n, or --source is required")
if options.source_dir and not options.build_dir:
args_error(
parser,
"argument --build is required when argument --source is provided"
)
notify = TerminalNotifier(options.verbose, options.silent,
options.color)
try:
toolchain_name, internal_tc_name, end_warnings = find_valid_toolchain(
target, toolchain)
except NoValidToolchainException as e:
print_end_warnings(e.end_warnings)
args_error(parser, str(e))
if options.source_dir is not None:
resource_filter = None
wrapped_build_project(options.source_dir,
options.build_dir,
mcu,
end_warnings,
options,
toolchain_name,
notify=notify,
build_profile=extract_profile(
parser, options, internal_tc_name),
resource_filter=resource_filter,
**default_args_dict(options))
else:
p = options.program
# If 'p' was set via -n to list of numbers make this a single element
# integer list
if not isinstance(p, list):
p = [p]
build_data_blob = {} if options.build_data else None
for test_no in p:
test = Test(test_no)
if options.automated is not None:
test.automated = options.automated
if options.dependencies is not None:
test.dependencies = options.dependencies
if options.host_test is not None:
test.host_test = options.host_test
if options.peripherals is not None:
test.peripherals = options.peripherals
if options.duration is not None:
test.duration = options.duration
if options.extra is not None:
test.extra_files = options.extra
if not test.is_supported(mcu, toolchain):
print('The selected test is not supported on target '
'%s with toolchain %s' % (mcu, toolchain))
sys.exit()
# Linking with extra libraries
if options.rpc:
test.dependencies.append(RPC_LIBRARY)
if options.usb:
test.dependencies.append(USB_LIBRARIES)
if options.dsp:
test.dependencies.append(DSP_LIBRARIES)
if options.testlib:
test.dependencies.append(TEST_MBED_LIB)
build_dir = join(BUILD_DIR, "test", mcu, toolchain, test.id)
if options.build_dir is not None:
build_dir = options.build_dir
wrapped_build_project(test.source_dir,
build_dir,
mcu,
end_warnings,
options,
toolchain_name,
set(test.dependencies),
notify=notify,
report=build_data_blob,
inc_dirs=[dirname(MBED_LIBRARIES)],
build_profile=extract_profile(
parser, options, internal_tc_name),
**default_args_dict(options))
if options.build_data:
merge_build_data(options.build_data, build_data_blob,
"application")
parser.add_argument('-f', '--filter',
dest='general_filter_regex',
default=None,
help='Filter targets')
parser.add_argument("-v", "--verbose",
action="store_true",
dest="verbose",
default=False,
help="Verbose diagnostic output")
options = parser.parse_args()
# Only prints matrix of supported toolchains
if options.supported_toolchains:
print mcu_toolchain_matrix(platform_filter=options.general_filter_regex)
exit(0)
# If auto_detect attribute is present, we assume other auto-detection
# parameters like 'toolchains_filter' are also set.
MUTs = get_autodetected_MUTS_list()
count = 0
for mut in MUTs.values():
print ""
print "[mbed] Detected %s, port %s, mounted %s" % (mut['mcu'], mut['port'], mut['disk'])
print "[mbed] Supported toolchains for %s" % mut['mcu']
print mcu_toolchain_matrix(platform_filter=r'^'+mut['mcu']+'$')
count += 1
if count == 0:
