def __init__(self, manifest_path): self.manifest_path = manifest_path self.silent = False self.verbose = False self._manifest = fs.load_json(manifest_path) self._BOARDS_CACHE = {} self._custom_packages = None self.config = ProjectConfig.get_instance() self.pm = ToolPackageManager(self.config.get_optional_dir("packages"))
def __init__(self): config = ProjectConfig.get_instance() packages_dir = config.get_optional_dir("packages") super(CorePackageManager, self).__init__( packages_dir, [ "https://dl.bintray.com/platformio/dl-packages/manifest.json", "http%s://dl.platformio.org/packages/manifest.json" % ("" if sys.version_info < (2, 7, 9) else "s"), ], )
def __init__(self, package_dir=None, repositories=None): if not repositories: repositories = [ "https://dl.bintray.com/platformio/dl-platforms/manifest.json", "{0}://dl.platformio.org/platforms/manifest.json".format( "https" if app.get_setting("strict_ssl") else "http"), ] self.config = ProjectConfig.get_instance() BasePkgManager.__init__( self, package_dir or self.config.get_optional_dir("platforms"), repositories)
def cli(ctx, **options): storage_cmds = ("install", "uninstall", "update", "list") # skip commands that don't need storage folder if ctx.invoked_subcommand not in storage_cmds or ( len(ctx.args) == 2 and ctx.args[1] in ("-h", "--help") ): return storage_dirs = list(options["storage_dir"]) if options["global"]: storage_dirs.append(get_project_global_lib_dir()) if not storage_dirs: if is_platformio_project(): storage_dirs = [get_project_dir()] elif is_ci(): storage_dirs = [get_project_global_lib_dir()] click.secho( "Warning! Global library storage is used automatically. " "Please use `platformio lib --global %s` command to remove " "this warning." % ctx.invoked_subcommand, fg="yellow", ) if not storage_dirs: raise NotGlobalLibDir( get_project_dir(), get_project_global_lib_dir(), ctx.invoked_subcommand ) in_silence = PlatformioCLI.in_silence() ctx.meta[CTX_META_PROJECT_ENVIRONMENTS_KEY] = options["environment"] ctx.meta[CTX_META_INPUT_DIRS_KEY] = storage_dirs ctx.meta[CTX_META_STORAGE_DIRS_KEY] = [] ctx.meta[CTX_META_STORAGE_LIBDEPS_KEY] = {} for storage_dir in storage_dirs: if not is_platformio_project(storage_dir): ctx.meta[CTX_META_STORAGE_DIRS_KEY].append(storage_dir) continue with fs.cd(storage_dir): config = ProjectConfig.get_instance( os.path.join(storage_dir, "platformio.ini") ) config.validate(options["environment"], silent=in_silence) libdeps_dir = config.get_optional_dir("libdeps") for env in config.envs(): if options["environment"] and env not in options["environment"]: continue storage_dir = os.path.join(libdeps_dir, env) ctx.meta[CTX_META_STORAGE_DIRS_KEY].append(storage_dir) ctx.meta[CTX_META_STORAGE_LIBDEPS_KEY][storage_dir] = config.get( "env:" + env, "lib_deps", [] )
def __init__(self, options=None): """ Called by PlatformIO to pass context """ miniterm.Transform.__init__(self) self.options = options or {} self.project_dir = self.options.get("project_dir") self.environment = self.options.get("environment") self.config = ProjectConfig.get_instance() if not self.environment: default_envs = self.config.default_envs() if default_envs: self.environment = default_envs[0] elif self.config.envs(): self.environment = self.config.envs()[0]
def add_project_items(self, psync): with util.cd(self.options["project_dir"]): cfg = ProjectConfig.get_instance( os.path.join(self.options["project_dir"], "platformio.ini")) psync.add_item(cfg.path, "platformio.ini") psync.add_item(cfg.get_optional_dir("shared"), "shared") psync.add_item(cfg.get_optional_dir("boards"), "boards") if self.options["force_remote"]: self._add_project_source_items(cfg, psync) else: self._add_project_binary_items(cfg, psync) if self.command == "test": psync.add_item(cfg.get_optional_dir("test"), "test")
def __init__(self, manifest_path): self.manifest_path = manifest_path self.silent = False self.verbose = False self._manifest = fs.load_json(manifest_path) self._BOARDS_CACHE = {} self._custom_packages = None self.config = ProjectConfig.get_instance() self.pm = PackageManager(self.config.get_optional_dir("packages"), self.package_repositories) self._src_manifest = None src_manifest_path = self.pm.get_src_manifest_path(self.get_dir()) if src_manifest_path: self._src_manifest = fs.load_json(src_manifest_path)
def get_project_optional_dir(name, default=None): project_dir = get_project_dir() config = ProjectConfig.get_instance(join(project_dir, "platformio.ini")) optional_dir = config.get("platformio", name) if not optional_dir: return default if "$PROJECT_HASH" in optional_dir: optional_dir = optional_dir.replace( "$PROJECT_HASH", "%s-%s" % (basename(project_dir), sha1( hashlib_encode_data(project_dir)).hexdigest()[:10])) if optional_dir.startswith("~"): optional_dir = expanduser(optional_dir) return realpath(optional_dir)
def get_best_envname(project_dir, boards=None): config = ProjectConfig.get_instance(join(project_dir, "platformio.ini")) config.validate() envname = None default_envs = config.default_envs() if default_envs: envname = default_envs[0] if not boards: return envname for env in config.envs(): if not boards: return env if not envname: envname = env items = config.items(env=env, as_dict=True) if "board" in items and items.get("board") in boards: return env return envname
def project_config(project_dir, json_output): if not is_platformio_project(project_dir): raise NotPlatformIOProjectError(project_dir) with fs.cd(project_dir): config = ProjectConfig.get_instance() if json_output: return click.echo(config.to_json()) click.echo("Computed project configuration for %s" % click.style(project_dir, fg="cyan")) for section, options in config.as_tuple(): click.secho(section, fg="cyan") click.echo("-" * len(section)) click.echo( tabulate( [(name, "=", "\n".join(value) if isinstance(value, list) else value) for name, value in options], tablefmt="plain", )) click.echo() return None
def save_project_libdeps(project_dir, specs, environments=None, action="add"): config = ProjectConfig.get_instance( os.path.join(project_dir, "platformio.ini")) config.validate(environments) for env in config.envs(): if environments and env not in environments: continue config.expand_interpolations = False lib_deps = [] try: lib_deps = ignore_deps_by_specs( config.get("env:" + env, "lib_deps"), specs) except InvalidProjectConfError: pass if action == "add": lib_deps.extend(spec.as_dependency() for spec in specs) if lib_deps: config.set("env:" + env, "lib_deps", lib_deps) elif config.has_option("env:" + env, "lib_deps"): config.remove_option("env:" + env, "lib_deps") config.save()
def __init__(self, package_dir=None): self.config = ProjectConfig.get_instance() super(LibraryManager, self).__init__(package_dir or self.config.get_optional_dir("globallib"))
def cli( environment, project_dir, project_conf, pattern, flags, severity, silent, verbose, json_output, fail_on_defect, skip_packages, ): app.set_session_var("custom_project_conf", project_conf) # find project directory on upper level if isfile(project_dir): project_dir = find_project_dir_above(project_dir) results = [] with fs.cd(project_dir): config = ProjectConfig.get_instance(project_conf) config.validate(environment) default_envs = config.default_envs() for envname in config.envs(): skipenv = any([ environment and envname not in environment, not environment and default_envs and envname not in default_envs, ]) env_options = config.items(env=envname, as_dict=True) env_dump = [] for k, v in env_options.items(): if k not in ("platform", "framework", "board"): continue env_dump.append( "%s: %s" % (k, ", ".join(v) if isinstance(v, list) else v)) default_patterns = [ config.get_optional_dir("src"), config.get_optional_dir("include"), ] tool_options = dict( verbose=verbose, silent=silent, patterns=pattern or env_options.get("check_patterns", default_patterns), flags=flags or env_options.get("check_flags"), severity=[ DefectItem.SEVERITY_LABELS[DefectItem.SEVERITY_HIGH] ] if silent else severity or config.get("env:" + envname, "check_severity"), skip_packages=skip_packages or env_options.get("check_skip_packages"), ) for tool in config.get("env:" + envname, "check_tool"): if skipenv: results.append({"env": envname, "tool": tool}) continue if not silent and not json_output: print_processing_header(tool, envname, env_dump) ct = CheckToolFactory.new(tool, project_dir, config, envname, tool_options) result = {"env": envname, "tool": tool, "duration": time()} rc = ct.check(on_defect_callback=None if ( json_output or verbose ) else lambda defect: click.echo(repr(defect))) result["defects"] = ct.get_defects() result["duration"] = time() - result["duration"] result["succeeded"] = rc == 0 if fail_on_defect: result["succeeded"] = rc == 0 and not any( DefectItem.SEVERITY_LABELS[ d.severity] in fail_on_defect for d in result["defects"]) result["stats"] = collect_component_stats(result) results.append(result) if verbose: click.echo("\n".join(repr(d) for d in result["defects"])) if not json_output and not silent: if rc != 0: click.echo("Error: %s failed to perform check! Please " "examine tool output in verbose mode." % tool) elif not result["defects"]: click.echo("No defects found") print_processing_footer(result) if json_output: click.echo(dump_json_to_unicode(results_to_json(results))) elif not silent: print_check_summary(results) command_failed = any(r.get("succeeded") is False for r in results) if command_failed: raise exception.ReturnErrorCode(1)
for env in cfg.envs(): platform = cfg.get("env:{}".format(env), "platform") if "espressif8266" in platform: yield {"chip": "esp8266", "env": env} elif "espressif32" in platform: yield {"chip": "esp32", "env": env} else: raise ValueError("Unknown `platform = {}` for `[env:{}]`".format( platform, env)) def filter_jobs(jobs, ignore=("spec_", )): for job in jobs: if job["env"].startswith(ignore): continue yield job if __name__ == "__main__": jobs = list(filter_jobs(get_jobs(ProjectConfig.get_instance()))) sort = [] for job in jobs: if job["chip"] == "esp8266": sort.append(job["env"]) sort.sort(key=str.casefold) serialized = json.dumps({"include": jobs}) print("::set-output name=matrix::{}".format(serialized))
def project_init( ctx, # pylint: disable=R0913 project_dir, board, ide, environment, project_option, env_prefix, silent, ): if not silent: if project_dir == os.getcwd(): click.secho("\nThe current working directory", fg="yellow", nl=False) click.secho(" %s " % project_dir, fg="cyan", nl=False) click.secho("will be used for the project.", fg="yellow") click.echo("") click.echo("The next files/directories have been created in %s" % click.style(project_dir, fg="cyan")) click.echo("%s - Put project header files here" % click.style("include", fg="cyan")) click.echo("%s - Put here project specific (private) libraries" % click.style("lib", fg="cyan")) click.echo("%s - Put project source files here" % click.style("src", fg="cyan")) click.echo("%s - Project Configuration File" % click.style("platformio.ini", fg="cyan")) is_new_project = not is_platformio_project(project_dir) if is_new_project: init_base_project(project_dir) if environment: update_project_env(project_dir, environment, project_option) elif board: update_board_envs(ctx, project_dir, board, project_option, env_prefix, ide is not None) if ide: with fs.cd(project_dir): config = ProjectConfig.get_instance( os.path.join(project_dir, "platformio.ini")) config.validate() pg = ProjectGenerator(config, environment or get_best_envname(config, board), ide) pg.generate() if is_new_project: init_cvs_ignore(project_dir) if silent: return if ide: click.secho( "\nProject has been successfully %s including configuration files " "for `%s` IDE." % ("initialized" if is_new_project else "updated", ide), fg="green", ) else: click.secho( "\nProject has been successfully %s! Useful commands:\n" "`pio run` - process/build project from the current directory\n" "`pio run --target upload` or `pio run -t upload` " "- upload firmware to a target\n" "`pio run --target clean` - clean project (remove compiled files)" "\n`pio run --help` - additional information" % ("initialized" if is_new_project else "updated"), fg="green", )
def __init__(self, package_dir=None): if not package_dir: package_dir = ProjectConfig.get_instance().get_optional_dir( "packages") super(ToolPackageManager, self).__init__(PackageType.TOOL, package_dir)
def cli( # pylint: disable=redefined-builtin ctx, environment, ignore, filter, upload_port, test_port, project_dir, project_conf, without_building, without_uploading, without_testing, no_reset, monitor_rts, monitor_dtr, verbose): with fs.cd(project_dir): test_dir = get_project_test_dir() if not isdir(test_dir): raise exception.TestDirNotExists(test_dir) test_names = get_test_names(test_dir) config = ProjectConfig.get_instance( project_conf or join(project_dir, "platformio.ini")) config.validate(envs=environment) click.echo("Verbose mode can be enabled via `-v, --verbose` option") click.secho("Collected %d items" % len(test_names), bold=True) results = [] default_envs = config.default_envs() for testname in test_names: for envname in config.envs(): section = "env:%s" % envname # filter and ignore patterns patterns = dict(filter=list(filter), ignore=list(ignore)) for key in patterns: patterns[key].extend( config.get(section, "test_%s" % key, [])) skip_conditions = [ environment and envname not in environment, not environment and default_envs and envname not in default_envs, testname != "*" and patterns['filter'] and not any([fnmatch(testname, p) for p in patterns['filter']]), testname != "*" and any([fnmatch(testname, p) for p in patterns['ignore']]), ] if any(skip_conditions): results.append({"env": envname, "test": testname}) continue click.echo() print_processing_header(testname, envname) cls = (NativeTestProcessor if config.get(section, "platform") == "native" else EmbeddedTestProcessor) tp = cls( ctx, testname, envname, dict(project_config=config, project_dir=project_dir, upload_port=upload_port, test_port=test_port, without_building=without_building, without_uploading=without_uploading, without_testing=without_testing, no_reset=no_reset, monitor_rts=monitor_rts, monitor_dtr=monitor_dtr, verbose=verbose)) result = { "env": envname, "test": testname, "duration": time(), "succeeded": tp.process() } result['duration'] = time() - result['duration'] results.append(result) print_processing_footer(result) if without_testing: return print_testing_summary(results) command_failed = any(r.get("succeeded") is False for r in results) if command_failed: raise exception.ReturnErrorCode(1)
def __init__(self, package_dir=None): self.config = ProjectConfig.get_instance() super(PlatformPackageManager, self).__init__( PackageType.PLATFORM, package_dir or self.config.get_optional_dir("platforms"), )
def get_project_cache_dir(): """ Deprecated, use ProjectConfig.get_optional_dir("cache") instead """ return ProjectConfig.get_instance(join( get_project_dir(), "platformio.ini")).get_optional_dir("cache")
Import("env") from platformio import util from platformio.project.helpers import get_project_build_dir, get_project_dir from platformio.project.config import ProjectConfig from os.path import basename, join, relpath, abspath, isfile, exists from os import environ import base64 import subprocess import re config = ProjectConfig.get_instance(join(get_project_dir(), "platformio.ini")) def get_envname(): return base64.b64decode(ARGUMENTS["PIOENV"]) envname = get_envname() print("PBD: %s, env : %s" % (relpath(get_project_build_dir()), envname)) def get_option(section, option, dft): if config.has_option(section, option): return config.get(section, option) else: return dft def get_env_option(name, default): return get_option("env:%s" % envname, name, default)
def cli( # pylint: disable=redefined-builtin ctx, environment, ignore, filter, upload_port, test_port, project_dir, project_conf, without_building, without_uploading, without_testing, no_reset, monitor_rts, monitor_dtr, verbose): with util.cd(project_dir): test_dir = get_project_test_dir() if not isdir(test_dir): raise exception.TestDirNotExists(test_dir) test_names = get_test_names(test_dir) config = ProjectConfig.get_instance( project_conf or join(project_dir, "platformio.ini")) config.validate(envs=environment) click.echo("Verbose mode can be enabled via `-v, --verbose` option") click.echo("Collected %d items" % len(test_names)) results = [] start_time = time() default_envs = config.default_envs() for testname in test_names: for envname in config.envs(): section = "env:%s" % envname # filter and ignore patterns patterns = dict(filter=list(filter), ignore=list(ignore)) for key in patterns: patterns[key].extend( config.get(section, "test_%s" % key, [])) skip_conditions = [ environment and envname not in environment, not environment and default_envs and envname not in default_envs, testname != "*" and patterns['filter'] and not any([fnmatch(testname, p) for p in patterns['filter']]), testname != "*" and any([fnmatch(testname, p) for p in patterns['ignore']]), ] if any(skip_conditions): results.append((None, testname, envname)) continue cls = (NativeTestProcessor if config.get(section, "platform") == "native" else EmbeddedTestProcessor) tp = cls( ctx, testname, envname, dict(project_config=config, project_dir=project_dir, upload_port=upload_port, test_port=test_port, without_building=without_building, without_uploading=without_uploading, without_testing=without_testing, no_reset=no_reset, monitor_rts=monitor_rts, monitor_dtr=monitor_dtr, verbose=verbose)) results.append((tp.process(), testname, envname)) if without_testing: return passed_nums = 0 failed_nums = 0 testname_max_len = max([len(r[1]) for r in results]) envname_max_len = max([len(click.style(r[2], fg="cyan")) for r in results]) print_header("[%s]" % click.style("TEST SUMMARY")) click.echo() for result in results: status, testname, envname = result if status is False: failed_nums += 1 status_str = click.style("FAILED", fg="red") elif status is None: status_str = click.style("IGNORED", fg="yellow") else: passed_nums += 1 status_str = click.style("PASSED", fg="green") format_str = "test/{:<%d} > {:<%d}\t[{}]" % (testname_max_len, envname_max_len) click.echo(format_str.format(testname, click.style(envname, fg="cyan"), status_str), err=status is False) print_header("%s%d passed in %.2f seconds" % ("%d failed, " % failed_nums if failed_nums else "", passed_nums, time() - start_time), is_error=failed_nums, fg="red" if failed_nums else "green") if failed_nums: raise exception.ReturnErrorCode(1)
def lib_install( # pylint: disable=too-many-arguments ctx, libraries, save, silent, interactive, force): storage_dirs = ctx.meta[CTX_META_STORAGE_DIRS_KEY] storage_libdeps = ctx.meta.get(CTX_META_STORAGE_LIBDEPS_KEY, []) installed_manifests = {} for storage_dir in storage_dirs: if not silent and (libraries or storage_dir in storage_libdeps): print_storage_header(storage_dirs, storage_dir) lm = LibraryManager(storage_dir) if libraries: for library in libraries: pkg_dir = lm.install(library, silent=silent, interactive=interactive, force=force) installed_manifests[library] = lm.load_manifest(pkg_dir) elif storage_dir in storage_libdeps: builtin_lib_storages = None for library in storage_libdeps[storage_dir]: try: pkg_dir = lm.install(library, silent=silent, interactive=interactive, force=force) installed_manifests[library] = lm.load_manifest(pkg_dir) except exception.LibNotFound as e: if builtin_lib_storages is None: builtin_lib_storages = get_builtin_libs() if not silent or not is_builtin_lib( builtin_lib_storages, library): click.secho("Warning! %s" % e, fg="yellow") if not save or not libraries: return input_dirs = ctx.meta.get(CTX_META_INPUT_DIRS_KEY, []) project_environments = ctx.meta[CTX_META_PROJECT_ENVIRONMENTS_KEY] for input_dir in input_dirs: config = ProjectConfig.get_instance( os.path.join(input_dir, "platformio.ini")) config.validate(project_environments) for env in config.envs(): if project_environments and env not in project_environments: continue config.expand_interpolations = False try: lib_deps = config.get("env:" + env, "lib_deps") except InvalidProjectConfError: lib_deps = [] for library in libraries: if library in lib_deps: continue manifest = installed_manifests[library] try: assert library.lower() == manifest["name"].lower() assert semantic_version.Version(manifest["version"]) lib_deps.append("{name}@^{version}".format(**manifest)) except (AssertionError, ValueError): lib_deps.append(library) config.set("env:" + env, "lib_deps", lib_deps) config.save()
def cli(ctx, project_dir, project_conf, environment, verbose, interface, __unprocessed): app.set_session_var("custom_project_conf", project_conf) # use env variables from Eclipse or CLion for sysenv in ("CWD", "PWD", "PLATFORMIO_PROJECT_DIR"): if is_platformio_project(project_dir): break if os.getenv(sysenv): project_dir = os.getenv(sysenv) with fs.cd(project_dir): config = ProjectConfig.get_instance(project_conf) config.validate(envs=[environment] if environment else None) env_name = environment or helpers.get_default_debug_env(config) env_options = config.items(env=env_name, as_dict=True) if not set(env_options.keys()) >= set(["platform", "board"]): raise ProjectEnvsNotAvailableError() debug_options = helpers.validate_debug_options(ctx, env_options) assert debug_options if not interface: return helpers.predebug_project(ctx, project_dir, env_name, False, verbose) configuration = load_project_ide_data(project_dir, env_name) if not configuration: raise DebugInvalidOptionsError("Could not load debug configuration") if "--version" in __unprocessed: result = proc.exec_command([configuration["gdb_path"], "--version"]) if result["returncode"] == 0: return click.echo(result["out"]) raise exception.PlatformioException("\n".join( [result["out"], result["err"]])) try: fs.ensure_udev_rules() except exception.InvalidUdevRules as e: click.echo( helpers.escape_gdbmi_stream("~", str(e) + "\n") if helpers.is_gdbmi_mode() else str(e) + "\n", nl=False, ) debug_options["load_cmds"] = helpers.configure_esp32_load_cmds( debug_options, configuration) rebuild_prog = False preload = debug_options["load_cmds"] == ["preload"] load_mode = debug_options["load_mode"] if load_mode == "always": rebuild_prog = preload or not helpers.has_debug_symbols( configuration["prog_path"]) elif load_mode == "modified": rebuild_prog = helpers.is_prog_obsolete( configuration["prog_path"]) or not helpers.has_debug_symbols( configuration["prog_path"]) else: rebuild_prog = not isfile(configuration["prog_path"]) if preload or (not rebuild_prog and load_mode != "always"): # don't load firmware through debug server debug_options["load_cmds"] = [] if rebuild_prog: if helpers.is_gdbmi_mode(): click.echo( helpers.escape_gdbmi_stream( "~", "Preparing firmware for debugging...\n"), nl=False, ) stream = helpers.GDBMIConsoleStream() with util.capture_std_streams(stream): helpers.predebug_project(ctx, project_dir, env_name, preload, verbose) stream.close() else: click.echo("Preparing firmware for debugging...") helpers.predebug_project(ctx, project_dir, env_name, preload, verbose) # save SHA sum of newly created prog if load_mode == "modified": helpers.is_prog_obsolete(configuration["prog_path"]) if not isfile(configuration["prog_path"]): raise DebugInvalidOptionsError("Program/firmware is missed") # run debugging client inject_contrib_pysite() # pylint: disable=import-outside-toplevel from platformio.commands.debug.process.client import GDBClient, reactor client = GDBClient(project_dir, __unprocessed, debug_options, env_options) client.spawn(configuration["gdb_path"], configuration["prog_path"]) signal.signal(signal.SIGINT, lambda *args, **kwargs: None) reactor.run() return True
def GetProjectConfig(env): return ProjectConfig.get_instance(env['PROJECT_CONFIG'])
def cli(ctx, project_dir, project_conf, environment, verbose, interface, __unprocessed): # use env variables from Eclipse or CLion for sysenv in ("CWD", "PWD", "PLATFORMIO_PROJECT_DIR"): if is_platformio_project(project_dir): break if os.getenv(sysenv): project_dir = os.getenv(sysenv) with util.cd(project_dir): config = ProjectConfig.get_instance( project_conf or join(project_dir, "platformio.ini")) config.validate(envs=[environment] if environment else None) env_name = environment or helpers.get_default_debug_env(config) env_options = config.items(env=env_name, as_dict=True) if not set(env_options.keys()) >= set(["platform", "board"]): raise exception.ProjectEnvsNotAvailable() debug_options = helpers.validate_debug_options(ctx, env_options) assert debug_options if not interface: return helpers.predebug_project(ctx, project_dir, env_name, False, verbose) configuration = load_project_ide_data(project_dir, env_name) if not configuration: raise exception.DebugInvalidOptions( "Could not load debug configuration") if "--version" in __unprocessed: result = util.exec_command([configuration['gdb_path'], "--version"]) if result['returncode'] == 0: return click.echo(result['out']) raise exception.PlatformioException("\n".join( [result['out'], result['err']])) try: util.ensure_udev_rules() except NameError: pass except exception.InvalidUdevRules as e: for line in str(e).split("\n") + [""]: click.echo( ('~"%s\\n"' if helpers.is_mi_mode(__unprocessed) else "%s") % line) debug_options['load_cmds'] = helpers.configure_esp32_load_cmds( debug_options, configuration) rebuild_prog = False preload = debug_options['load_cmds'] == ["preload"] load_mode = debug_options['load_mode'] if load_mode == "always": rebuild_prog = ( preload or not helpers.has_debug_symbols(configuration['prog_path'])) elif load_mode == "modified": rebuild_prog = ( helpers.is_prog_obsolete(configuration['prog_path']) or not helpers.has_debug_symbols(configuration['prog_path'])) else: rebuild_prog = not isfile(configuration['prog_path']) if preload or (not rebuild_prog and load_mode != "always"): # don't load firmware through debug server debug_options['load_cmds'] = [] if rebuild_prog: if helpers.is_mi_mode(__unprocessed): click.echo('~"Preparing firmware for debugging...\\n"') output = helpers.GDBBytesIO() with util.capture_std_streams(output): helpers.predebug_project(ctx, project_dir, env_name, preload, verbose) output.close() else: click.echo("Preparing firmware for debugging...") helpers.predebug_project(ctx, project_dir, env_name, preload, verbose) # save SHA sum of newly created prog if load_mode == "modified": helpers.is_prog_obsolete(configuration['prog_path']) if not isfile(configuration['prog_path']): raise exception.DebugInvalidOptions("Program/firmware is missed") # run debugging client inject_contrib_pysite() from platformio.commands.debug.client import GDBClient, reactor client = GDBClient(project_dir, __unprocessed, debug_options, env_options) client.spawn(configuration['gdb_path'], configuration['prog_path']) signal.signal(signal.SIGINT, lambda *args, **kwargs: None) reactor.run() return True
def get_project_global_lib_dir(): return ProjectConfig.get_instance().get_optional_dir("globallib")
class Context: def __init__(self): self.meta = "" Import("env") if "upload" in BUILD_TARGETS: upload_options = env.BoardConfig().get("upload", {}) if "detect_frequency" in upload_options and upload_options[ "detect_frequency"] == "true": print("Uploading script to detect speed") project_dir = env["PROJECT_DIR"] with fs.cd(project_dir): config = ProjectConfig.get_instance( os.path.join(project_dir, "platformio.ini")) config.validate() processor = EnvironmentProcessor(Context(), "microdetect", config, ["upload"], "", False, False, 1) processor.process() dev = None while not dev: dev = libusb_package.find(idVendor=0x1209, idProduct=0x2883) pass sleep(0.5) env.AutodetectUploadPort() port = env.subst("$UPLOAD_PORT") s = Serial(port=port, baudrate=115200) rate = f"{s.readline().decode('utf-8').strip()}000000" print(rate) # rate = usb.util.get_string(dev, dev.iProduct, 0x0409).split("\x00")[0].rpartition(" - ")[2]
def cli( ctx, environment, target, upload_port, project_dir, project_conf, jobs, silent, verbose, disable_auto_clean, ): app.set_session_var("custom_project_conf", project_conf) # find project directory on upper level if isfile(project_dir): project_dir = find_project_dir_above(project_dir) is_test_running = CTX_META_TEST_IS_RUNNING in ctx.meta with fs.cd(project_dir): config = ProjectConfig.get_instance(project_conf) config.validate(environment) # clean obsolete build dir if not disable_auto_clean: build_dir = config.get_optional_dir("build") try: clean_build_dir(build_dir, config) except: # pylint: disable=bare-except click.secho( "Can not remove temporary directory `%s`. Please remove " "it manually to avoid build issues" % build_dir, fg="yellow", ) handle_legacy_libdeps(project_dir, config) default_envs = config.default_envs() results = [] for env in config.envs(): skipenv = any([ environment and env not in environment, not environment and default_envs and env not in default_envs, ]) if skipenv: results.append({"env": env}) continue # print empty line between multi environment project if not silent and any( r.get("succeeded") is not None for r in results): click.echo() results.append( process_env( ctx, env, config, environment, target, upload_port, silent, verbose, jobs, is_test_running, )) command_failed = any(r.get("succeeded") is False for r in results) if not is_test_running and (command_failed or not silent) and len(results) > 1: print_processing_summary(results) if command_failed: raise exception.ReturnErrorCode(1) return True