first commit

buildroot/share/PlatformIO/scripts/SAMD51_grandcentral_m4.py

@@ -0,0 +1,19 @@
+#
+# SAMD51_grandcentral_m4.py
+# Customizations for env:SAMD51_grandcentral_m4
+#
+from os.path import join, isfile
+import shutil
+from pprint import pprint
+
+Import("env")
+
+mf = env["MARLIN_FEATURES"]
+rxBuf = mf["RX_BUFFER_SIZE"] if "RX_BUFFER_SIZE" in mf else "0"
+txBuf = mf["TX_BUFFER_SIZE"] if "TX_BUFFER_SIZE" in mf else "0"
+
+serialBuf = str(max(int(rxBuf), int(txBuf), 350))
+
+build_flags = env.get('BUILD_FLAGS')
+build_flags.append("-DSERIAL_BUFFER_SIZE=" + serialBuf)
+env.Replace(BUILD_FLAGS=build_flags)

buildroot/share/PlatformIO/scripts/STM32F103RC_MEEB_3DP.py

@@ -0,0 +1,58 @@
+#
+# buildroot/share/PlatformIO/scripts/STM32F103RC_MEEB_3DP.py
+#
+try:
+    import configparser
+except ImportError:
+    import ConfigParser as configparser
+
+import os
+Import("env", "projenv")
+# access to global build environment
+print(env)
+# access to project build environment (is used source files in "src" folder)
+print(projenv)
+
+config = configparser.ConfigParser()
+config.read("platformio.ini")
+
+#com_port = config.get("env:STM32F103RC_meeb", "upload_port")
+#print('Use the {0:s} to reboot the board to dfu mode.'.format(com_port))
+
+#
+# Upload actions
+#
+
+def before_upload(source, target, env):
+    print("before_upload")
+    # do some actions
+    # use com_port
+    #
+    env.Execute("pwd")
+
+def after_upload(source, target, env):
+    print("after_upload")
+    # do some actions
+    #
+    #
+    env.Execute("pwd")
+
+print("Current build targets", map(str, BUILD_TARGETS))
+
+env.AddPreAction("upload", before_upload)
+env.AddPostAction("upload", after_upload)
+
+flash_size = 0
+vect_tab_addr = 0
+
+for define in env['CPPDEFINES']:
+    if define[0] == "VECT_TAB_ADDR":
+        vect_tab_addr = define[1]
+    if define[0] == "STM32_FLASH_SIZE":
+        flash_size = define[1]
+
+print('Use the {0:s} address as the marlin app entry point.'.format(vect_tab_addr))
+print('Use the {0:d}KB flash version of stm32f103rct6 chip.'.format(flash_size))
+
+import marlin
+marlin.custom_ld_script("STM32F103RC_MEEB_3DP.ld")

buildroot/share/PlatformIO/scripts/STM32F103RC_fysetc.py

@@ -0,0 +1,26 @@
+#
+# buildroot/share/PlatformIO/scripts/STM32F103RC_fysetc.py
+#
+import os
+from os.path import join
+from os.path import expandvars
+Import("env")
+
+# Custom HEX from ELF
+env.AddPostAction(
+	join("$BUILD_DIR","${PROGNAME}.elf"),
+	env.VerboseAction(" ".join([
+		"$OBJCOPY", "-O ihex", "$TARGET", # TARGET=.pio/build/fysetc_STM32F1/firmware.elf
+		"\"" + join("$BUILD_DIR","${PROGNAME}.hex") + "\"", # Note: $BUILD_DIR is a full path
+	]), "Building $TARGET"))
+
+# In-line command with arguments
+UPLOAD_TOOL="stm32flash"
+platform = env.PioPlatform()
+if platform.get_package_dir("tool-stm32duino") != None:
+	UPLOAD_TOOL=expandvars("\"" + join(platform.get_package_dir("tool-stm32duino"),"stm32flash","stm32flash") + "\"")
+
+env.Replace(
+	UPLOADER=UPLOAD_TOOL,
+	UPLOADCMD=expandvars(UPLOAD_TOOL + " -v -i rts,-dtr,dtr -R -b 115200 -g 0x8000000 -w \"" + join("$BUILD_DIR","${PROGNAME}.hex")+"\"" + " $UPLOAD_PORT")
+)

buildroot/share/PlatformIO/scripts/STM32F103VE_longer.py

@@ -0,0 +1,22 @@
+#
+# buildroot/share/PlatformIO/scripts/STM32F103VE_longer.py
+# Customizations for env:STM32F103VE_longer
+#
+import os,marlin
+
+# Rename ${PROGNAME}.bin and save it as 'project.bin' (No encryption on the Longer3D)
+def encrypt(source, target, env):
+    firmware = open(target[0].path, "rb")
+    renamed = open(target[0].dir.path + '/project.bin', "wb")
+    length = os.path.getsize(target[0].path)
+    position = 0
+    try:
+        while position < length:
+            byte = firmware.read(1)
+            renamed.write(byte)
+            position += 1
+    finally:
+        firmware.close()
+        renamed.close()
+
+marlin.add_post_action(encrypt);

buildroot/share/PlatformIO/scripts/STM32F1_create_variant.py

@@ -0,0 +1,30 @@
+#
+# STM32F1_create_variant.py
+#
+import os,shutil,marlin
+from SCons.Script import DefaultEnvironment
+from platformio import util
+
+env = DefaultEnvironment()
+platform = env.PioPlatform()
+board = env.BoardConfig()
+
+FRAMEWORK_DIR = platform.get_package_dir("framework-arduinoststm32-maple")
+assert os.path.isdir(FRAMEWORK_DIR)
+
+source_root = os.path.join("buildroot", "share", "PlatformIO", "variants")
+assert os.path.isdir(source_root)
+
+variant = board.get("build.variant")
+variant_dir = os.path.join(FRAMEWORK_DIR, "STM32F1", "variants", variant)
+
+source_dir = os.path.join(source_root, variant)
+assert os.path.isdir(source_dir)
+
+if os.path.isdir(variant_dir):
+    shutil.rmtree(variant_dir)
+
+if not os.path.isdir(variant_dir):
+    os.mkdir(variant_dir)
+
+marlin.copytree(source_dir, variant_dir)

buildroot/share/PlatformIO/scripts/add_nanolib.py

@@ -0,0 +1,5 @@
+#
+# add_nanolib.py
+#
+Import("env")
+env.Append(LINKFLAGS=["--specs=nano.specs"])

buildroot/share/PlatformIO/scripts/chitu_crypt.py

