Import("ENV", "fw_build_meta") import os from fbt.util import ( should_gen_cdb_and_link_dir, link_elf_dir_as_latest, ) # Building initial C environment for libs env = ENV.Clone( tools=[ ("compilation_db", {"COMPILATIONDB_COMSTR": "\tCDB\t${TARGET}"}), "fwbin", "fbt_apps", ], COMPILATIONDB_USE_ABSPATH=False, BUILD_DIR=fw_build_meta["build_dir"], IS_BASE_FIRMWARE=fw_build_meta["type"] == "firmware", FW_FLAVOR=fw_build_meta["flavor"], PLUGIN_ELF_DIR="${BUILD_DIR}", LIB_DIST_DIR="${BUILD_DIR}/lib", LINT_SOURCES=[ "applications", ], LIBPATH=[ "${LIB_DIST_DIR}", ], CPPPATH=[ "#/furi", "#/applications", "#/firmware/targets/f${TARGET_HW}/ble_glue", "#/firmware/targets/f${TARGET_HW}/fatfs", "#/firmware/targets/f${TARGET_HW}/furi_hal", "#/firmware/targets/f${TARGET_HW}/Inc", "#/firmware/targets/furi_hal_include", ], # Specific flags for building libraries - always do optimized builds FW_LIB_OPTS={ "Default": { "CCFLAGS": [ "-Os", ], "CPPDEFINES": [ "NDEBUG", "FURI_NDEBUG", ], # You can add other entries named after libraries # If they are present, they have precedence over Default }, # for furi_check to respect build type "furi": { "CCFLAGS": [ "-Os", ], "CPPDEFINES": [ "NDEBUG", "FURI_DEBUG" if ENV["DEBUG"] else "FURI_NDEBUG", ], }, }, ) def ApplyLibFlags(env): flags_to_apply = env["FW_LIB_OPTS"].get( env.get("FW_LIB_NAME"), env["FW_LIB_OPTS"]["Default"], ) # print("Flags for ", env.get("FW_LIB_NAME", "Default"), flags_to_apply) env.MergeFlags(flags_to_apply) env.AddMethod(ApplyLibFlags) Export("env") if not env["VERBOSE"]: env.SetDefault( HEXCOMSTR="\tHEX\t${TARGET}", BINCOMSTR="\tBIN\t${TARGET}", DFUCOMSTR="\tDFU\t${TARGET}", ) if env["IS_BASE_FIRMWARE"]: env.Append( FIRMWARE_BUILD_CFG="firmware", RAM_EXEC=False, ) else: env.Append( FIRMWARE_BUILD_CFG="updater", RAM_EXEC=True, CPPDEFINES=[ "FURI_RAM_EXEC", ], ) # Invoke child SConscripts to populate global `env` + build their own part of the code lib_targets = env.BuildModules( [ "lib", "assets", "firmware", "furi", ], ) # Now, env is fully set up with everything to build apps fwenv = env.Clone() # Set up additional app-specific build flags SConscript("site_scons/firmwareopts.scons", exports={"ENV": fwenv}) # Set up app configuration if env["IS_BASE_FIRMWARE"]: fwenv.Append(APPS=fwenv["FIRMWARE_APPS"].get(fwenv.subst("$FIRMWARE_APP_SET"))) else: fwenv.Append(APPS=["updater"]) if extra_int_apps := GetOption("extra_int_apps"): fwenv.Append(APPS=extra_int_apps.split(",")) fwenv.LoadApplicationManifests() fwenv.PrepareApplicationsBuild() # Build external apps extapps = SConscript("applications/extapps.scons", exports={"ENV": fwenv}) # Add preprocessor definitions for current set of apps fwenv.AppendUnique( CPPDEFINES=fwenv["APPBUILD"].get_apps_cdefs(), ) # Build applications.c for selected services & apps # Depends on virtual value-only node, so it only gets rebuilt when set of apps changes apps_c = fwenv.ApplicationsC( "applications/applications.c", [Value(fwenv["APPS"]), Value(fwenv["LOADER_AUTOSTART"])], ) # Adding dependency on manifest files so apps.c is rebuilt when any manifest is changed fwenv.Depends(apps_c, fwenv.GlobRecursive("*.fam", "#/applications")) sources = [apps_c] # Gather sources only from app folders in current configuration for app_folder in fwenv["APPBUILD"].get_builtin_app_folders(): sources += fwenv.GlobRecursive("*.c*", os.path.join("applications", app_folder)) fwenv.AppendUnique( LINKFLAGS=[ "-specs=nano.specs", "-specs=nosys.specs", "-Wl,--start-group", "-lstdc++", "-lsupc++", "-Wl,--end-group", "-Wl,--gc-sections", "-Wl,--undefined=uxTopUsedPriority", "-Wl,--wrap,_malloc_r", "-Wl,--wrap,_free_r", "-Wl,--wrap,_calloc_r", "-Wl,--wrap,_realloc_r", "-n", "-Xlinker", "-Map=${TARGET}.map", ], ) # Debug # print(fwenv.Dump()) # Full firmware definition fwelf = fwenv["FW_ELF"] = fwenv.Program( "${FIRMWARE_BUILD_CFG}", sources, LIBS=[ "print", "flipper${TARGET_HW}", "furi", "freertos", "stm32cubewb", "hwdrivers", "fatfs", "littlefs", "subghz", "flipperformat", "toolbox", "nfc", "microtar", "usb_stm32", "st25rfal002", "infrared", "appframe", "assets", "misc", "mbedtls", "loclass", # 2nd round "flipperformat", "toolbox", ], ) # Firmware depends on everything child builders returned Depends(fwelf, lib_targets) # Output extra details after building firmware AddPostAction(fwelf, fwenv["APPBUILD_DUMP"]) AddPostAction( fwelf, Action('${PYTHON3} "${ROOT_DIR}/scripts/fwsize.py" elf ${TARGET}', "Firmware size"), ) # Produce extra firmware files fwhex = fwenv["FW_HEX"] = fwenv.HEXBuilder("${FIRMWARE_BUILD_CFG}") fwbin = fwenv["FW_BIN"] = fwenv.BINBuilder("${FIRMWARE_BUILD_CFG}") AddPostAction( fwbin, Action('@${PYTHON3} "${ROOT_DIR}/scripts/fwsize.py" bin ${TARGET}'), ) fwdfu = fwenv["FW_DFU"] = fwenv.DFUBuilder("${FIRMWARE_BUILD_CFG}") Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_dfu", fwdfu) fwdump = fwenv.ObjDump("${FIRMWARE_BUILD_CFG}") Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_list", fwdump) fw_artifacts = fwenv["FW_ARTIFACTS"] = [ fwhex, fwbin, fwdfu, fwenv["FW_VERSION_JSON"], ] # If current configuration was explicitly requested, generate compilation database # and link its directory as build/latest if should_gen_cdb_and_link_dir(fwenv, BUILD_TARGETS): fwcdb = fwenv.CompilationDatabase() # without filtering, both updater & firmware commands would be generated fwenv.Replace(COMPILATIONDB_PATH_FILTER=fwenv.subst("*${FW_FLAVOR}*")) AlwaysBuild(fwcdb) Precious(fwcdb) NoClean(fwcdb) Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_cdb", fwcdb) fw_artifacts.append(fwcdb) # Adding as a phony target, so folder link is updated even if elf didn't change link_dir_command = fwenv.PhonyTarget( fwenv.subst("${FIRMWARE_BUILD_CFG}_latest"), Action( lambda source, target, env: link_elf_dir_as_latest(env, source[0]), None, ), source=fwelf, ) fw_artifacts.append(link_dir_command) Alias(fwenv["FIRMWARE_BUILD_CFG"] + "_all", fw_artifacts) Return("fwenv")