Esempio n. 1
0
def Makesis(pkgfile,
            package,
            installed=None,
            cert=None,
            key=None,
            passwd="",
            env=None):
    """
    Call makesis command line utility to create a sis package.
    
    If cert is given, key must be given.
    @param installed: Installed files( to be parsed from pkg in the future )
    @param cert: Certificate used in signing
    @param key: Key used in signing
    @param passwd: Password used in signing
    
    """
    if env is None: env = DefaultEnvironment()

    unsigned_package = package

    if installed is None:
        installed = []

    output_files = []
    output_files.append(package)  # Always

    makesis = os.path.join(arguments.EPOC32_TOOLS, MAKESIS_EXECUTABLE)
    makesis = ("%s %s %s" % (makesis, pkgfile, unsigned_package))
    env.Command(unsigned_package,
                installed + [pkgfile],
                makesis,
                ENV=os.environ)

    return output_files
Esempio n. 2
0
def SignSis(target, source, cert, key, passwd="", env=None):
    """ Call signsis command line utility to create a sis package.
    
    """
    if env is None: env = DefaultEnvironment()

    signsis = os.path.join(arguments.EPOC32_TOOLS, "signsis.exe")
    signsis = ("%s %s %s %s %s %s" %
               (signsis, handle_path(source), handle_path(target),
                handle_path(cert), handle_path(key), passwd))
    env.Command(target, source, signsis, ENV=os.environ)

    return [target]
        if "__pio_env" in config:
            return config
    return ""


#
# Generate final linker script
#

if not env.BoardConfig().get("build.ldscript", ""):
    linker_script = env.Command(
        join("$BUILD_DIR", "esp32_out.ld"),
        env.BoardConfig().get(
            "build.esp-idf.ldscript",
            join(FRAMEWORK_DIR, "components", "esp32", "ld", "esp32.ld"),
        ),
        env.VerboseAction(
            '$CC -I"$BUILD_DIR/config" -C -P -x  c -E $SOURCE -o $TARGET',
            "Generating LD script $TARGET",
        ),
    )

    env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
    env.Replace(LDSCRIPT_PATH="esp32_out.ld")

#
# Generate partition table
#

fwpartitions_dir = join(FRAMEWORK_DIR, "components", "partition_table")
partitions_csv = env.BoardConfig().get("build.partitions",
Esempio n. 4
0
)

#
# Generate linker script
#

env.Replace(
    OUTLD_CFLAGS=[
        "-DAPP_OFFSET=CONFIG_APP1_OFFSET",
        "-DAPP_SIZE=CONFIG_APP1_SIZE",
    ]
)
linker_script = env.Command(
    join("$BUILD_DIR", "esp8266_out.ld"),
    join(FRAMEWORK_DIR, "components", "esp8266", "ld", "esp8266.ld"),
    env.VerboseAction(
#	$(CC) $(OUTLD_CFLAGS) -I ../include -C -P -x c -E $< -o $@ #origin
        '$CC $OUTLD_CFLAGS -I"$PROJECTSRC_DIR" -P -x c -E $SOURCE -o $TARGET',
        "Generating LD script $TARGET")
)
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)

linker_script = env.Command(
    join("$BUILD_DIR", "esp8266_common_out.ld"),
    join(FRAMEWORK_DIR, "components", "esp8266", "ld", "esp8266.common.ld"),
    env.VerboseAction(
#	$(CC) -I ../include -C -P -x c -E $< -o $@ #origin
        '$CC -I"$PROJECTSRC_DIR" -P -x c -E $SOURCE -o $TARGET',
        "Generating LD script $TARGET")
)
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
env.Append(
    LIBSOURCE_DIRS=[join(FRAMEWORK_DIR, "libraries")],
    LINKFLAGS=[
        "-T", "esp32.common.ld", "-T", "esp32.rom.ld", "-T",
        "esp32.peripherals.ld"
    ],
)

#
# Generate partition table
#