@@ -0,0 +1,116 @@
+#
+# buildroot/share/PlatformIO/scripts/chitu_crypt.py
+# Customizations for Chitu boards
+#
+import os,random,struct,uuid,marlin
+
+# Relocate firmware from 0x08000000 to 0x08008800
+marlin.relocate_firmware("0x08008800")
+
+def calculate_crc(contents, seed):
+    accumulating_xor_value = seed;
+
+    for i in range(0, len(contents), 4):
+        value = struct.unpack('<I', contents[ i : i + 4])[0]
+        accumulating_xor_value = accumulating_xor_value ^ value
+    return accumulating_xor_value
+
+def xor_block(r0, r1, block_number, block_size, file_key):
+    # This is the loop counter
+    loop_counter = 0x0
+
+    # This is the key length
+    key_length = 0x18
+
+    # This is an initial seed
+    xor_seed = 0x4BAD
+
+    # This is the block counter
+    block_number = xor_seed * block_number
+
+    #load the xor key from the file
+    r7 =  file_key
+
+    for loop_counter in range(0, block_size):
+        # meant to make sure different bits of the key are used.
+        xor_seed = int(loop_counter / key_length)
+
+        # IP is a scratch register / R12
+        ip = loop_counter - (key_length * xor_seed)
+
+        # xor_seed = (loop_counter * loop_counter) + block_number
+        xor_seed = (loop_counter * loop_counter) + block_number
+
+        # shift the xor_seed left by the bits in IP.
+        xor_seed = xor_seed >> ip
+
+        # load a byte into IP
+        ip = r0[loop_counter]
+
+        # XOR the seed with r7
+        xor_seed = xor_seed ^ r7
+
+        # and then with IP
+        xor_seed = xor_seed ^ ip
+
+        #Now store the byte back
+        r1[loop_counter] = xor_seed & 0xFF
+
+        #increment the loop_counter
+        loop_counter = loop_counter + 1
+
+def encrypt_file(input, output_file, file_length):
+    input_file = bytearray(input.read())
+    block_size = 0x800
+    key_length = 0x18
+
+    uid_value = uuid.uuid4()
+    file_key = int(uid_value.hex[0:8], 16)
+
+    xor_crc = 0xEF3D4323;
+
+    # the input file is exepcted to be in chunks of 0x800
+    # so round the size
+    while len(input_file) % block_size != 0:
+        input_file.extend(b'0x0')
+
+    # write the file header
+    output_file.write(struct.pack(">I", 0x443D2D3F))
+    # encrypt the contents using a known file header key
+
+    # write the file_key
+    output_file.write(struct.pack("<I", file_key))
+
+    #TODO - how to enforce that the firmware aligns to block boundaries?
+    block_count = int(len(input_file) / block_size)
+    print ("Block Count is ", block_count)
+    for block_number in range(0, block_count):
+        block_offset = (block_number * block_size)
+        block_end = block_offset + block_size
+        block_array = bytearray(input_file[block_offset: block_end])
+        xor_block(block_array, block_array, block_number, block_size, file_key)
+        for n in range (0, block_size):
+            input_file[block_offset + n] = block_array[n]
+
+        # update the expected CRC value.
+        xor_crc = calculate_crc(block_array, xor_crc)
+
+    # write CRC
+    output_file.write(struct.pack("<I", xor_crc))
+
+    # finally, append the encrypted results.
+    output_file.write(input_file)
+    return
+
+# Encrypt ${PROGNAME}.bin and save it as 'update.cbd'
+def encrypt(source, target, env):
+    firmware = open(target[0].path, "rb")
+    update = open(target[0].dir.path + '/update.cbd', "wb")
+    length = os.path.getsize(target[0].path)
+
+    encrypt_file(firmware, update, length)
+
+    firmware.close()
+    update.close()
+
+marlin.add_post_action(encrypt);

buildroot/share/PlatformIO/scripts/common-cxxflags.py

@@ -0,0 +1,34 @@
+#
+# common-cxxflags.py
+# Convenience script to apply customizations to CPP flags
+#
+Import("env")
+env.Append(CXXFLAGS=[
+  "-Wno-register"
+  #"-Wno-incompatible-pointer-types",
+  #"-Wno-unused-const-variable",
+  #"-Wno-maybe-uninitialized",
+  #"-Wno-sign-compare"
+])
+
+#
+# Add CPU frequency as a compile time constant instead of a runtime variable
+#
+def add_cpu_freq():
+	if 'BOARD_F_CPU' in env:
+		env['BUILD_FLAGS'].append('-DBOARD_F_CPU=' + env['BOARD_F_CPU'])
+
+# Useful for JTAG debugging
+#
+# It will separate release and debug build folders.
+# It useful to keep two live versions: a debug version for debugging and another for
+# release, for flashing when upload is not done automatically by jlink/stlink.
+# Without this, PIO needs to recompile everything twice for any small change.
+if env.GetBuildType() == "debug" and env.get('UPLOAD_PROTOCOL') not in ['jlink', 'stlink']:
+	env['BUILD_DIR'] = '$PROJECT_BUILD_DIR/$PIOENV/debug'
+
+# On some platform, F_CPU is a runtime variable. Since it's used to convert from ns
+# to CPU cycles, this adds overhead preventing small delay (in the order of less than
+# 30 cycles) to be generated correctly. By using a compile time constant instead
+# the compiler will perform the computation and this overhead will be avoided
+add_cpu_freq()

buildroot/share/PlatformIO/scripts/common-dependencies-post.py

@@ -0,0 +1,16 @@
+#
+# common-dependencies-post.py
+# Convenience script to add build flags for Marlin Enabled Features
+#
+
+Import("env")
+Import("projenv")
+
+def apply_board_build_flags():
+	if not 'BOARD_CUSTOM_BUILD_FLAGS' in env['MARLIN_FEATURES']:
+		return
+	projenv.Append(CCFLAGS=env['MARLIN_FEATURES']['BOARD_CUSTOM_BUILD_FLAGS'].split())
+
+# We need to add the board build flags in a post script
+# so the platform build script doesn't overwrite the custom CCFLAGS
+apply_board_build_flags()

buildroot/share/PlatformIO/scripts/common-dependencies.h

