Fix last hickup at first compile run after install

Jason2866 · web-flow · commit e1356e9722f2 · 2024-09-01T21:51:19.000+02:00
diff --git a/builder/frameworks/espidf.py b/builder/frameworks/espidf.py
@@ -69,7 +69,7 @@
 IDF_ENV_VERSION = "1.0.0"
 FRAMEWORK_DIR = platform.get_package_dir("framework-espidf")
 TOOLCHAIN_DIR = platform.get_package_dir(
-    "tc-%s" % ("rv32" if mcu in ("esp32c2", "esp32c3", "esp32c6", "esp32h2") else ("xt-%s" % mcu))
+    "toolchain-%s" % ("riscv32-esp" if mcu in ("esp32c2", "esp32c3", "esp32c6", "esp32h2") else ("xtensa-%s" % mcu))
 )
 
 
@@ -252,7 +252,7 @@ def populate_idf_env_vars(idf_env):
 
     if mcu not in ("esp32c2", "esp32c3", "esp32c6", "esp32h2", "esp32p4"):
         additional_packages.append(
-            os.path.join(platform.get_package_dir("tc-ulp"), "bin"),
+            os.path.join(platform.get_package_dir("toolchain-esp32ulp"), "bin"),
         )
 
     idf_env["PATH"] = os.pathsep.join(additional_packages + [idf_env["PATH"]])
@@ -1292,17 +1292,6 @@ def _get_installed_pip_packages(python_exe_path):
             )
         )
 
-#        # A special "esp-windows-curses" python package is required on Windows
-#        # for Menuconfig on IDF <5
-#        if not IDF5 and "esp-windows-curses" not in installed_packages:
-#            env.Execute(
-#                env.VerboseAction(
-#                    '"%s" -m pip install "file://%s/tools/kconfig_new/esp-windows-curses"'
-#                    % (python_exe_path, FRAMEWORK_DIR),
-#                    "Installing windows-curses package",
-#                )
-#            )
-
 
 def get_idf_venv_dir():
     # The name of the IDF venv contains the IDF version to avoid possible conflicts and
diff --git a/builder/frameworks/ulp.py b/builder/frameworks/ulp.py
@@ -36,13 +36,13 @@ def prepare_ulp_env_vars(env):
     ulp_env.PrependENVPath("IDF_PATH", FRAMEWORK_DIR)
 
     toolchain_path = platform.get_package_dir(
-        "tc-xt-%s" % idf_variant
+        "toolchain-xtensa-%s" % idf_variant
     )
 
     additional_packages = [
         toolchain_path,
         os.path.join(
-            platform.get_package_dir("tc-ulp"),
+            platform.get_package_dir("toolchain-esp32ulp"),
             "bin",
         ),
         platform.get_package_dir("tool-ninja"),
diff --git a/builder/main.py b/builder/main.py
@@ -14,48 +14,23 @@
 
 import re
 import sys
-import shutil
-import subprocess
-import os
-from os.path import isfile, isdir, join
+from os.path import isfile, join
 
 from SCons.Script import (
     ARGUMENTS, COMMAND_LINE_TARGETS, AlwaysBuild, Builder, Default,
     DefaultEnvironment)
 
 from platformio.util import get_serial_ports
-from platformio.proc import exec_command, where_is_program
 
-pio_exe = where_is_program("platformio")
 env = DefaultEnvironment()
 platform = env.PioPlatform()
-board = env.BoardConfig()
-mcu = board.get("build.mcu", "esp32")
 
 #
 # Helpers
 #
 
-PLATFORM_PATH = env.GetProjectOption("platform")
-PLATFORM_CMD = (
-    pio_exe,
-    "pkg",
-    "install",
-    "--global",
-    "--platform",
-    PLATFORM_PATH,
-)
-
-# install platform again to install missing packages, needed since no registry install
-if bool(platform.get_package_dir("tc-%s" % ("rv32" if mcu in ("esp32c2", "esp32c3", "esp32c6", "esp32h2") else ("xt-%s" % mcu)))) == False:
-    result = exec_command(PLATFORM_CMD)
-    if result["returncode"] != 0:
-        sys.stderr.write(result["err"] + "\n")
-        env.Exit(1)
-
 FRAMEWORK_DIR = platform.get_package_dir("framework-arduinoespressif32")
 
-
 def BeforeUpload(target, source, env):
     upload_options = {}
     if "BOARD" in env:
@@ -277,15 +252,15 @@ def __fetch_fs_size(target, source, env):
     CXX="%s-elf-g++" % toolchain_arch,
     GDB=join(
         platform.get_package_dir(
-            "tl-rv-gdb"
+            "riscv32-esp-elf-gdb"
             if mcu in ("esp32c2", "esp32c3", "esp32c6")
-            else "tl-xt-gdb"
+            else "xtensa-esp-elf-gdb"
         )
         or "",
         "bin",
         "%s-elf-gdb" % toolchain_arch,
     ),
-    OBJCOPY=join(platform.get_package_dir("tool-esptool") or "", "esptool.py"),
+    OBJCOPY=join(platform.get_package_dir("tool-esptoolpy") or "", "esptool.py"),
     RANLIB="%s-elf-gcc-ranlib" % toolchain_arch,
     SIZETOOL="%s-elf-size" % toolchain_arch,
 
@@ -460,7 +435,7 @@ def __fetch_fs_size(target, source, env):
 elif upload_protocol == "esptool":
     env.Replace(
         UPLOADER=join(
-            platform.get_package_dir("tool-esptool") or "", "esptool.py"),
+            platform.get_package_dir("tool-esptoolpy") or "", "esptool.py"),
         UPLOADERFLAGS=[
             "--chip", mcu,
             "--port", '"$UPLOAD_PORT"',
@@ -553,7 +528,7 @@ def __fetch_fs_size(target, source, env):
         f.replace(
             "$PACKAGE_DIR",
             _to_unix_slashes(
-                platform.get_package_dir("tl-openocd") or ""))
+                platform.get_package_dir("tool-openocd") or ""))
         for f in openocd_args
     ]
     env.Replace(
diff --git a/platform.json b/platform.json
@@ -47,49 +47,49 @@
       "owner": "pioarduino",
       "version": "https://github.com/pioarduino/esp-idf/releases/download/v5.1.4.240805/esp-idf-v5.1.4.zip"
     },
