Merge branch 'develop' of https://github.com/ivankravets/platformio into develop

platformio/builder/scripts/frameworks/mbed.py

@@ -60,6 +60,8 @@ def parse_eix_file(filename):
         ("CPPDEFINES", "./Target/Source/Symbols/Symbol"),
         ("FILES", "./Target/Files/File"),
         ("LINKFLAGS", "./Target/Source/LD/Switch"),
+        ("OBJFILES", "./Target/Source/Addobjects/Addobject"),
+        ("LIBPATH", "./Target/Linker/Librarypaths/Librarypath"),
         ("STDLIBS", "./Target/Source/Syslibs/Library"),
         ("LDSCRIPT_PATH", "./Target/Source/Scriptfile"),
         ("CPPPATH", "./Target/Compiler/Includepaths/Includepath")
@@ -79,15 +81,6 @@ def parse_eix_file(filename):
     return result
 
 
-def get_source_files(flist):
-    files = []
-    for f in flist:
-        if f['type'] == "h" or not f['name'].startswith("mbed"):
-            continue
-        files.append(join("$BUILD_DIR", "FrameworkMbed", f['name'][5:]))
-    return files
-
-
 def get_build_flags(data):
     flags = {}
     cflags = set(data.get("CFLAGS", []))
@@ -105,14 +98,16 @@ eixdata = parse_eix_file(
     join(env.subst("$PLATFORMFW_DIR"), "variant", variant, "%s.eix" % variant))
 
 build_flags = get_build_flags(eixdata)
+variant_dir = join("$PLATFORMFW_DIR", "variant", variant)
+
 env.Replace(
     CPPFLAGS=build_flags.get("CPPFLAGS", []),
     CFLAGS=build_flags.get("CFLAGS", []),
     CXXFLAGS=build_flags.get("CXXFLAGS", []),
     LINKFLAGS=eixdata.get("LINKFLAGS", []),
     CPPDEFINES=[define for define in eixdata.get("CPPDEFINES", [])],
-    LDSCRIPT_PATH=normpath(join(
+    LDSCRIPT_PATH=normpath(
-        "$PLATFORMFW_DIR", "core", eixdata.get("LDSCRIPT_PATH")[0][5:]))
+        join(variant_dir, eixdata.get("LDSCRIPT_PATH")[0]))
 )
 
 # Hook for K64F and K22F
@@ -123,26 +118,27 @@ if board_type in ("frdm_k22f", "frdm_k64f"):
 
 for lib_path in eixdata.get("CPPPATH"):
     _vdir = join("$BUILD_DIR", "FrameworkMbedInc%d" % crc32(lib_path))
-    env.VariantDir(
+    env.VariantDir(_vdir, join(variant_dir, lib_path))
-        _vdir,
-        join("$PLATFORMFW_DIR", "core", lib_path[5:])
-    )
     env.Append(CPPPATH=[_vdir])
 
 
+env.Append(
+    LIBPATH=[join(variant_dir, lib_path)
+             for lib_path in eixdata.get("LIBPATH", [])
+             if lib_path.startswith("mbed")],
+    LIBS=["mbed"]
+)
+
 #
 # Target: Build mbed Library
 #
 
 libs = [l for l in eixdata.get("STDLIBS", []) if l not in env.get("LIBS")]
 
-env.VariantDir(
-    join("$BUILD_DIR", "FrameworkMbed"),
-    join("$PLATFORMFW_DIR", "core")
-)
 libs.append(env.Library(
     join("$BUILD_DIR", "FrameworkMbed"),
-    get_source_files(eixdata.get("FILES", []))
+    [join(variant_dir, f)
+     for f in eixdata.get("OBJFILES", [])]
 ))
 
 env.Append(LIBS=libs)

platformio/builder/tools/platformio.py

@@ -63,8 +63,8 @@ def BuildFirmware(env):
     return firmenv.Program(
         join("$BUILD_DIR", "firmware"),
         [firmenv.GlobCXXFiles(vdir) for vdir in vdirs],
-        LIBS=env.get("LIBS") + deplibs,
+        LIBS=env.get("LIBS", []) + deplibs,
-        LIBPATH="$BUILD_DIR",
+        LIBPATH=env.get("LIBPATH", []) + ["$BUILD_DIR"],
         PROGSUFFIX=".elf"
     )
 