@@ -0,0 +1,111 @@
+/**
+ * Marlin 3D Printer Firmware
+ * Copyright (c) 2020 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]
+ *
+ * Based on Sprinter and grbl.
+ * Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+/**
+ * The purpose of this file is just include Marlin Configuration files,
+ * to discover which FEATURES are enabled, without any HAL include.
+ * Used by common-dependencies.py
+ */
+
+#include "../../../../Marlin/src/inc/MarlinConfig.h"
+
+//
+// Conditionals only used for [features]
+//
+#if ENABLED(SR_LCD_3W_NL)
+  // Feature checks for SR_LCD_3W_NL
+#elif EITHER(LCD_I2C_TYPE_MCP23017, LCD_I2C_TYPE_MCP23008)
+  #define USES_LIQUIDTWI2
+#elif ENABLED(LCD_I2C_TYPE_PCA8574)
+  #define USES_LIQUIDCRYSTAL_I2C
+#elif ANY(HAS_MARLINUI_HD44780, LCD_I2C_TYPE_PCF8575, SR_LCD_2W_NL, LCM1602)
+  #define USES_LIQUIDCRYSTAL
+#endif
+
+#if SAVED_POSITIONS
+  #define HAS_SAVED_POSITIONS
+#endif
+
+#if ENABLED(HOST_PROMPT_SUPPORT) && DISABLED(EMERGENCY_PARSER)
+  #define HAS_GCODE_M876
+#endif
+
+#if ENABLED(DUET_SMART_EFFECTOR) && PIN_EXISTS(SMART_EFFECTOR_MOD)
+  #define HAS_SMART_EFF_MOD
+#endif
+
+#if HAS_LCD_MENU
+  #if ENABLED(BACKLASH_GCODE)
+    #define HAS_MENU_BACKLASH
+  #endif
+  #if ENABLED(LEVEL_BED_CORNERS)
+    #define HAS_MENU_BED_CORNERS
+  #endif
+  #if ENABLED(CANCEL_OBJECTS)
+    #define HAS_MENU_CANCELOBJECT
+  #endif
+  #if EITHER(DELTA_CALIBRATION_MENU, DELTA_AUTO_CALIBRATION)
+    #define HAS_MENU_DELTA_CALIBRATE
+  #endif
+  #if EITHER(LED_CONTROL_MENU, CASE_LIGHT_MENU)
+    #define HAS_MENU_LED
+  #endif
+  #if ENABLED(ADVANCED_PAUSE_FEATURE)
+    #define HAS_MENU_FILAMENT
+  #endif
+  #if ENABLED(SDSUPPORT)
+    #define HAS_MENU_MEDIA
+  #endif
+  #if ENABLED(MIXING_EXTRUDER)
+    #define HAS_MENU_MIXER
+  #endif
+  #if ENABLED(POWER_LOSS_RECOVERY)
+    #define HAS_MENU_JOB_RECOVERY
+  #endif
+  #if HAS_POWER_MONITOR
+    #define HAS_MENU_POWER_MONITOR
+  #endif
+  #if HAS_CUTTER
+    #define HAS_MENU_CUTTER
+  #endif
+  #if HAS_TEMPERATURE
+    #define HAS_MENU_TEMPERATURE
+  #endif
+  #if ENABLED(MMU2_MENUS)
+    #define HAS_MENU_MMU2
+  #endif
+  #if ENABLED(PASSWORD_FEATURE)
+    #define HAS_MENU_PASSWORD
+  #endif
+  #if HAS_TRINAMIC_CONFIG
+    #define HAS_MENU_TMC
+  #endif
+  #if ENABLED(TOUCH_SCREEN_CALIBRATION)
+    #define HAS_MENU_TOUCH_SCREEN
+  #endif
+  #if ENABLED(ASSISTED_TRAMMING_WIZARD)
+    #define HAS_MENU_TRAMMING
+  #endif
+  #if ENABLED(AUTO_BED_LEVELING_UBL)
+    #define HAS_MENU_UBL
+  #endif
+#endif

buildroot/share/PlatformIO/scripts/common-dependencies.py

