def build_all(self, env, glob_build, srcroot, bindir, libdir, pkgdir):
if glob_build:
env = env.Clone()
# Needed for both C and F90 programs:
bldroot = '../..' # aka RSFSRC/build
if not glob_build:
bldroot = env.get('RSFROOT', os.environ.get('RSFROOT', sys.prefix))
if self.f90:
SConscript(os.path.join(srcroot, 'api', 'f90', 'SConstruct'))
else:
SConscript(os.path.join(srcroot, 'api', 'c', 'SConstruct'))
if not self.c:
docs_c = []
else:
docs_c = build_install_c(env, self.c, srcroot, bindir, libdir,
glob_build, bldroot)
if self.c_place:
docs_c += [
env.Doc(prog, 'M' + prog) for prog in Split(self.c_place)
]
if not self.c_mpi:
docs_c_mpi = None
else:
docs_c_mpi = build_install_c_mpi(env, self.c_mpi, srcroot, bindir,
glob_build, bldroot)
api = env.get('API', [])
if not self.f90:
docs_f90 = None
else:
docs_f90 = build_install_f90(env, self.f90, srcroot, bindir, api,
bldroot, glob_build)
if glob_build:
if not self.py:
docs_py = None
else:
docs_py = install_py_mains(env, self.py, bindir)
if self.py_modules:
install_py_modules(env, self.py_modules, pkgdir)
if self.jl:
install_jl_mains(env, self.jl, bindir)
install_self_doc(env, pkgdir, docs_c, docs_py, docs_f90,
docs_c_mpi)
def BuildFrameworks(env, frameworks):
if not frameworks:
return
if "BOARD" not in env:
sys.stderr.write("Please specify `board` in `platformio.ini` to use "
"with '%s' framework\n" % ", ".join(frameworks))
env.Exit(1)
board_frameworks = env.BoardConfig().get("frameworks", [])
if frameworks == ["platformio"]:
if board_frameworks:
frameworks.insert(0, board_frameworks[0])
else:
sys.stderr.write(
"Error: Please specify `board` in `platformio.ini`\n")
env.Exit(1)
for f in frameworks:
if f == "arduino":
# Arduino IDE appends .o the end of filename
Builder.match_splitext = scons_patched_match_splitext
if "nobuild" not in COMMAND_LINE_TARGETS:
env.ConvertInoToCpp()
if f in board_frameworks:
SConscript(env.GetFrameworkScript(f), exports="env")
else:
sys.stderr.write(
"Error: This board doesn't support %s framework!\n" % f)
env.Exit(1)
def subproject(self, project, env, conf): #pylint: disable=C0103, R0201,W0613
"""
Build the Subproject with name project
"""
#pylint: disable=E1102
SConscript(sconscript_path(project),
exports=['project', 'env', 'conf']) # pylint: disable=E0602, C0301
def AutoPacketBundle(env, name, exclude=[], subdirs=[], doc_extra_sources=[]):
import SENFSCons
sources, tests, includes = SENFSCons.Glob(env,
exclude=((exclude)),
subdirs=((subdirs)))
subscripts = sorted(env.Glob("*/SConscript", strings=True))
doxyfile = env.Glob("Doxyfile")
objects = env.Object(sources)
cobject = env.CombinedObject('${LOCALLIBDIR}/${NAME}${OBJADDSUFFIX}',
objects,
NAME=((name)))
sobundle = env.SharedLibrary('${LOCALLIBDIR}/${NAME}${OBJADDSUFFIX}',
sources,
NAME=((name)),
LIBS=[],
SHLIBPREFIX='')
env.Default(cobject)
env.Default(sobundle)
env.Append(ALLOBJECTS=objects, PACKET_BUNDLES=cobject)
env.Install('$OBJINSTALLDIR', cobject)
env.Install('$OBJINSTALLDIR', sobundle)
if tests: env.BoostUnitTest('test', tests + cobject)
if includes: env.InstallSubdir('$INCLUDEINSTALLDIR', includes)
if doxyfile: SENFSCons.Doxygen(env, extra_sources=((doc_extra_sources)))
if subscripts: SConscript(subscripts)
def generate(env):
# 1.) find the infusor directory
sconscript = os.path.join(env['OFT_SCONS_TOOLS'], '..', 'infuser',
'SConscript')
if not os.path.isfile(sconscript):
env.Error("Could not find the infuser. `{}` does not exist.".format(
sconscript))
exit(1)
# 2.) build infusor string
jar = SConscript([sconscript], exports='env')
env['INFUSER_JAR'] = jar
# 3.) create the infusion builder
infusion_builder = SCons.Builder.Builder(
generator=infusion_action_generator,
emitter=infusion_emitter,
target_factory=SCons.Node.FS.Dir,
source_factory=SCons.Node.FS.Entry)
env.Append(BUILDERS={'Infusion': infusion_builder})
# 4.) add ostfriesentee pseudo builders
env.AddMethod(ostfriesentee_library_method, 'OstfriesenteeLibrary')
env.AddMethod(ostfriesentee_application_method, 'OstfriesenteeApplication')
def BuildFrameworks(env, frameworks):
if not frameworks:
return
if "BOARD" not in env:
sys.stderr.write("Please specify `board` in `platformio.ini` to use "
"with '%s' framework\n" % ", ".join(frameworks))
env.Exit(1)
board_frameworks = env.BoardConfig().get("frameworks", [])
if frameworks == ["platformio"]:
if board_frameworks:
frameworks.insert(0, board_frameworks[0])
else:
sys.stderr.write(
"Error: Please specify `board` in `platformio.ini`\n")
env.Exit(1)
for f in frameworks:
if f in ("arduino", "energia"):
env.ConvertInoToCpp()
if f in board_frameworks:
SConscript(env.GetFrameworkScript(f))
else:
sys.stderr.write(
"Error: This board doesn't support %s framework!\n" % f)
env.Exit(1)
def initialize(cls,
packageName,
versionString=None,
eupsProduct=None,
eupsProductPath=None,
cleanExt=None,
versionModuleName="python/lsst/%s/version.py",
noCfgFile=False,
sconscriptOrder=None):
if cls._initializing:
state.log.fail(
"Recursion detected; an SConscript file should not call BasicSConstruct."
)
cls._initializing = True
if cleanExt is None:
cleanExt = r"*~ core *.so *.os *.o *.pyc *.pkgc"
dependencies.configure(packageName, versionString, eupsProduct,
eupsProductPath, noCfgFile)
state.env.BuildETags()
state.env.CleanTree(cleanExt)
if versionModuleName is not None:
try:
versionModuleName = versionModuleName % "/".join(
packageName.split("_"))
except TypeError:
pass
state.targets["version"] = state.env.VersionModule(
versionModuleName)
scripts = []
for root, dirs, files in os.walk("."):
if "SConstruct" in files and root != ".":
dirs[:] = []
continue
dirs[:] = [d for d in dirs if not d.startswith('.')]
dirs.sort(
) # os.walk order is not specified, but we want builds to be deterministic
if "SConscript" in files:
scripts.append(os.path.join(root, "SConscript"))
if sconscriptOrder is None:
sconscriptOrder = ("lib", "python", "tests", "examples", "doc")
def key(path):
for i, item in enumerate(sconscriptOrder):
if path.lstrip("./").startswith(item):
return i
return len(sconscriptOrder)
scripts.sort(key=key)
for script in scripts:
state.log.info("Using SConscript at %s" % script)
SConscript(script)
cls._initializing = False
return state.env
def AutoRules(env, exclude=[], subdirs=[], doc_extra_sources=[]):
import SENFSCons
sources, tests, includes = SENFSCons.Glob(env,
exclude=((exclude)),
subdirs=((subdirs)))
subscripts = sorted(env.Glob("*/SConscript", strings=True))
doxyfile = env.Glob("Doxyfile")
if sources: env.Append(ALLOBJECTS=env.Object(sources))
if tests: env.BoostUnitTest('test', tests)
if includes: env.InstallSubdir('$INCLUDEINSTALLDIR', includes)
if doxyfile: SENFSCons.Doxygen(env, extra_sources=((doc_extra_sources)))
if subscripts: SConscript(subscripts)
def ProcessGeneral(env):
corelibs = []
if "BUILD_FLAGS" in env:
env.MergeFlags(env['BUILD_FLAGS'])
if "FRAMEWORK" in env:
if env['FRAMEWORK'] in ("arduino", "energia"):
env.ConvertInoToCpp()
SConscriptChdir(0)
corelibs = SConscript(env.subst(
join("$PIOBUILDER_DIR", "scripts", "frameworks",
"${FRAMEWORK}.py")),
exports="env")
return corelibs
def BuildFramework(env):
if "FRAMEWORK" not in env or "uploadlazy" in COMMAND_LINE_TARGETS:
return
if env['FRAMEWORK'].lower() in ("arduino", "energia"):
env.ConvertInoToCpp()
for f in env['FRAMEWORK'].split(","):
framework = f.strip().lower()
if framework in env.get("BOARD_OPTIONS", {}).get("frameworks"):
SConscript(
env.subst(
join("$PIOBUILDER_DIR", "scripts", "frameworks",
"%s.py" % framework)))
else:
Exit("Error: This board doesn't support %s framework!" % framework)
def initialize(cls, packageName, versionString=None, eupsProduct=None, eupsProductPath=None,
cleanExt=None, versionModuleName="python/lsst/%s/version.py", noCfgFile=False,
sconscriptOrder=None, disableCc=False):
if not disableCc:
state._configureCommon()
state._saveState()
if cls._initializing:
state.log.fail("Recursion detected; an SConscript file should not call BasicSConstruct.")
cls._initializing = True
dependencies.configure(packageName, versionString, eupsProduct, eupsProductPath, noCfgFile)
state.env.BuildETags()
if cleanExt is None:
cleanExt = r"*~ core core.[1-9]* *.so *.os *.o *.pyc *.pkgc"
state.env.CleanTree(cleanExt, ".cache __pycache__ .pytest_cache")
if versionModuleName is not None:
try:
versionModuleName = versionModuleName % "/".join(packageName.split("_"))
except TypeError:
pass
state.targets["version"] = state.env.VersionModule(versionModuleName)
scripts = []
for root, dirs, files in os.walk("."):
if "SConstruct" in files and root != ".":
dirs[:] = []
continue
dirs[:] = [d for d in dirs if not d.startswith('.')]
dirs.sort() # os.walk order is not specified, but we want builds to be deterministic
if "SConscript" in files:
scripts.append(os.path.join(root, "SConscript"))
if sconscriptOrder is None:
sconscriptOrder = DEFAULT_TARGETS
# directory for shebang target is bin.src
sconscriptOrder = [t if t != "shebang" else "bin.src" for t in sconscriptOrder]
def key(path):
for i, item in enumerate(sconscriptOrder):
if path.lstrip("./").startswith(item):
return i
return len(sconscriptOrder)
scripts.sort(key=key)
for script in scripts:
state.log.info("Using SConscript at %s" % script)
SConscript(script)
cls._initializing = False
return state.env
def ProcessGeneral(env):
corelibs = []
if "BUILD_FLAGS" in env:
env.MergeFlags(env['BUILD_FLAGS'])
env.PrependENVPath(
"PATH", join(env.subst("$PLATFORMTOOLS_DIR"), "toolchain", "bin"))
if "FRAMEWORK" in env:
if env['FRAMEWORK'] in ("arduino", "energia"):
env.ConvertInotoCpp()
SConscriptChdir(0)
corelibs = SConscript(env.subst(
join("$PIOBUILDER_DIR", "scripts", "frameworks",
"${FRAMEWORK}.py")),
exports="env")
return corelibs
def BuildFrameworks(env, frameworks):
if not frameworks or "uploadlazy" in COMMAND_LINE_TARGETS:
return
board_frameworks = env.get("BOARD_OPTIONS", {}).get("frameworks", [])
if frameworks == ["platformio"]:
if board_frameworks:
frameworks.insert(0, board_frameworks[0])
else:
env.Exit("Error: Please specify board type")
for f in frameworks:
if f in ("arduino", "energia"):
env.ConvertInoToCpp()
if f in board_frameworks:
SConscript(env.subst(
join("$PIOBUILDER_DIR", "scripts", "frameworks", "%s.py" % f)))
else:
env.Exit("Error: This board doesn't support %s framework!" % f)
def _build_units(env, units):
"""
For each given unit, check the build manifest to see if it has been
built. If not, execute the unit's SConscript.
"""
project_dir = _get_project_dir(env)
for unit in Flatten([units]):
unit_name = _get_unit_name(env, unit)
if env['X_BUILD_MANIFEST'].has_key(unit_name):
continue
unit_dir = os.path.join(project_dir, unit_name)
variant_dir = os.path.join(project_dir, 'build', _get_variant(env),
unit_name)
SConscript(dirs=unit_dir,
exports='env',
variant_dir=variant_dir,
duplicate=0)
# Make sure that the build manifest has been updated.
if not env['X_BUILD_MANIFEST'].has_key(unit_name):
env['X_BUILD_MANIFEST'][unit_name] = {}
def build_library(tile, libname, chip):
"""Build a static ARM cortex library"""
dirs = chip.build_dirs()
output_name = '%s_%s.a' % (libname, chip.arch_name())
# Support both firmware/src and just src locations for source code
if os.path.exists('firmware'):
VariantDir(dirs['build'], os.path.join('firmware', 'src'), duplicate=0)
else:
VariantDir(dirs['build'], 'src', duplicate=0)
library_env = setup_environment(chip)
library_env['OUTPUT'] = output_name
library_env['OUTPUT_PATH'] = os.path.join(dirs['build'], output_name)
library_env['BUILD_DIR'] = dirs['build']
# Check for any dependencies this library has
tilebus_defs = setup_dependencies(tile, library_env)
# Create header files for all tilebus config variables and commands that are defined in ourselves
# or in our dependencies
tilebus_defs += tile.find_products('tilebus_definitions')
compile_tilebus(tilebus_defs, library_env, header_only=True)
SConscript(os.path.join(dirs['build'], 'SConscript'),
exports='library_env')
library_env.InstallAs(os.path.join(dirs['output'], output_name),
os.path.join(dirs['build'], output_name))
# See if we should copy any files over to the output:
for src, dst in chip.property('copy_files', []):
srcpath = os.path.join(*src)
destpath = os.path.join(dirs['output'], dst)
library_env.InstallAs(destpath, srcpath)
return os.path.join(dirs['output'], output_name)
"-<test%s>" % sep,
"-<tests%s>" % sep
])
def LookupSources(env, variant_dir, src_dir, duplicate=True, src_filter=None):
return env.CollectBuildFiles(variant_dir, src_dir, src_filter, duplicate)
def VariantDirWrap(env, variant_dir, src_dir, duplicate=False):
env.VariantDir(variant_dir, src_dir, duplicate)
env = DefaultEnvironment()
env.AddMethod(LookupSources)
env.AddMethod(VariantDirWrap)
env.Replace(
PLATFORMFW_DIR=env.PioPlatform().get_package_dir("framework-simba"))
env.Append(UPLOADERFLAGS=[
"0x1000",
join("$PLATFORMFW_DIR", "3pp", "esp32", "bin", "bootloader.bin"), "0x4000",
join("$PLATFORMFW_DIR", "3pp", "esp32", "bin", "partitions_singleapp.bin"),
"0x10000"
])
SConscript(
[env.subst(join("$PLATFORMFW_DIR", "make", "platformio.sconscript"))])
import sys
from os.path import join, isfile
from SCons.Script import DefaultEnvironment, SConscript
env = DefaultEnvironment()
mcu = env.BoardConfig().get("build.mcu")
core = env.BoardConfig().get("build.core", "")
if core == "maple":
build_script = join(
env.PioPlatform().get_package_dir("A21B"),
"tools", "build-%s.py" % mcu[0:7])
elif core == "stm32l0":
build_script = join(
env.PioPlatform().get_package_dir("A21C"),
"tools", "build.py")
else:
build_script = join(env.PioPlatform().get_package_dir(
"A21A"), "tools", "build.py")
if not isfile(build_script):
sys.stderr.write("Error: Missing PlatformIO build script %s!\n" % build_script)
env.Exit(1)
SConscript(build_script)
# 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.
"""
Arduino
Arduino Wiring-based Framework allows writing cross-platform software to
control devices attached to a wide range of Arduino boards to create all
kinds of creative coding, interactive objects, spaces or physical experiences.
http://arduino.cc/en/Reference/HomePage
"""
from os.path import join
from SCons.Script import DefaultEnvironment, SConscript
env = DefaultEnvironment()
SConscript("_embedtxt_files.py", exports="env")
if "espidf" not in env.subst("$PIOFRAMEWORK"):
SConscript(
join(DefaultEnvironment().PioPlatform().get_package_dir(
"framework-arduinoespressif32"), "tools", "platformio-build.py"))
from os.path import join
from SCons.Script import Import, SConscript
Import("env")
SConscript(join(env.PioPlatform().get_package_dir("zephyros"), "scripts",
"OSQ", "build.py"),
exports="env")
env.Exit("Error: %s" % str(e))
if "BOARD_MCU" not in env:
env.Replace(BOARD_MCU="${BOARD_OPTIONS['build']['mcu']}")
if "BOARD_F_CPU" not in env:
env.Replace(BOARD_F_CPU="${BOARD_OPTIONS['build']['f_cpu']}")
if "UPLOAD_PROTOCOL" not in env:
env.Replace(
UPLOAD_PROTOCOL="${BOARD_OPTIONS['upload'].get('protocol', None)}")
if "UPLOAD_SPEED" not in env:
env.Replace(
UPLOAD_SPEED="${BOARD_OPTIONS['upload'].get('speed', None)}")
if "ldscript" in env.get("BOARD_OPTIONS", {}).get("build", {}):
env.Replace(
LDSCRIPT_PATH=join(
"$PIOHOME_DIR", "packages", "ldscripts",
"${BOARD_OPTIONS['build']['ldscript']}"
)
)
if "IGNORE_LIBS" in env:
env['IGNORE_LIBS'] = [l.strip() for l in env['IGNORE_LIBS'].split(",")]
env.PrependENVPath(
"PATH",
env.subst(join("$PIOPACKAGES_DIR", "$PIOPACKAGE_TOOLCHAIN", "bin"))
)
SConscriptChdir(0)
SConscript(env.subst("$BUILD_SCRIPT"))
env.Replace(PROGNAME="firmware")
env.Append(BUILDERS=dict(DataToBin=Builder(action=env.VerboseAction(
" ".join([
"$PYTHONEXE",
join(PULP_TOOLS_DIR, "bin",
"flashImageBuilder"), "--flash-boot-binary", "$SOURCES",
"--comp-dir-rec", "$PROJECTDATA_DIR", "--raw", "$TARGET"
]), "Building data image $TARGET"),
suffix=".bin")))
#
# Autotiler
#
SConscript("autotiler.py", exports={"env": env})
#
# Target: Build executable, linkable firmware and data image
#
target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
target_elf = join("$BUILD_DIR", "${PROGNAME}.elf")
else:
target_elf = env.BuildProgram()
if "uploadfs" in COMMAND_LINE_TARGETS:
data_dir = env.subst("$PROJECTDATA_DIR")
if not (isdir(data_dir) and listdir(data_dir)):
sys.stderr.write(
control devices attached to a wide range of Arduino boards to create all
kinds of creative coding, interactive objects, spaces or physical experiences.
http://www.stm32duino.com
"""
import sys
from os.path import join, isfile
from SCons.Script import DefaultEnvironment, SConscript
env = DefaultEnvironment()
mcu = env.BoardConfig().get("build.mcu")
core = env.BoardConfig().get("build.core", "")
if core == "maple":
build_script = join(
env.PioPlatform().get_package_dir("framework-arduinoststm32-maple"),
"tools", "platformio-build-%s.py" % mcu[0:7])
if isfile(build_script):
SConscript(build_script)
else:
sys.stderr.write("Error: %s family is not supported by maple core\n" %
mcu[0:7])
env.Exit(1)
else:
SConscript(
join(env.PioPlatform().get_package_dir("framework-arduinoststm32"),
"tools", "platformio-build.py"))
# 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.
"""
Arduino
Arduino Wiring-based Framework allows writing cross-platform software to
control devices attached to a wide range of Arduino boards to create all
kinds of creative coding, interactive objects, spaces or physical experiences.
http://arduino.cc/en/Reference/HomePage
"""
from os.path import join
from SCons.Script import DefaultEnvironment, SConscript
SConscript(
# join(DefaultEnvironment().PioPlatform().get_package_dir(
# "framework-arduinoespressif32"), "tools", "platformio-build.py"))
# join("https://github.com/espressif/arduino-esp32/tree/stickbreaker-i2c", "tools", "platformio-build.py"))
join("https://github.com/stickbreaker/arduino-esp32", "tools",
"platformio-build.py"))
# Copyright 2014-present PlatformIO <*****@*****.**>
#
# 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.
"""
Arduino
Arduino Wiring-based Framework allows writing cross-platform software to
control devices attached to a wide range of Arduino boards to create all
kinds of creative coding, interactive objects, spaces or physical experiences.
"""
import sys
from os.path import join, isfile
from SCons.Script import DefaultEnvironment, SConscript
env = DefaultEnvironment()
SConscript(
join(env.PioPlatform().get_package_dir("framework-arduinolinkit7697"),
"tools", "platformio-build.py"))
# Copyright 2018-present PIO Plus <*****@*****.**>
#
# 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.
from os.path import join
from SCons.Script import Import, SConscript
Import("env")
SConscript(join(env.PioPlatform().get_package_dir("framework-gap_sdk"),
"PlatformIO", "build-mbed.py"),
exports={"env": env})
) else join("$PIOHOME_DIR", "packages", "ldscripts",
"${BOARD_OPTIONS['build']['ldscript']}")))
if env['PLATFORM'] != env.get("BOARD_OPTIONS", {}).get("platform"):
Exit("Error: '%s' platform doesn't support this board. "
"Use '%s' platform instead." %
(env['PLATFORM'], env.get("BOARD_OPTIONS", {}).get("platform")))
for opt in ("LIB_IGNORE", "LIB_USE"):
if opt not in env:
continue
env[opt] = [l.strip() for l in env[opt].split(",") if l.strip()]
env.PrependENVPath(
"PATH", env.subst(join("$PIOPACKAGES_DIR", "$PIOPACKAGE_TOOLCHAIN",
"bin")))
SConscriptChdir(0)
SConscript(env.subst("$BUILD_SCRIPT"))
if getenv("PLATFORMIO_EXTRA_SCRIPT", env.get("EXTRA_SCRIPT", None)):
SConscript(getenv("PLATFORMIO_EXTRA_SCRIPT", env.get("EXTRA_SCRIPT")))
if "envdump" in COMMAND_LINE_TARGETS:
print env.Dump()
Exit()
if "idedata" in COMMAND_LINE_TARGETS:
print json.dumps(env.DumpIDEData())
Exit()
# Copyright (C) Ivan Kravets <*****@*****.**>
# See LICENSE for details.
"""
Builder for Freescale Kinetis series ARM microcontrollers.
"""
from os.path import join
from SCons.Script import (COMMAND_LINE_TARGETS, AlwaysBuild, Default,
DefaultEnvironment, SConscript)
env = DefaultEnvironment()
SConscript(env.subst(join("$PIOBUILDER_DIR", "scripts", "basearm.py")))
#
# Target: Build executable and linkable firmware
#
target_elf = env.BuildProgram()
#
# 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)
#
from os.path import join
from SCons.Script import Import, SConscript
Import("env")
# https://github.com/platformio/builder-framework-mbed.git
SConscript(
join(env.PioPlatform().get_package_dir("framework-mbed"), "platformio",
"platformio-build.py"))
# 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.
"""
Arduino
Arduino Wiring-based Framework allows writing cross-platform software to
control devices attached to a wide range of Arduino boards to create all
kinds of creative coding, interactive objects, spaces or physical experiences.
http://arduino.cc/en/Reference/HomePage
"""
from os.path import join
from SCons.Script import COMMAND_LINE_TARGETS, DefaultEnvironment, SConscript
if "nobuild" not in COMMAND_LINE_TARGETS:
SConscript(
join(
DefaultEnvironment().PioPlatform().get_package_dir(
"framework-arduinoespressif8266"), "tools",
"platformio-build.py"))
from os.path import join
from SCons.Script import Import, SConscript
Import("env")
SConscript(join(env.PioPlatform().get_package_dir("framework-zephyr"),
"scripts", "platformio", "platformio-build.py"),
exports="env")