scripts/mbed_to_package.py

@@ -1,64 +1,67 @@
 # Copyright (C) Ivan Kravets <me@ikravets.com>
 # See LICENSE for details.
 
-from os import getcwd, mkdir, makedirs, listdir
+import argparse
-from os.path import isfile, isdir, join
+import zipfile
-from shutil import copy2, rmtree, copytree
+from os import getcwd, listdir, makedirs, mkdir, rename
+from os.path import isdir, isfile, join
+from shutil import move, rmtree
 from sys import exit as sys_exit
 from sys import path
-import zipfile
-
-
-MBED_DIR = "/home/valeros/mbed-master"
-OUTPUT_DIR = "/home/valeros/mbed-framework"
-CORE_DIR = join(OUTPUT_DIR, "core")
-VARIANT_DIR = join(OUTPUT_DIR, "variant")
 
 path.append("..")
-path.append(MBED_DIR)
+
-from workspace_tools.export import gccarm
 from platformio.util import exec_command
 
 
-def _unzip_generated_file(mcu):
+def _unzip_generated_file(mbed_dir, output_dir, mcu):
     filename = join(
-        MBED_DIR, "build", "export", "MBED_A1_emblocks_%s.zip" % mcu)
+        mbed_dir, "build", "export", "MBED_A1_emblocks_%s.zip" % mcu)
-    variant_dir = join(VARIANT_DIR, mcu)
+    variant_dir = join(output_dir, "variant", mcu)
     if isfile(filename):
         print "Processing board: %s" % mcu
         with zipfile.ZipFile(filename) as zfile:
             mkdir(variant_dir)
-            file_data = zfile.read("MBED_A1/MBED_A1.eix")
+            zfile.extractall(variant_dir)
-            with open(join(variant_dir, "%s.eix" % mcu), "w") as f:
+            for f in listdir(join(variant_dir, "MBED_A1")):
-                f.write(file_data)
+                if not f.lower().startswith("mbed"):
+                    continue
+                move(join(variant_dir, "MBED_A1", f), variant_dir)
+            rename(join(variant_dir, "MBED_A1.eix"),
+                   join(variant_dir, "%s.eix" % mcu))
+            rmtree(join(variant_dir, "MBED_A1"))
     else:
         print "Warning! Skipped board: %s" % mcu
 
 
-def main():
+def main(mbed_dir, output_dir):
     print "Starting..."
-    if isdir(OUTPUT_DIR):
+
-        rmtree(OUTPUT_DIR)
+    path.append(mbed_dir)
-        print "Delete previous framework dir"
+    from workspace_tools.export import gccarm
-    makedirs(VARIANT_DIR)
+
-    # copy MBED library
+    if isdir(output_dir):
-    mbedlib_dir = join(MBED_DIR, "libraries", "mbed")
+        print "Deleting previous framework dir..."
-    for item in listdir(mbedlib_dir):
+        rmtree(output_dir)
-        src = join(mbedlib_dir, item)
+
-        dst = join(CORE_DIR, item)
+    makedirs(join(output_dir, "variant"))
-        if isdir(src):
-            copytree(src, dst)
-        else:
-            copy2(src, dst)
     # make .eix files
     for mcu in set(gccarm.GccArm.TARGETS):
         exec_command(
-            ["python", join(MBED_DIR, "workspace_tools", "project.py"),
+            ["python", join(mbed_dir, "workspace_tools", "build.py"),
-             "--mcu", mcu, "-i", "emblocks", "-p", "0"], cwd=getcwd()
+             "--mcu", mcu, "-t", "GCC_ARM"], cwd=getcwd()
         )
-        _unzip_generated_file(mcu)
+        exec_command(
+            ["python", join(mbed_dir, "workspace_tools", "project.py"),
+             "--mcu", mcu, "-i", "emblocks", "-p", "0", "-b"], cwd=getcwd()
+        )
+        _unzip_generated_file(mbed_dir, output_dir, mcu)
     print "Complete!"
 
 
 if __name__ == "__main__":
-    sys_exit(main())
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--mbed', help="The path to mbed framework")
+    parser.add_argument('--output', help="The path to output directory")
+    args = vars(parser.parse_args())
+    sys_exit(main(args["mbed"], args["output"]))