@@ -0,0 +1,310 @@
+#
+# common-dependencies.py
+# Convenience script to check dependencies and add libs and sources for Marlin Enabled Features
+#
+import subprocess,os,re
+
+PIO_VERSION_MIN = (5, 0, 3)
+try:
+	from platformio import VERSION as PIO_VERSION
+	weights = (1000, 100, 1)
+	version_min = sum([x[0] * float(re.sub(r'[^0-9]', '.', str(x[1]))) for x in zip(weights, PIO_VERSION_MIN)])
+	version_cur = sum([x[0] * float(re.sub(r'[^0-9]', '.', str(x[1]))) for x in zip(weights, PIO_VERSION)])
+	if version_cur < version_min:
+		print()
+		print("**************************************************")
+		print("******      An update to PlatformIO is      ******")
+		print("******  required to build Marlin Firmware.  ******")
+		print("******                                      ******")
+		print("******      Minimum version: ", PIO_VERSION_MIN, "    ******")
+		print("******      Current Version: ", PIO_VERSION, "    ******")
+		print("******                                      ******")
+		print("******   Update PlatformIO and try again.   ******")
+		print("**************************************************")
+		print()
+		exit(1)
+except SystemExit:
+	exit(1)
+except:
+	print("Can't detect PlatformIO Version")
+
+from platformio.package.meta import PackageSpec
+from platformio.project.config import ProjectConfig
+
+Import("env")
+
+#print(env.Dump())
+
+try:
+	verbose = int(env.GetProjectOption('custom_verbose'))
+except:
+	verbose = 0
+
+def blab(str,level=1):
+	if verbose >= level:
+		print("[deps] %s" % str)
+
+FEATURE_CONFIG = {}
+
+def add_to_feat_cnf(feature, flines):
+
+	try:
+		feat = FEATURE_CONFIG[feature]
+	except:
+		FEATURE_CONFIG[feature] = {}
+
+	# Get a reference to the FEATURE_CONFIG under construction
+	feat = FEATURE_CONFIG[feature]
+
+	# Split up passed lines on commas or newlines and iterate
+	# Add common options to the features config under construction
+	# For lib_deps replace a previous instance of the same library
+	atoms = re.sub(r',\\s*', '\n', flines).strip().split('\n')
+	for line in atoms:
+		parts = line.split('=')
+		name = parts.pop(0)
+		if name in ['build_flags', 'extra_scripts', 'src_filter', 'lib_ignore']:
+			feat[name] = '='.join(parts)
+			blab("[%s] %s=%s" % (feature, name, feat[name]), 3)
+		else:
+			for dep in re.split(r",\s*", line):
+				lib_name = re.sub(r'@([~^]|[<>]=?)?[\d.]+', '', dep.strip()).split('=').pop(0)
+				lib_re = re.compile('(?!^' + lib_name + '\\b)')
+				feat['lib_deps'] = list(filter(lib_re.match, feat['lib_deps'])) + [dep]
+				blab("[%s] lib_deps = %s" % (feature, dep), 3)
+
+def load_config():
+	blab("========== Gather [features] entries...")
+	items = ProjectConfig().items('features')
+	for key in items:
+		feature = key[0].upper()
+		if not feature in FEATURE_CONFIG:
+			FEATURE_CONFIG[feature] = { 'lib_deps': [] }
+		add_to_feat_cnf(feature, key[1])
+
+	# Add options matching custom_marlin.MY_OPTION to the pile
+	blab("========== Gather custom_marlin entries...")
+	all_opts = env.GetProjectOptions()
+	for n in all_opts:
+		key = n[0]
+		mat = re.match(r'custom_marlin\.(.+)', key)
+		if mat:
+			try:
+				val = env.GetProjectOption(key)
+			except:
+				val = None
+			if val:
+				opt = mat.group(1).upper()
+				blab("%s.custom_marlin.%s = '%s'" % ( env['PIOENV'], opt, val ))
+				add_to_feat_cnf(opt, val)
+
+def get_all_known_libs():
+	known_libs = []
+	for feature in FEATURE_CONFIG:
+		feat = FEATURE_CONFIG[feature]
+		if not 'lib_deps' in feat:
+			continue
+		for dep in feat['lib_deps']:
+			known_libs.append(PackageSpec(dep).name)
+	return known_libs
+
+def get_all_env_libs():
+	env_libs = []
+	lib_deps = env.GetProjectOption('lib_deps')
+	for dep in lib_deps:
+		env_libs.append(PackageSpec(dep).name)
+	return env_libs
+
+def set_env_field(field, value):
+	proj = env.GetProjectConfig()
+	proj.set("env:" + env['PIOENV'], field, value)
+
+# All unused libs should be ignored so that if a library
+# exists in .pio/lib_deps it will not break compilation.
+def force_ignore_unused_libs():
+	env_libs = get_all_env_libs()
+	known_libs = get_all_known_libs()
+	diff = (list(set(known_libs) - set(env_libs)))
+	lib_ignore = env.GetProjectOption('lib_ignore') + diff
+	blab("Ignore libraries: %s" % lib_ignore)
+	set_env_field('lib_ignore', lib_ignore)
+
+def apply_features_config():
+	load_config()
+	blab("========== Apply enabled features...")
+	for feature in FEATURE_CONFIG:
+		if not env.MarlinFeatureIsEnabled(feature):
+			continue
+
+		feat = FEATURE_CONFIG[feature]
+
+		if 'lib_deps' in feat and len(feat['lib_deps']):
+			blab("========== Adding lib_deps for %s... " % feature, 2)
+
+			# feat to add
+			deps_to_add = {}
+			for dep in feat['lib_deps']:
+				deps_to_add[PackageSpec(dep).name] = dep
+				blab("==================== %s... " % dep, 2)
+
+			# Does the env already have the dependency?
+			deps = env.GetProjectOption('lib_deps')
+			for dep in deps:
+				name = PackageSpec(dep).name
+				if name in deps_to_add:
+					del deps_to_add[name]
+
+			# Are there any libraries that should be ignored?
+			lib_ignore = env.GetProjectOption('lib_ignore')
+			for dep in deps:
+				name = PackageSpec(dep).name
+				if name in deps_to_add:
+					del deps_to_add[name]
+
+			# Is there anything left?
+			if len(deps_to_add) > 0:
+				# Only add the missing dependencies
+				set_env_field('lib_deps', deps + list(deps_to_add.values()))
+
+		if 'build_flags' in feat:
+			f = feat['build_flags']
+			blab("========== Adding build_flags for %s: %s" % (feature, f), 2)
+			new_flags = env.GetProjectOption('build_flags') + [ f ]
+			env.Replace(BUILD_FLAGS=new_flags)
+
+		if 'extra_scripts' in feat:
+			blab("Running extra_scripts for %s... " % feature, 2)
+			env.SConscript(feat['extra_scripts'], exports="env")
+
+		if 'src_filter' in feat:
+			blab("========== Adding src_filter for %s... " % feature, 2)
+			src_filter = ' '.join(env.GetProjectOption('src_filter'))
+			# first we need to remove the references to the same folder
+			my_srcs = re.findall(r'[+-](<.*?>)', feat['src_filter'])
+			cur_srcs = re.findall(r'[+-](<.*?>)', src_filter)
+			for d in my_srcs:
+				if d in cur_srcs:
+					src_filter = re.sub(r'[+-]' + d, '', src_filter)
+
+			src_filter = feat['src_filter'] + ' ' + src_filter
+			set_env_field('src_filter', [src_filter])
+			env.Replace(SRC_FILTER=src_filter)
+
+		if 'lib_ignore' in feat:
+			blab("========== Adding lib_ignore for %s... " % feature, 2)
+			lib_ignore = env.GetProjectOption('lib_ignore') + [feat['lib_ignore']]
+			set_env_field('lib_ignore', lib_ignore)
+
+#
+# Find a compiler, considering the OS
+#
+ENV_BUILD_PATH = os.path.join(env.Dictionary('PROJECT_BUILD_DIR'), env['PIOENV'])
+GCC_PATH_CACHE = os.path.join(ENV_BUILD_PATH, ".gcc_path")
+def search_compiler():
+	try:
+		filepath = env.GetProjectOption('custom_gcc')
+		blab("Getting compiler from env")
+		return filepath
+	except:
+		pass
+
+	if os.path.exists(GCC_PATH_CACHE):
+		with open(GCC_PATH_CACHE, 'r') as f:
+			return f.read()
+
+	# Find the current platform compiler by searching the $PATH
+	# which will be in a platformio toolchain bin folder
+	path_regex = re.escape(env['PROJECT_PACKAGES_DIR'])
+	gcc = "g++"
+	if env['PLATFORM'] == 'win32':
+		path_separator = ';'
+		path_regex += r'.*\\bin'
+		gcc += ".exe"
+	else:
+		path_separator = ':'
+		path_regex += r'/.+/bin'
+
+	# Search for the compiler
+	for pathdir in env['ENV']['PATH'].split(path_separator):
+		if not re.search(path_regex, pathdir, re.IGNORECASE):
+			continue
+		for filepath in os.listdir(pathdir):
+			if not filepath.endswith(gcc):
+				continue
+			# Use entire path to not rely on env PATH
+			filepath = os.path.sep.join([pathdir, filepath])
+			# Cache the g++ path to no search always
+			if os.path.exists(ENV_BUILD_PATH):
+				with open(GCC_PATH_CACHE, 'w+') as f:
+					f.write(filepath)
+
+			return filepath
+
+	filepath = env.get('CXX')
+	blab("Couldn't find a compiler! Fallback to %s" % filepath)
+	return filepath
+
+#
+# Use the compiler to get a list of all enabled features
+#
+def load_marlin_features():
+	if 'MARLIN_FEATURES' in env:
+		return
+
+	# Process defines
+	build_flags = env.get('BUILD_FLAGS')
+	build_flags = env.ParseFlagsExtended(build_flags)
+
+	cxx = search_compiler()
+	cmd = ['"' + cxx + '"']
+
+	# Build flags from board.json
+	#if 'BOARD' in env:
+	#	cmd += [env.BoardConfig().get("build.extra_flags")]
+	for s in build_flags['CPPDEFINES']:
+		if isinstance(s, tuple):
+			cmd += ['-D' + s[0] + '=' + str(s[1])]
+		else:
+			cmd += ['-D' + s]
+
+	cmd += ['-D__MARLIN_DEPS__ -w -dM -E -x c++ buildroot/share/PlatformIO/scripts/common-dependencies.h']
+	cmd = ' '.join(cmd)
+	blab(cmd, 4)
+	define_list = subprocess.check_output(cmd, shell=True).splitlines()
+	marlin_features = {}
+	for define in define_list:
+		feature = define[8:].strip().decode().split(' ')
+		feature, definition = feature[0], ' '.join(feature[1:])
+		marlin_features[feature] = definition
+	env['MARLIN_FEATURES'] = marlin_features
+
+#
+# Return True if a matching feature is enabled
+#
+def MarlinFeatureIsEnabled(env, feature):
+	load_marlin_features()
+	r = re.compile('^' + feature + '$')
+	found = list(filter(r.match, env['MARLIN_FEATURES']))
+
+	# Defines could still be 'false' or '0', so check
+	some_on = False
+	if len(found):
+		for f in found:
+			val = env['MARLIN_FEATURES'][f]
+			if val in [ '', '1', 'true' ]:
+				some_on = True
+			elif val in env['MARLIN_FEATURES']:
+				some_on = env.MarlinFeatureIsEnabled(val)
+
+	return some_on
+
+#
+# Add a method for other PIO scripts to query enabled features
+#
+env.AddMethod(MarlinFeatureIsEnabled)
+
+#
+# Add dependencies for enabled Marlin features
+#
+apply_features_config()
+force_ignore_unused_libs()