-    "tc-xt-esp32": {
+    "toolchain-xtensa-esp32": {
       "type": "toolchain",
       "optional": true,
       "owner": "",
       "version": ""
     },
-    "tc-xt-esp32s2": {
+    "toolchain-xtensa-esp32s2": {
       "type": "toolchain",
       "optional": true,
       "owner": "",
       "version": ""
     },
-    "tc-xt-esp32s3": {
+    "toolchain-xtensa-esp32s3": {
       "type": "toolchain",
       "optional": true,
       "owner": "",
       "version": ""
     },
-    "tc-rv32": {
+    "toolchain-riscv32-esp": {
       "type": "toolchain",
       "optional": true,
       "owner": "",
       "version": ""
     },
-    "tc-ulp": {
+    "toolchain-esp32ulp": {
       "type": "toolchain",
       "optional": true,
       "owner": "",
       "version": ""
     },
-    "tl-xt-gdb": {
+    "xtensa-esp-elf-gdb": {
       "type": "debugger",
       "optional": true,
       "owner": "",
       "version": ""
     },
-    "tl-rv-gdb": {
+    "riscv32-esp-elf-gdb": {
       "type": "debugger",
       "optional": true,
       "owner": "",
       "version": ""
     },
-    "tool-esptool": {
+    "tool-esptoolpy": {
       "type": "uploader",
       "optional": false,
       "owner": "pioarduino",
@@ -158,12 +158,12 @@
     "contrib-piohome": {
       "optional": true,
       "owner": "",
-      "version": "https://github.com/pioarduino/registry/releases/download/0.0.1/contrib-piohome-3.4.4.tar.gz"
+      "version": ""
     },
     "contrib-pioremote": {
       "optional": true,
       "owner": "",
-      "version": "https://github.com/pioarduino/registry/releases/download/0.0.1/contrib-pioremote-1.0.1.tar.gz"
+      "version": ""
     }
   }
 }
diff --git a/platform.py b/platform.py
@@ -21,13 +21,30 @@
 from platformio.public import PlatformBase, to_unix_path
 from platformio.proc import get_pythonexe_path
 from platformio.project.config import ProjectConfig
+from platformio.package.manager.tool import ToolPackageManager
 
 python_exe = get_pythonexe_path()
+pm = ToolPackageManager()
 
 IDF_TOOLS_PATH_DEFAULT = os.path.join(os.path.expanduser("~"), ".espressif")
 IDF_TOOLS = os.path.join(ProjectConfig.get_instance().get("platformio", "packages_dir"), "tl-install", "tools", "idf_tools.py")
-IDF_TOOLS_FLAG = ["install"]
-IDF_TOOLS_CMD = [python_exe, IDF_TOOLS] + IDF_TOOLS_FLAG
+IDF_TOOLS_CMD = (
+    python_exe,
+    IDF_TOOLS,
+    "install",
+)
+
+# IDF Install is needed only one time
+tl_flag = bool(os.path.exists(IDF_TOOLS))
+if (tl_flag and not bool(os.path.exists(join(IDF_TOOLS_PATH_DEFAULT, "tools")))):
+    rc = subprocess.call(IDF_TOOLS_CMD)
+    if rc != 0:
+        sys.stderr.write("Error: Couldn't execute 'idf_tools.py install'\n")
+    else:
+        shutil.copytree(join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-packages"), join(IDF_TOOLS_PATH_DEFAULT, "tools"), symlinks=False, ignore=None, ignore_dangling_symlinks=False, dirs_exist_ok=True)
+        for p in ("tool-mklittlefs", "tool-mkfatfs", "tool-mkspiffs", "tool-dfuutil", "tool-openocd", "tool-cmake", "tool-ninja", "tool-cppcheck", "tool-clangtidy", "tool-pvs-studio", "tc-xt-esp32", "tc-xt-esp32s2", "tc-xt-esp32s3",  "tc-ulp", "tc-rv32", "tl-xt-gdb", "tl-rv-gdb", "contrib-piohome", "contrib-pioremote"):
+            tl_path = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", p)
+            pm.install(tl_path)
 
 class Espressif32Platform(PlatformBase):
     def configure_default_packages(self, variables, targets):
@@ -37,48 +54,16 @@ def configure_default_packages(self, variables, targets):
         board_config = self.board_config(variables.get("board"))
         mcu = variables.get("board_build.mcu", board_config.get("build.mcu", "esp32"))
         frameworks = variables.get("pioframework", [])
-        tl_flag = bool(os.path.exists(IDF_TOOLS))
-
-        # IDF Install is needed only one time
-        if not os.path.exists(join(IDF_TOOLS_PATH_DEFAULT, "tools")) and tl_flag:
-            rc = subprocess.call(IDF_TOOLS_CMD)
-            if rc != 0:
-                sys.stderr.write("Error: Couldn't execute 'idf_tools.py install'\n")
-            else:
-                shutil.copytree(join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-packages"), join(IDF_TOOLS_PATH_DEFAULT, "tools"), symlinks=False, ignore=None, ignore_dangling_symlinks=False, dirs_exist_ok=True)
-
-        if tl_flag:
-            # install tool is not needed anymore
-            self.packages["tl-install"]["optional"] = True
-            # Install all tools and toolchains
-            for p in self.packages:
-                if p in ("tool-mklittlefs", "tool-mkfatfs", "tool-mkspiffs", "tool-dfuutil", "tool-openocd", "tool-cmake", "tool-ninja", "tool-cppcheck", "tool-clangtidy", "tool-pvs-studio", "contrib-piohome", "contrib-pioremote", "tc-ulp", "tc-rv32", "tl-xt-gdb", "tl-rv-gdb"):
-                    tl_path = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", p)
-                    self.packages[p]["optional"] = False
-                    self.packages[p]["version"] = tl_path
-            # Enable common packages for IDF and mixed Arduino+IDF projects
-            for p in self.packages:
-                if p in ("tool-cmake", "tool-ninja", "tc-ulp"):
-                    self.packages[p]["optional"] = False if "espidf" in frameworks else True
-            # Enabling of following tools is not needed, installing is enough
-            for p in self.packages:
-                if p in ("contrib-pioremote", "contrib-piohome"):
-                    try:
-                        pkg_dir = pm.get_package(p).path
-                        # When package is not found an execption happens -> install is forced
-                        # else the are removed from current env
-                        self.packages[p]["optional"] = True
-                    except:
-                        pass
-
 
         # Enable debug tool gdb only when build debug is enabled
-        if variables.get("build_type") or  "debug" in "".join(targets):
-            self.packages["tl-rv-gdb"]["optional"] = False if mcu in ["esp32c2", "esp32c3", "esp32c6", "esp32h2"] else True
-            self.packages["tl-xt-gdb"]["optional"] = False if not mcu in ["esp32c2", "esp32c3", "esp32c6", "esp32h2"] else True
+        if (variables.get("build_type") or "debug" in "".join(targets)) and tl_flag:
+            self.packages["riscv32-esp-elf-gdb"]["optional"] = False if mcu in ["esp32c2", "esp32c3", "esp32c6", "esp32h2"] else True
+            self.packages["riscv32-esp-elf-gdb"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tl-rv-gdb")
+            self.packages["xtensa-esp-elf-gdb"]["optional"] = False if not mcu in ["esp32c2", "esp32c3", "esp32c6", "esp32h2"] else True
+            self.packages["xtensa-esp-elf-gdb"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tl-xt-gdb")
         else:
-            self.packages["tl-rv-gdb"]["optional"] = True
-            self.packages["tl-xt-gdb"]["optional"] = True
+            self.packages["riscv32-esp-elf-gdb"]["optional"] = True
+            self.packages["xtensa-esp-elf-gdb"]["optional"] = True
 
         # Enable check tools only when "check_tool" is enabled
         for p in self.packages:
@@ -93,17 +78,18 @@ def configure_default_packages(self, variables, targets):
             filesystem = variables.get("board_build.filesystem", "littlefs")
             if filesystem == "littlefs":
                 # Use mklittlefs v3.2.0 to generate FS
-                tl_path = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-mklittlefs")
                 self.packages["tool-mklittlefs"]["optional"] = False
-                self.packages["tool-mklittlefs"]["version"] = tl_path
+                self.packages["tool-mklittlefs"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-mklittlefs")
                 del self.packages["tool-mkfatfs"]
                 del self.packages["tool-mkspiffs"]
             elif filesystem == "fatfs":
                 self.packages["tool-mkfatfs"]["optional"] = False
+                self.packages["tool-mkfatfs"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-mkfatfs")
                 del self.packages["tool-mklittlefs"]
                 del self.packages["tool-mkspiffs"]
             elif filesystem == "spiffs":
                 self.packages["tool-mkspiffs"]["optional"] = False
+                self.packages["tool-mkspiffs"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-mkspiffs")
                 del self.packages["tool-mkfatfs"]
                 del self.packages["tool-mklittlefs"]
         else:
@@ -113,38 +99,41 @@ def configure_default_packages(self, variables, targets):
 
         if variables.get("upload_protocol"):
             self.packages["tool-openocd"]["optional"] = False
+            self.packages["tool-openocd"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-openocd")
         else:
             del self.packages["tool-openocd"]
 
         if "downloadfs" in targets:
             filesystem = variables.get("board_build.filesystem", "littlefs")
             if filesystem == "littlefs":
                 # Use mklittlefs v4.0.0 to unpack, older version is incompatible
-                tl_path = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-mklittlefs400")
                 self.packages["tool-mklittlefs"]["optional"] = False
-                self.packages["tool-mklittlefs"]["version"] = tl_path
+                self.packages["tool-mklittlefs"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-mklittlefs400")
 
         # Currently only Arduino Nano ESP32 uses the dfuutil tool as uploader
         if variables.get("board") == "arduino_nano_esp32":
             self.packages["tool-dfuutil"]["optional"] = False
+            self.packages["tool-dfuutil"]["version"] = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tool-dfuutil")
         else:
             del self.packages["tool-dfuutil"]
 
         # Enable needed toolchains
         for available_mcu in ("esp32", "esp32s2", "esp32s3"):
             if available_mcu == mcu and tl_flag:
                 tc_path = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tc-xt-%s" % mcu)
-                self.packages["tc-xt-%s" % mcu]["optional"] = False
-                self.packages["tc-xt-%s" % mcu]["version"] = tc_path
+                self.packages["toolchain-xtensa-%s" % mcu]["optional"] = False
+                self.packages["toolchain-xtensa-%s" % mcu]["version"] = tc_path
                 if available_mcu == "esp32":
-                    del self.packages["tc-rv32"]
-        # Enable ULP toolchains
+                    del self.packages["toolchain-riscv32-esp"]
+        # Enable riscv and ULP toolchains
         if mcu in ("esp32s2", "esp32s3", "esp32c2", "esp32c3", "esp32c6", "esp32h2"):
             if mcu in ("esp32c2", "esp32c3", "esp32c6", "esp32h2"):
-                del self.packages["tc-ulp"]
+                del self.packages["toolchain-esp32ulp"]
             # RISC-V based toolchain for ESP32C3, ESP32C6 ESP32S2, ESP32S3 ULP
             if tl_flag:
-                self.packages["tc-rv32"]["optional"] = False
+                tc_path = "file://" + join(IDF_TOOLS_PATH_DEFAULT, "tools", "tc-rv32")
+                self.packages["toolchain-riscv32-esp"]["optional"] = False
+                self.packages["toolchain-riscv32-esp"]["version"] = tc_path
 
         return super().configure_default_packages(variables, targets)
 