partition_table = env.Command(
    join(env.subst("$BUILD_DIR"), "partitions_table.bin"),
    join("$ESPIDF_DIR", "components", "partition_table",
         "partitions_singleapp.csv"), '"$PYTHONEXE" "%s" -q $SOURCE $TARGET' %
    join("$ESPIDF_DIR", "components", "partition_table", "gen_esp32part.py"))

env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", partition_table)

#
# Generate linker script
#

linker_script = env.Command(
    join("$BUILD_DIR", "esp32_out.ld"),
    join("$ESPIDF_DIR", "components", "esp32", "ld", "esp32.ld"),
    "$CC -I$PROJECTSRC_DIR -C -P -x  c -E $SOURCE -o $TARGET")

env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
Esempio n. 6
0
    UPLOADERFLAGS=[
        "0x1000", join("$BUILD_DIR", "bootloader.bin"),
        "0x8000", join("$BUILD_DIR", "partitions_table.bin"),
        "0x10000"
    ]
)

#
# Generate partition table
#

partition_table = env.Command(
    join("$BUILD_DIR", "partitions_table.bin"),
    join(FRAMEWORK_DIR, "components", "partition_table",
         "partitions_singleapp.csv"),
    env.VerboseAction('"$PYTHONEXE" "%s" -q $SOURCE $TARGET' % join(
        FRAMEWORK_DIR, "components", "partition_table", "gen_esp32part.py"),
        "Generating partitions $TARGET"))


env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", partition_table)

#
# Generate linker script
#

linker_script = env.Command(
    join("$BUILD_DIR", "esp32_out.ld"),
    join(FRAMEWORK_DIR, "components", "esp32", "ld", "esp32.ld"),
    env.VerboseAction(
Esempio n. 7
0
        print("Warning! Detected custom MMU flags. Please use the "
              "`-D PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM` option to disable "
              "the default configuration.")

assert mmu_flags
env.Append(CPPDEFINES=mmu_flags)

# Build the eagle.app.v6.common.ld linker file
app_ld = env.Command(
    join("$BUILD_DIR", "ld", "local.eagle.app.v6.common.ld"),
    join(FRAMEWORK_DIR, "tools", "sdk", "ld", "eagle.app.v6.common.ld.h"),
    env.VerboseAction(
        "$CC -CC -E -P -D%s %s %s $SOURCE -o $TARGET" % (
            current_vtables,
            # String representation of MMU flags
            " ".join([
                "-D%s=%s" % f if isinstance(f, (tuple, list)) else "-D" + f
                for f in mmu_flags
            ]),
            fp_in_irom,
        ),
        "Generating LD script $TARGET",
    ),
)
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", app_ld)

if not env.BoardConfig().get("build.ldscript", ""):
    env.Replace(
        LDSCRIPT_PATH=env.BoardConfig().get("build.arduino.ldscript", ""))

#
# Dynamic core_version.h for staging builds
Esempio n. 8
0
    r"^(?:CODE|GSINIT|GSFINAL|CONST|HOME|RSEG0|SSEG|HEADER1|HEADER3|PREG2)[^=]*\D+(\d+).*",
    SIZEDATAREGEXP=r"^(?:DATA)[^=]*\D+(\d+).*",
    PROGNAME="firmware",
    PROGSUFFIX=".ihx")

#
# Target: Build executable and linkable firmware
#

#target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
    target_ihx = join("$BUILD_DIR", "${PROGNAME}.elf")
    target_bin = join("$BUILD_DIR", "${PROGNAME}.bin")
else:
    target_ihx = env.BuildProgram()
    target_bin = env.Command(join("$BUILD_DIR", "${PROGNAME}.bin"), target_ihx,
                             "$OBJCOPY -p $SOURCES $TARGET")

#
# Target: Print binary size
#

target_size = env.AddPlatformTarget(
    "size",
    target_bin,
    sizePrintCMD,
    "Program Size",
    "Calculate program size",
)

#
# Target: Upload firmware
Esempio n. 9
0
             env.BoardConfig().get("build.variant"))
    ])
    libs.append(
        env.BuildLibrary(
            join("$BUILD_DIR", "FrameworkArduinoVariant"),
            join(FRAMEWORK_DIR, "variants",
                 env.BoardConfig().get("build.variant"))))