buildroot/share/PlatformIO/scripts/custom_board.py

@@ -0,0 +1,13 @@
+#
+# buildroot/share/PlatformIO/scripts/custom_board.py
+#
+import marlin
+board = marlin.env.BoardConfig()
+
+address = board.get("build.address", "")
+if address:
+	marlin.relocate_firmware(address)
+
+ldscript = board.get("build.ldscript", "")
+if ldscript:
+	marlin.custom_ld_script(ldscript)

buildroot/share/PlatformIO/scripts/download_mks_assets.py

@@ -0,0 +1,46 @@
+#
+# buildroot/share/PlatformIO/scripts/download_mks_assets.py
+# Added by HAS_TFT_LVGL_UI to download assets from Makerbase repo
+#
+Import("env")
+import os,requests,zipfile,tempfile,shutil
+
+url = "https://github.com/makerbase-mks/Mks-Robin-Nano-Marlin2.0-Firmware/archive/master.zip"
+zip_path = os.path.join(env.Dictionary("PROJECT_LIBDEPS_DIR"), "mks-assets.zip")
+assets_path = os.path.join(env.Dictionary("PROJECT_BUILD_DIR"), env.Dictionary("PIOENV"), "assets")
+
+def download_mks_assets():
+	print("Downloading MKS Assets")
+	r = requests.get(url, stream=True)
+	# the user may have a very clean workspace,
+	# so create the PROJECT_LIBDEPS_DIR directory if not exits
+	if os.path.exists(env.Dictionary("PROJECT_LIBDEPS_DIR")) == False:
+		os.mkdir(env.Dictionary("PROJECT_LIBDEPS_DIR"))
+	with open(zip_path, 'wb') as fd:
+		for chunk in r.iter_content(chunk_size=128):
+			fd.write(chunk)
+
+def copy_mks_assets():
+	print("Copying MKS Assets")
+	output_path = tempfile.mkdtemp()
+	zip_obj = zipfile.ZipFile(zip_path, 'r')
+	zip_obj.extractall(output_path)
+	zip_obj.close()
+	if os.path.exists(assets_path) == True and os.path.isdir(assets_path) == False:
+		os.unlink(assets_path)
+	if os.path.exists(assets_path) == False:
+		os.mkdir(assets_path)
+	base_path = ''
+	for filename in os.listdir(output_path):
+		base_path = filename
+	for filename in os.listdir(os.path.join(output_path, base_path, 'Firmware', 'mks_font')):
+		shutil.copy(os.path.join(output_path, base_path, 'Firmware', 'mks_font', filename), assets_path)
+	for filename in os.listdir(os.path.join(output_path, base_path, 'Firmware', 'mks_pic')):
+		shutil.copy(os.path.join(output_path, base_path, 'Firmware', 'mks_pic', filename), assets_path)
+	shutil.rmtree(output_path, ignore_errors=True)
+
+if os.path.exists(zip_path) == False:
+	download_mks_assets()
+
+if os.path.exists(assets_path) == False:
+	copy_mks_assets()

buildroot/share/PlatformIO/scripts/fix_framework_weakness.py

@@ -0,0 +1,44 @@
+#
+# fix_framework_weakness.py
+#
+from os.path import join, isfile
+import shutil
+from pprint import pprint
+
+Import("env")
+
+if env.MarlinFeatureIsEnabled("POSTMORTEM_DEBUGGING"):
+    FRAMEWORK_DIR = env.PioPlatform().get_package_dir("framework-arduinoststm32-maple")
+    patchflag_path = join(FRAMEWORK_DIR, ".exc-patching-done")
+
+    # patch file only if we didn't do it before
+    if not isfile(patchflag_path):
+        print("Patching libmaple exception handlers")
+        original_file = join(FRAMEWORK_DIR, "STM32F1", "cores", "maple", "libmaple", "exc.S")
+        backup_file = join(FRAMEWORK_DIR, "STM32F1", "cores", "maple", "libmaple", "exc.S.bak")
+        src_file = join("buildroot", "share", "PlatformIO", "scripts", "exc.S")
+
+        assert isfile(original_file) and isfile(src_file)
+        shutil.copyfile(original_file, backup_file)
+        shutil.copyfile(src_file, original_file);
+
+        def _touch(path):
+            with open(path, "w") as fp:
+                fp.write("")
+
+        env.Execute(lambda *args, **kwargs: _touch(patchflag_path))
+        print("Done patching exception handler")
+
+    print("Libmaple modified and ready for post mortem debugging")
+
+mf = env["MARLIN_FEATURES"]
+rxBuf = mf["RX_BUFFER_SIZE"] if "RX_BUFFER_SIZE" in mf else "0"
+txBuf = mf["TX_BUFFER_SIZE"] if "TX_BUFFER_SIZE" in mf else "0"
+if int(rxBuf) < 64:
+	rxBuf = "64"
+if int(txBuf) < 64:
+	txBuf = "64"
+
+build_flags = env.get('BUILD_FLAGS')
+build_flags.append("-DUSART_RX_BUF_SIZE=" + rxBuf + " -DUSART_TX_BUF_SIZE=" + txBuf)
+env.Replace(BUILD_FLAGS=build_flags)

