add dynamic toolchain configuration

Author: Jason2866

platform.py

@@ -63,6 +63,46 @@ def configure_default_packages(self, variables, targets):
         else:
             del self.packages["tool-dfuutil-arduino"]
 
+        build_core = variables.get(
+            "board_build.core", board_config.get("build.core", "arduino")
+        ).lower()
+
+        if frameworks == ["arduino"] and build_core == "esp32":
+            # In case the upstream Arduino framework is specified in the configuration
+            # file then we need to dynamically extract toolchain versions from the
+            # Arduino index file. This feature can be disabled via a special option:
+            if (
+                variables.get(
+                    "board_build.arduino.upstream_packages",
+                    board_config.get("build.arduino.upstream_packages", "no"),
+                ).lower()
+                == "yes"
+            ):
+                package_version = self.packages["framework-arduinoespressif32"][
+                    "version"
+                ]
+
+                url_items = urllib.parse.urlparse(package_version)
+                # Only GitHub repositories support dynamic packages
+                if (
+                    url_items.scheme in ("http", "https")
+                    and url_items.netloc.startswith("github")
+                    and url_items.path.endswith(".git")
+                ):
+                    try:
+                        self.configure_upstream_arduino_packages(url_items)
+                    except Exception as e:
+                        sys.stderr.write(
+                            "Error! Failed to extract upstream toolchain"
+                            "configurations:\n%s\n" % str(e)
+                        )
+                        sys.stderr.write(
+                            "You can disable this feature via the "
+                            "`board_build.arduino.upstream_packages = no` setting in "
+                            "your `platformio.ini` file.\n"
+                        )
+                        sys.exit(1)
+
         # Starting from v12, Espressif's toolchains are shipped without
         # bundled GDB. Instead, it's distributed as separate packages for Xtensa
         # and RISC-V targets.
@@ -131,6 +171,9 @@ def _add_dynamic_options(self, board):
             "tumpa",
         ]
 
+        # A special case for the Kaluga board that has a separate interface config
+        if board.id == "esp32-s2-kaluga-1":
+            supported_debug_tools.append("ftdi")
         if board.get("build.mcu", "") in ("esp32c3", "esp32c6", "esp32s3", "esp32h2"):
             supported_debug_tools.append("esp-builtin")
 
@@ -201,6 +244,9 @@ def _add_dynamic_options(self, board):
                 "default": link == debug.get("default_tool"),
             }
 
+            # Avoid erasing Arduino Nano bootloader by preloading app binary
+            if board.id == "arduino_nano_esp32":
+                debug["tools"][link]["load_cmds"] = "preload"
         board.manifest["debug"] = debug
         return board
 
@@ -236,3 +282,114 @@ def configure_debug_session(self, debug_config):
             )
         )
         debug_config.load_cmds = load_cmds
+
+
+    @staticmethod
+    def extract_toolchain_versions(tool_deps):
+        def _parse_version(original_version):
+            assert original_version
+            version_patterns = (
+                r"^gcc(?P<MAJOR>\d+)_(?P<MINOR>\d+)_(?P<PATCH>\d+)-esp-(?P<EXTRA>.+)$",
+                r"^esp-(?P<EXTRA>.+)-(?P<MAJOR>\d+)\.(?P<MINOR>\d+)\.?(?P<PATCH>\d+)$",
+                r"^esp-(?P<MAJOR>\d+)\.(?P<MINOR>\d+)\.(?P<PATCH>\d+)(_(?P<EXTRA>.+))?$",
+            )
+            for pattern in version_patterns:
+                match = re.search(pattern, original_version)
+                if match:
+                    result = "%s.%s.%s" % (
+                        match.group("MAJOR"),
+                        match.group("MINOR"),
+                        match.group("PATCH"),
+                    )
+                    if match.group("EXTRA"):
+                        result = result + "+%s" % match.group("EXTRA")
+                    return result
+
+            raise ValueError("Bad package version `%s`" % original_version)
+
+        if not tool_deps:
+            raise ValueError(
+                ("Failed to extract tool dependencies from the remote package file")
+            )
+
+        toolchain_remap = {
+            "xtensa-esp32-elf-gcc": "toolchain-xtensa-esp32",
+            "xtensa-esp32s2-elf-gcc": "toolchain-xtensa-esp32s2",
+            "xtensa-esp32s3-elf-gcc": "toolchain-xtensa-esp32s3",
+            "riscv32-esp-elf-gcc": "toolchain-riscv32-esp",
+        }
+
+        result = dict()
+        for tool in tool_deps:
+            if tool["name"] in toolchain_remap:
+                result[toolchain_remap[tool["name"]]] = _parse_version(tool["version"])
+
+        return result
+
+    @staticmethod
+    def parse_tool_dependencies(index_data):
+        for package in index_data.get("packages", []):
+            if package["name"] == "esp32":
+                for platform in package["platforms"]:
+                    if platform["name"] == "esp32":
+                        return platform["toolsDependencies"]
+
+        return []
+
+    @staticmethod
+    def download_remote_package_index(url_items):
+        def _prepare_url_for_index_file(url_items):
+            tag = "master"
+            if url_items.fragment:
+                tag = url_items.fragment
+            return (
+                "https://raw.githubusercontent.com/%s/"
+                "%s/package/package_esp32_index.template.json"
+                % (url_items.path.replace(".git", ""), tag)
+            )
+
+        index_file_url = _prepare_url_for_index_file(url_items)
+
+        try:
+            from platformio.public import fetch_http_content
+            content = fetch_http_content(index_file_url)
+        except ImportError:
+            import requests
+            content = requests.get(index_file_url, timeout=5).text
+
+        return json.loads(content)
+
+    def configure_arduino_toolchains(self, package_index):
+        if not package_index:
+            return
+
+        toolchain_packages = self.extract_toolchain_versions(
+            self.parse_tool_dependencies(package_index)
+        )
+        for toolchain_package, version in toolchain_packages.items():
+            if toolchain_package not in self.packages:
+                self.packages[toolchain_package] = dict()
+            self.packages[toolchain_package]["version"] = version
+            self.packages[toolchain_package]["owner"] = "espressif"
+            self.packages[toolchain_package]["type"] = "toolchain"
+
+    def configure_upstream_arduino_packages(self, url_items):
+        framework_index_file = os.path.join(
+            self.get_package_dir("framework-arduinoespressif32") or "",
+            "package",
+            "package_esp32_index.template.json",
+        )
+
+        # Detect whether the remote is already cloned
+        if os.path.isfile(framework_index_file) and os.path.isdir(
+            os.path.join(
+                self.get_package_dir("framework-arduinoespressif32") or "", ".git"
+            )
+        ):
+            with open(framework_index_file) as fp:
+                self.configure_arduino_toolchains(json.load(fp))
+        else:
+            print("Configuring toolchain packages from a remote source...")
+            self.configure_arduino_toolchains(
+                self.download_remote_package_index(url_items)
+            )