envsafe = env.Clone()

libs.append(
    envsafe.BuildLibrary(
        join("$BUILD_DIR", "FrameworkArduino"),
        join(FRAMEWORK_DIR, "cores",
             env.BoardConfig().get("build.core"))))

env.Prepend(LIBS=libs)

#
# Generate partition table
#

partition_table = env.Command(
    join("$BUILD_DIR", "partitions.bin"),
    join(FRAMEWORK_DIR, "tools", "partitions", "default.csv"),
    env.VerboseAction(
        '"$PYTHONEXE" "%s" -q $SOURCE $TARGET' %
        join(FRAMEWORK_DIR, "tools", "gen_esp32part.py"),
        "Generating partitions $TARGET"))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", partition_table)
Esempio n. 10
0
# Allow user to override via pre:script
if env.get("PROGNAME", "program") == "program":
    env.Replace(PROGNAME="firmware")

#
# Target: Build executable and linkable firmware
#

target_elf = None
if "nobuild" in COMMAND_LINE_TARGETS:
    target_elf = join("$BUILD_DIR", "${PROGNAME}.elf")
    target_firm = join("$BUILD_DIR", "${PROGNAME}.ihx")
else:
    target_elf = env.BuildProgram()
    target_firm = env.Command(
        join("$BUILD_DIR", "${PROGNAME}.ihx"), env['PIOBUILDFILES'],
        env['LINKCOM'].replace("$LINKFLAGS", "$ldflags_for_hex"))
    env.Depends(target_firm, target_elf)

AlwaysBuild(env.Alias("nobuild", target_firm))
target_buildprog = env.Alias("buildprog", target_firm, target_firm)

#
# Target: Print binary size
#

target_size = env.Alias(
    "size", target_elf,
    env.VerboseAction("$SIZEPRINTCMD", "Calculating size $SOURCE"))
AlwaysBuild(target_size)
Esempio n. 11
0
# script. We can just use the info here