buildroot/share/PlatformIO/scripts/generic_create_variant.py

@@ -0,0 +1,54 @@
+#
+# generic_create_variant.py
+#
+# Copy one of the variants from buildroot/platformio/variants into
+# the appropriate framework variants folder, so that its contents
+# will be picked up by PlatformIO just like any other variant.
+#
+import os,shutil,marlin
+from SCons.Script import DefaultEnvironment
+from platformio import util
+
+env = DefaultEnvironment()
+
+#
+# Get the platform name from the 'platform_packages' option,
+# or look it up by the platform.class.name.
+#
+platform = env.PioPlatform()
+
+from platformio.package.meta import PackageSpec
+platform_packages = env.GetProjectOption('platform_packages')
+if len(platform_packages) == 0:
+    framewords = {
+        "Ststm32Platform": "framework-arduinoststm32",
+        "AtmelavrPlatform": "framework-arduino-avr"
+    }
+    platform_name = framewords[platform.__class__.__name__]
+else:
+    platform_name = PackageSpec(platform_packages[0]).name
+
+if platform_name in [ "usb-host-msc", "usb-host-msc-cdc-msc", "tool-stm32duino" ]:
+    platform_name = "framework-arduinoststm32"
+
+FRAMEWORK_DIR = platform.get_package_dir(platform_name)
+assert os.path.isdir(FRAMEWORK_DIR)
+
+board = env.BoardConfig()
+
+#mcu_type = board.get("build.mcu")[:-2]
+variant = board.get("build.variant")
+#series = mcu_type[:7].upper() + "xx"
+
+# Prepare a new empty folder at the destination
+variant_dir = os.path.join(FRAMEWORK_DIR, "variants", variant)
+if os.path.isdir(variant_dir):
+    shutil.rmtree(variant_dir)
+if not os.path.isdir(variant_dir):
+    os.mkdir(variant_dir)
+
+# Source dir is a local variant sub-folder
+source_dir = os.path.join("buildroot/share/PlatformIO/variants", variant)
+assert os.path.isdir(source_dir)
+
+marlin.copytree(source_dir, variant_dir)

buildroot/share/PlatformIO/scripts/jgaurora_a5s_a1_with_bootloader.py

@@ -0,0 +1,39 @@
+#
+# buildroot/share/PlatformIO/scripts/jgaurora_a5s_a1_with_bootloader.py
+# Customizations for env:jgaurora_a5s_a1
+#
+import os,marlin
+
+# Append ${PROGNAME}.bin firmware after bootloader and save it as 'jgaurora_firmware.bin'
+def addboot(source, target, env):
+	firmware = open(target[0].path, "rb")
+	lengthfirmware = os.path.getsize(target[0].path)
+	bootloader_bin = "buildroot/share/PlatformIO/scripts/" + "jgaurora_bootloader.bin"
+	bootloader = open(bootloader_bin, "rb")
+	lengthbootloader = os.path.getsize(bootloader_bin)
+
+	firmware_with_boothloader_bin = target[0].dir.path + '/firmware_with_bootloader.bin'
+	if os.path.exists(firmware_with_boothloader_bin):
+		os.remove(firmware_with_boothloader_bin)
+	firmwareimage = open(firmware_with_boothloader_bin, "wb")
+	position = 0
+	while position < lengthbootloader:
+		byte = bootloader.read(1)
+		firmwareimage.write(byte)
+		position += 1
+	position = 0
+	while position < lengthfirmware:
+		byte = firmware.read(1)
+		firmwareimage.write(byte)
+		position += 1
+	bootloader.close()
+	firmware.close()
+	firmwareimage.close()
+
+	firmware_without_bootloader_bin = target[0].dir.path + '/firmware_for_sd_upload.bin'
+	if os.path.exists(firmware_without_bootloader_bin):
+		os.remove(firmware_without_bootloader_bin)
+	os.rename(target[0].path, firmware_without_bootloader_bin)
+	#os.rename(target[0].dir.path+'/firmware_with_bootloader.bin', target[0].dir.path+'/firmware.bin')
+
+marlin.add_post_action(addboot);

buildroot/share/PlatformIO/scripts/lerdge.py

@@ -0,0 +1,46 @@
+#
+# buildroot/share/PlatformIO/scripts/lerdge.py
+# Customizations for Lerdge build environments:
+#   env:LERDGEX  env:LERDGEX_usb_flash_drive
+#   env:LERDGES  env:LERDGES_usb_flash_drive
+#   env:LERDGEK  env:LERDGEK_usb_flash_drive
+#
+import os,marlin
+Import("env")
+
+from SCons.Script import DefaultEnvironment
+board = DefaultEnvironment().BoardConfig()
+
+def encryptByte(byte):
+    byte = 0xFF & ((byte << 6) | (byte >> 2))
+    i = 0x58 + byte
+    j = 0x05 + byte + (i >> 8)
+    byte = (0xF8 & i) | (0x07 & j)
+    return byte
+
+def encrypt_file(input, output_file, file_length):
+    input_file = bytearray(input.read())
+    for i in range(len(input_file)):
+        result = encryptByte(input_file[i])
+        input_file[i] = result
+
+    output_file.write(input_file)
+    return
+
+# Encrypt ${PROGNAME}.bin and save it as build.firmware
+def encrypt(source, target, env):
+    print("Encrypting to:", board.get("build.firmware"))
+    firmware = open(target[0].path, "rb")
+    renamed = open(target[0].dir.path + "/" + board.get("build.firmware"), "wb")
+    length = os.path.getsize(target[0].path)
+
+    encrypt_file(firmware, renamed, length)
+
+    firmware.close()
+    renamed.close()
+
+if 'firmware' in board.get("build").keys():
+  marlin.add_post_action(encrypt);
+else:
+  print("You need to define output file via board_build.firmware = 'filename' parameter")
+  exit(1);

