Nicolas Borla
BBR 1 Ebene
Diff: mbed-os/tools/make.py
- Revision:
- 0:fbdae7e6d805
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-os/tools/make.py Mon May 14 11:29:06 2018 +0000
@@ -0,0 +1,335 @@
+#! /usr/bin/env python2
+"""
+mbed SDK
+Copyright (c) 2011-2013 ARM Limited
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+TEST BUILD & RUN
+"""
+from __future__ import print_function
+from builtins import str
+import sys
+import json
+from time import sleep
+from shutil import copy
+from os.path import join, abspath, dirname
+from json import load, dump
+
+# Be sure that the tools directory is in the search path
+ROOT = abspath(join(dirname(__file__), ".."))
+sys.path.insert(0, ROOT)
+
+from tools.utils import args_error
+from tools.utils import NotSupportedException
+from tools.paths import BUILD_DIR
+from tools.paths import MBED_LIBRARIES
+from tools.paths import RPC_LIBRARY
+from tools.paths import USB_LIBRARIES
+from tools.paths import DSP_LIBRARIES
+from tools.tests import TESTS, Test, TEST_MAP
+from tools.tests import TEST_MBED_LIB
+from tools.tests import test_known, test_name_known
+from tools.targets import TARGET_MAP
+from tools.options import get_default_options_parser
+from tools.options import extract_profile
+from tools.options import extract_mcus
+from tools.notifier.term import TerminalNotifier
+from tools.build_api import build_project
+from tools.build_api import mcu_toolchain_matrix
+from tools.build_api import mcu_toolchain_list
+from tools.build_api import mcu_target_list
+from tools.build_api import merge_build_data
+from utils import argparse_filestring_type
+from utils import argparse_many
+from utils import argparse_dir_not_parent
+from tools.toolchains import mbedToolchain, TOOLCHAIN_CLASSES, TOOLCHAIN_PATHS
+
+if __name__ == '__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")
+
+ 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")
+
+ 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(
+ '-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")
+
+ # Local run
+ 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, help="The source (input) directory", action="append")
+ 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("-d", "--disk", dest="disk",
+ default=None, help="The mbed disk")
+ parser.add_argument("-s", "--serial", dest="serial",
+ default=None, help="The mbed serial port")
+ parser.add_argument("-b", "--baud", type=int, dest="baud",
+ default=None, help="The mbed serial baud rate")
+ group.add_argument("-L", "--list-tests", action="store_true", dest="list_tests",
+ default=False, help="List available tests in order and exit")
+
+ # Ideally, all the tests with a single "main" thread can be run with, or
+ # without the usb, dsp
+ 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")
+
+ # 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()
+
+ # force program to "0" if a source dir is specified
+ if options.source_dir is not None:
+ p = 0
+ else:
+ # Program Number or name
+ p = options.program
+
+ # If 'p' was set via -n to list of numbers make this a single element integer list
+ if type(p) != type([]):
+ p = [p]
+
+ # 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]
+
+ 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)
+
+ if not TOOLCHAIN_CLASSES[toolchain].check_executable():
+ search_path = TOOLCHAIN_PATHS[toolchain] or "No path set"
+ args_error(parser, "Could not find executable for %s.\n"
+ "Currently set search path: %s"
+ %(toolchain, search_path))
+
+ # Test
+ 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.source_dir is not None:
+ test.source_dir = options.source_dir
+ build_dir = options.source_dir
+
+ if options.build_dir is not None:
+ build_dir = options.build_dir
+
+ try:
+ bin_file = build_project(test.source_dir, build_dir, mcu, toolchain,
+ set(test.dependencies),
+ linker_script=options.linker_script,
+ clean=options.clean,
+ notify=notify,
+ report=build_data_blob,
+ macros=options.macros,
+ jobs=options.jobs,
+ name=options.artifact_name,
+ app_config=options.app_config,
+ inc_dirs=[dirname(MBED_LIBRARIES)],
+ build_profile=extract_profile(parser,
+ options,
+ toolchain),
+ stats_depth=options.stats_depth)
+ print('Image: %s'% bin_file)
+
+ if options.disk:
+ # Simple copy to the mbed disk
+ copy(bin_file, options.disk)
+
+ if options.serial:
+ # Import pyserial: https://pypi.python.org/pypi/pyserial
+ from serial import Serial
+
+ sleep(TARGET_MAP[mcu].program_cycle_s)
+
+ serial = Serial(options.serial, timeout = 1)
+ if options.baud:
+ serial.setBaudrate(options.baud)
+
+ serial.flushInput()
+ serial.flushOutput()
+
+ try:
+ serial.sendBreak()
+ except:
+ # In linux a termios.error is raised in sendBreak and in setBreak.
+ # The following setBreak() is needed to release the reset signal on the target mcu.
+ try:
+ serial.setBreak(False)
+ except:
+ pass
+
+ while True:
+ c = serial.read(512)
+ sys.stdout.write(c)
+ sys.stdout.flush()
+
+ except KeyboardInterrupt as e:
+ print("\n[CTRL+c] exit")
+ except NotSupportedException as e:
+ print("\nCould not compile for %s: %s" % (mcu, str(e)))
+ except Exception as e:
+ if options.verbose:
+ import traceback
+ traceback.print_exc(file=sys.stdout)
+ else:
+ print("[ERROR] %s" % str(e))
+
+ sys.exit(1)
+ if options.build_data:
+ merge_build_data(options.build_data, build_data_blob, "application")