linkerscript_cmd = env.Command(
    os.path.join("$BUILD_DIR", "memmap_default.ld"),  # $TARGET
    os.path.join(FRAMEWORK_DIR, "lib", "memmap_default.ld"),  # $SOURCE
    env.VerboseAction(
        " ".join([
            '"$PYTHONEXE" "%s"' %
            os.path.join(FRAMEWORK_DIR, "tools", "simplesub.py"),
            "--input",
            "$SOURCE",
            "--out",
            "$TARGET",
            "--sub",
            "__FLASH_LENGTH__",
            "$PICO_FLASH_LENGTH",
            "--sub",
            "__EEPROM_START__",
            "$PICO_EEPROM_START",
            "--sub",
            "__FS_START__",
            "$FS_START",
            "--sub",
            "__FS_END__",
            "$FS_END",
            "--sub",
            "__RAM_LENGTH__",
            "%dk" % (ram_size // 1024),
        ]), "Generating linkerscript $BUILD_DIR/memmap_default.ld"))

# if no custom linker script is provided, we use the command that we prepared to generate one.
Esempio n. 12
0
#
# Linker requires preprocessing with link flags
#

if not board.get("build.ldscript", ""):
    ldscript = os.path.join(FRAMEWORK_DIR, configuration.get("ldscript", [])[0] or "")
    if board.get("build.mbed.ldscript", ""):
        ldscript = env.subst(board.get("build.mbed.ldscript"))
    if os.path.isfile(ldscript):
        linker_script = env.Command(
            os.path.join(
                "$BUILD_DIR", "%s.link_script.ld" % os.path.basename(ldscript)
            ),
            ldscript,
            env.VerboseAction(
                "%s -E -P $LINKFLAGS $SOURCE -o $TARGET"
                % env.subst("$GDB").replace("-gdb", "-cpp"),
                "Generating LD script $TARGET",
            ),
        )

        env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
        env.Replace(LDSCRIPT_PATH=linker_script)
    else:
        print("Warning! Couldn't find linker script file!")

#
# Compile core part
#
Esempio n. 13
0
        print("Warning! Cannot find softdevice binary"
              "Firmware will be linked without it!")

#
# Generate linker script
#

env.Replace(LDSCRIPT_PATH=join(FRAMEWORK_DIR, mbed_config.get("ldscript")))
if not env.get("LDSCRIPT_PATH"):
    sys.stderr.write("Cannot find linker script for your board!\n")
    env.Exit(1)

linker_script = env.Command(
    join("$BUILD_DIR",
         "%s.link_script.ld" % basename(env.get("LDSCRIPT_PATH"))),
    "$LDSCRIPT_PATH",
    env.VerboseAction(
        '%s -E -P $LINKPPFLAGS $SOURCE -o $TARGET' %
        env.subst("$GDB").replace("-gdb", "-cpp"),
        "Generating LD script $TARGET"))

env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
env.Replace(LDSCRIPT_PATH=linker_script)

#
# Initialize libraries for LDF
#

for lib, lib_config in libs.items():
    extra_includes = []
    if lib == "events" and not MBED_RTOS:
        # Manually handle dependency on rtos lib
Esempio n. 14
0
# in a special file "version.h" in the root folder of the package
#

create_verion_file()

#
# Generate final linker script
#

if not board.get("build.ldscript", ""):
    linker_script = env.Command(
        os.path.join("$BUILD_DIR", "%s_out.ld" % idf_variant),
        board.get(
            "build.esp-idf.ldscript",
            os.path.join(FRAMEWORK_DIR, "components", idf_variant, "ld",
                         "%s.ld" % idf_variant),
        ),
        env.VerboseAction(
            '$CC -I"$BUILD_DIR/config" -C -P -x  c -E $SOURCE -o $TARGET',
            "Generating LD script $TARGET",
        ),
    )

    env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
    env.Replace(LDSCRIPT_PATH="%s_out.ld" % idf_variant)

#
# Generate partition table
#

fwpartitions_dir = os.path.join(FRAMEWORK_DIR, "components", "partition_table")
partitions_csv = board.get("build.partitions", "partitions_singleapp.csv")
Esempio n. 15
0
# VTables
#

current_vtables = None
for d in flatten_cppdefines:
    if str(d).startswith("VTABLES_IN_"):
        current_vtables = d
if not current_vtables:
    current_vtables = "VTABLES_IN_FLASH"
    env.Append(CPPDEFINES=[current_vtables])
assert current_vtables

# Build the eagle.app.v6.common.ld linker file
app_ld = env.Command(
    join("$BUILD_DIR", "ld", "eagle.app.v6.common.ld"),
    join(FRAMEWORK_DIR, "tools", "sdk", "ld", "eagle.app.v6.common.ld.h"),
    env.VerboseAction(
        "$CC -CC -E -P -D%s $SOURCE -o $TARGET" % current_vtables,
        "Generating LD script $TARGET"))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", app_ld)

#
# Target: Build Core Library
#

libs = []

if "build.variant" in env.BoardConfig():
    env.Append(CPPPATH=[
        join(FRAMEWORK_DIR, "variants",
             env.BoardConfig().get("build.variant"))
    ])
Esempio n. 16
0
# VTables
#

current_vtables = None
for d in flatten_cppdefines:
    if str(d).startswith("VTABLES_IN_"):
        current_vtables = d
if not current_vtables:
    current_vtables = "VTABLES_IN_FLASH"
    env.Append(CPPDEFINES=[current_vtables])
assert current_vtables

# Build the eagle.app.v6.common.ld linker file
app_ld = env.Command(
    join("$BUILD_DIR", "ld", "local.eagle.app.v6.common.ld"),
    join(FRAMEWORK_DIR, "tools", "sdk", "ld", "eagle.app.v6.common.ld.h"),
    env.VerboseAction(
        "$CC -CC -E -P -D%s $SOURCE -o $TARGET" % current_vtables,
        "Generating LD script $TARGET"))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", app_ld)

#
# Dynamic core_version.h for staging builds
#

def platform_txt_version(default):
    with open(join(FRAMEWORK_DIR, "platform.txt"), "r") as platform_txt:
        for line in platform_txt:
            if not line:
                continue
            k, delim, v = line.partition("=")
            if not delim:
Esempio n. 17
0
#
# Generate partition table
#

fwpartitions_dir = join(FRAMEWORK_DIR, "components", "partition_table")
partitions_csv = env.BoardConfig().get("build.partitions",
                                       "partitions_singleapp.csv")
env.Replace(PARTITIONS_TABLE_CSV=abspath(
    join(fwpartitions_dir, partitions_csv) if isfile(
        join(fwpartitions_dir, partitions_csv)) else partitions_csv))

partition_table = env.Command(
    join("$BUILD_DIR", "partitions.bin"), "$PARTITIONS_TABLE_CSV",
    env.VerboseAction(
        '"$PYTHONEXE" "%s" -q --flash-size "%s" $SOURCE $TARGET' %
        (join(FRAMEWORK_DIR, "components", "partition_table",
              "gen_esp32part.py"), env.BoardConfig().get(
                  "upload.flash_size", "detect")),
        "Generating partitions $TARGET"))

env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", partition_table)

#
# Generate linker script
#

linker_script = env.Command(
    join("$BUILD_DIR", "esp32_out.ld"),
    join(FRAMEWORK_DIR, "components", "esp32", "ld", "esp32.ld"),
    env.VerboseAction(
        '$CC -I"$PROJECTSRC_DIR" -C -P -x  c -E $SOURCE -o $TARGET',
Esempio n. 18
0
envsafe = env.Clone()

libs.append(
    envsafe.BuildLibrary(
        join("$BUILD_DIR", "FrameworkArduino"),
        join(FRAMEWORK_DIR, "cores",
             env.BoardConfig().get("build.core"))))

env.Prepend(LIBS=libs)

#
# Generate partition table
#

fwpartitions_dir = join(FRAMEWORK_DIR, "tools", "partitions")
partitions_csv = env.BoardConfig().get("build.arduino.partitions",
                                       "default.csv")
if "build.partitions" in env.BoardConfig():
    partitions_csv = env.BoardConfig().get("build.partitions")
env.Replace(PARTITIONS_TABLE_CSV=abspath(
    join(fwpartitions_dir, partitions_csv) if isfile(
        join(fwpartitions_dir, partitions_csv)) else partitions_csv))

partition_table = env.Command(
    join("$BUILD_DIR", "partitions.bin"), "$PARTITIONS_TABLE_CSV",
    env.VerboseAction(
        '"$PYTHONEXE" "%s" -q $SOURCE $TARGET' %
        join(FRAMEWORK_DIR, "tools", "gen_esp32part.py"),
        "Generating partitions $TARGET"))
env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", partition_table)
Esempio n. 19
0
if "nordicnrf5" in env.get("PIOPLATFORM"):
    softdevice_hex_path = join(FRAMEWORK_DIR,
                               mbed_config.get("softdevice_hex", ""))
    if softdevice_hex_path and isfile(softdevice_hex_path):
        env.Append(SOFTDEVICEHEX=softdevice_hex_path)
    else:
        print("Warning! Cannot find softdevice binary"
              "Firmware will be linked without it!")

#
# Generate linker script
#

env.Replace(LDSCRIPT_PATH=join(FRAMEWORK_DIR, mbed_config.get("ldscript")))
if not env.get("LDSCRIPT_PATH"):
    sys.stderr.write("Cannot find linker script for your board!\n")
    env.Exit(1)

linker_script = env.Command(
    join("$BUILD_DIR",
         "%s.link_script.ld" % basename(env.get("LDSCRIPT_PATH"))),
    env.get("LDSCRIPT_PATH"),
    env.VerboseAction(
        "arm-none-eabi-cpp -E -P %s $SOURCE -o $TARGET" %
        " ".join(mbed_config.get("build_flags").get("ld")),
        "Generating LD script $TARGET"))

env.Depends("$BUILD_DIR/$PROGNAME$PROGSUFFIX", linker_script)
env.Replace(LDSCRIPT_PATH=linker_script)