buildroot/share/PlatformIO/scripts/marlin.py

@@ -0,0 +1,75 @@
+#
+# buildroot/share/PlatformIO/scripts/marlin.py
+# Helper module with some commonly-used functions
+#
+import os,shutil
+
+from SCons.Script import DefaultEnvironment
+env = DefaultEnvironment()
+
+def copytree(src, dst, symlinks=False, ignore=None):
+   for item in os.listdir(src):
+        s = os.path.join(src, item)
+        d = os.path.join(dst, item)
+        if os.path.isdir(s):
+            shutil.copytree(s, d, symlinks, ignore)
+        else:
+            shutil.copy2(s, d)
+
+def replace_define(field, value):
+	for define in env['CPPDEFINES']:
+		if define[0] == field:
+			env['CPPDEFINES'].remove(define)
+	env['CPPDEFINES'].append((field, value))
+
+# Relocate the firmware to a new address, such as "0x08005000"
+def relocate_firmware(address):
+	replace_define("VECT_TAB_ADDR", address)
+
+# Relocate the vector table with a new offset
+def relocate_vtab(address):
+	replace_define("VECT_TAB_OFFSET", address)
+
+# Replace the existing -Wl,-T with the given ldscript path
+def custom_ld_script(ldname):
+	apath = os.path.abspath("buildroot/share/PlatformIO/ldscripts/" + ldname)
+	for i, flag in enumerate(env["LINKFLAGS"]):
+		if "-Wl,-T" in flag:
+			env["LINKFLAGS"][i] = "-Wl,-T" + apath
+		elif flag == "-T":
+			env["LINKFLAGS"][i + 1] = apath
+
+# Encrypt ${PROGNAME}.bin and save it with a new name
+# Called by specific encrypt() functions, mostly for MKS boards
+def encrypt_mks(source, target, env, new_name):
+	import sys
+
+	key = [0xA3, 0xBD, 0xAD, 0x0D, 0x41, 0x11, 0xBB, 0x8D, 0xDC, 0x80, 0x2D, 0xD0, 0xD2, 0xC4, 0x9B, 0x1E, 0x26, 0xEB, 0xE3, 0x33, 0x4A, 0x15, 0xE4, 0x0A, 0xB3, 0xB1, 0x3C, 0x93, 0xBB, 0xAF, 0xF7, 0x3E]
+
+	firmware = open(target[0].path, "rb")
+	renamed = open(target[0].dir.path + "/" + new_name, "wb")
+	length = os.path.getsize(target[0].path)
+	position = 0
+	try:
+		while position < length:
+			byte = firmware.read(1)
+			if position >= 320 and position < 31040:
+				byte = chr(ord(byte) ^ key[position & 31])
+				if sys.version_info[0] > 2:
+					byte = bytes(byte, 'latin1')
+			renamed.write(byte)
+			position += 1
+	finally:
+		firmware.close()
+		renamed.close()
+
+def add_post_action(action):
+	env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", action);
+
+# Apply customizations for a MKS Robin
+def prepare_robin(address, ldname, fwname):
+	def encrypt(source, target, env):
+		encrypt_mks(source, target, env, fwname)
+	relocate_firmware(address)
+	custom_ld_script(ldname)
+	add_post_action(encrypt);

buildroot/share/PlatformIO/scripts/mks_encrypt.py

@@ -0,0 +1,28 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_encrypt.py
+#
+# Apply encryption and save as 'build.firmware' for these environments:
+#  - env:mks_robin_stm32
+#  - env:flsun_hispeedv1
+#  - env:mks_robin_nano35_stm32
+#
+Import("env")
+
+from SCons.Script import DefaultEnvironment
+board = DefaultEnvironment().BoardConfig()
+
+if 'firmware' in board.get("build").keys():
+
+	import marlin
+
+	# Encrypt ${PROGNAME}.bin and save it as build.firmware
+	def encrypt(source, target, env):
+		marlin.encrypt_mks(source, target, env, board.get("build.firmware"))
+
+	marlin.add_post_action(encrypt);
+
+else:
+
+	import sys
+	print("You need to define output file via board_build.firmware = 'filename' parameter", file=sys.stderr)
+	env.Exit(1);

buildroot/share/PlatformIO/scripts/mks_robin.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin.py
+#
+import marlin
+marlin.prepare_robin("0x08007000", "mks_robin.ld", "Robin.bin")

buildroot/share/PlatformIO/scripts/mks_robin_e3.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_e3.py
+#
+import marlin
+marlin.prepare_robin("0x08005000", "mks_robin_e3.ld", "Robin_e3.bin")

buildroot/share/PlatformIO/scripts/mks_robin_e3p.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_e3p.py
+#
+import marlin
+marlin.prepare_robin("0x08007000", "mks_robin_e3p.ld", "Robin_e3p.bin")

buildroot/share/PlatformIO/scripts/mks_robin_lite.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_lite.py
+#
+import marlin
+marlin.prepare_robin("0x08005000", "mks_robin_lite.ld", "mksLite.bin")

buildroot/share/PlatformIO/scripts/mks_robin_lite3.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_lite3.py
+#
+import marlin
+marlin.prepare_robin("0x08005000", "mks_robin_lite.ld", "mksLite3.bin")

buildroot/share/PlatformIO/scripts/mks_robin_mini.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_mini.py
+#
+import marlin
+marlin.prepare_robin("0x08007000", "mks_robin_mini.ld", "Robin_mini.bin")

buildroot/share/PlatformIO/scripts/mks_robin_nano.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_nano.py
+#
+import marlin
+marlin.prepare_robin("0x08007000", "mks_robin_nano.ld", "Robin_nano.bin")

buildroot/share/PlatformIO/scripts/mks_robin_nano35.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_nano35.py
+#
+import marlin
+marlin.prepare_robin("0x08007000", "mks_robin_nano.ld", "Robin_nano35.bin")

buildroot/share/PlatformIO/scripts/mks_robin_pro.py

@@ -0,0 +1,5 @@
+#
+# buildroot/share/PlatformIO/scripts/mks_robin_pro.py
+#
+import marlin
+marlin.prepare_robin("0x08007000", "mks_robin_pro.ld", "Robin_pro.bin")

buildroot/share/PlatformIO/scripts/openblt.py

@@ -0,0 +1,15 @@
+#
+# Convert the ELF to an SREC file suitable for some bootloaders
+#
+import os,sys
+from os.path import join
+
+Import("env")
+
+env.AddPostAction(
+    "$BUILD_DIR/${PROGNAME}.elf",
+    env.VerboseAction(" ".join([
+        "$OBJCOPY", "-O", "srec",
+        "\"$BUILD_DIR/${PROGNAME}.elf\"", "\"$BUILD_DIR/${PROGNAME}.srec\""
+    ]), "Building " + join("$BUILD_DIR", "${PROGNAME}.srec"))
+)

buildroot/share/PlatformIO/scripts/preflight-checks.py

@@ -0,0 +1,93 @@
+#
+# preflight-checks.py
+# Check for common issues prior to compiling
+#
+import os,re,sys
+Import("env")
+
+def get_envs_for_board(board):
+	with open(os.path.join("Marlin", "src", "pins", "pins.h"), "r") as file:
+
+		if sys.platform == 'win32':
+			envregex = r"(?:env|win):"
+		elif sys.platform == 'darwin':
+			envregex = r"(?:env|mac|uni):"
+		elif sys.platform == 'linux':
+			envregex = r"(?:env|lin|uni):"
+		else:
+			envregex = r"(?:env):"
+
+		r = re.compile(r"if\s+MB\((.+)\)")
+		if board.startswith("BOARD_"):
+			board = board[6:]
+
+		for line in file:
+			mbs = r.findall(line)
+			if mbs and board in re.split(r",\s*", mbs[0]):
+				line = file.readline()
+				found_envs = re.match(r"\s*#include .+" + envregex, line)
+				if found_envs:
+					envlist = re.findall(envregex + r"(\w+)", line)
+					return [ "env:"+s for s in envlist ]
+	return []
+
+def check_envs(build_env, board_envs, config):
+	if build_env in board_envs:
+		return True
+	ext = config.get(build_env, 'extends', default=None)
+	if ext:
+		if isinstance(ext, str):
+			return check_envs(ext, board_envs, config)
+		elif isinstance(ext, list):
+			for ext_env in ext:
+				if check_envs(ext_env, board_envs, config):
+					return True
+	return False
+
+def sanity_check_target():
+	# Sanity checks:
+	if 'PIOENV' not in env:
+		raise SystemExit("Error: PIOENV is not defined. This script is intended to be used with PlatformIO")
+
+	if 'MARLIN_FEATURES' not in env:
+		raise SystemExit("Error: this script should be used after common Marlin scripts")
+
+	if 'MOTHERBOARD' not in env['MARLIN_FEATURES']:
+		raise SystemExit("Error: MOTHERBOARD is not defined in Configuration.h")
+
+	build_env = env['PIOENV']
+	motherboard = env['MARLIN_FEATURES']['MOTHERBOARD']
+	board_envs = get_envs_for_board(motherboard)
+	config = env.GetProjectConfig()
+	result = check_envs("env:"+build_env, board_envs, config)
+
+	if not result:
+		err = "Error: Build environment '%s' is incompatible with %s. Use one of these: %s" % \
+			  ( build_env, motherboard, ", ".join([ e[4:] for e in board_envs if e.startswith("env:") ]) )
+		raise SystemExit(err)
+
+	#
+	# Check for Config files in two common incorrect places
+	#
+	for p in [ env['PROJECT_DIR'], os.path.join(env['PROJECT_DIR'], "config") ]:
+		for f in [ "Configuration.h", "Configuration_adv.h" ]:
+			if os.path.isfile(os.path.join(p, f)):
+				err = "ERROR: Config files found in directory %s. Please move them into the Marlin subfolder." % p
+				raise SystemExit(err)
+
+	#
+	# Check for old files indicating an entangled Marlin (mixing old and new code)
+	#
+	mixedin = []
+	for p in [ os.path.join(env['PROJECT_DIR'], "Marlin/src/lcd/dogm") ]:
+		for f in [ "ultralcd_DOGM.cpp", "ultralcd_DOGM.h" ]:
+			if os.path.isfile(os.path.join(p, f)):
+				mixedin += [ f ]
+	if mixedin:
+		err = "ERROR: Old files fell into your Marlin folder. Remove %s and try again" % ", ".join(mixedin)
+		raise SystemExit(err)
+
+# Detect that 'vscode init' is running
+from SCons.Script import COMMAND_LINE_TARGETS
+if "idedata" not in COMMAND_LINE_TARGETS:
+    sanity_check_target()

buildroot/share/PlatformIO/scripts/random-bin.py

@@ -0,0 +1,9 @@
+#
+# random-bin.py
+# Set a unique firmware name based on current date and time
+#
+Import("env")
+
+from datetime import datetime
+
+env['PROGNAME'] = datetime.now().strftime("firmware-%Y%m%d-%H%M%S")

buildroot/share/PlatformIO/scripts/stm32_bootloader.py

@@ -0,0 +1,43 @@
+#
+# stm32_bootloader.py
+#
+import os,sys,shutil,marlin
+Import("env")
+
+from SCons.Script import DefaultEnvironment
+board = DefaultEnvironment().BoardConfig()
+
+#
+# Copy the firmware.bin file to build.firmware, no encryption
+#
+def noencrypt(source, target, env):
+	firmware = os.path.join(target[0].dir.path, board.get("build.firmware"))
+	shutil.copy(target[0].path, firmware)
+
+#
+# For build.offset define LD_FLASH_OFFSET, used by ldscript.ld
+#
+if 'offset' in board.get("build").keys():
+	LD_FLASH_OFFSET = board.get("build.offset")
+	marlin.relocate_vtab(LD_FLASH_OFFSET)
+
+	# Flash size
+	maximum_flash_size = int(board.get("upload.maximum_size") / 1024)
+	marlin.replace_define('STM32_FLASH_SIZE', maximum_flash_size)
+
+	# Get upload.maximum_ram_size (defined by /buildroot/share/PlatformIO/boards/VARIOUS.json)
+	maximum_ram_size = board.get("upload.maximum_ram_size")
+
+	for i, flag in enumerate(env["LINKFLAGS"]):
+		if "-Wl,--defsym=LD_FLASH_OFFSET" in flag:
+			env["LINKFLAGS"][i] = "-Wl,--defsym=LD_FLASH_OFFSET=" + LD_FLASH_OFFSET
+		if "-Wl,--defsym=LD_MAX_DATA_SIZE" in flag:
+			env["LINKFLAGS"][i] = "-Wl,--defsym=LD_MAX_DATA_SIZE=" + str(maximum_ram_size - 40)
+
+#
+# Only copy the file if there's no encrypt
+#
+board_keys = board.get("build").keys()
+if 'firmware' in board_keys and ('encrypt' not in board_keys or board.get("build.encrypt") == 'No'):
+	import marlin
+	marlin.add_post_action(noencrypt)