mirror of
https://github.com/78/xiaozhi-esp32.git
synced 2026-02-17 17:38:08 +00:00
3afeae16eb
- Changed the build job name in the GitHub Actions workflow to use the full name of the matrix variant for better clarity. - Refactored CMakeLists.txt to improve the formatting of the BOARD_SOURCES file globbing. - Added manufacturer information to the config.json files for the eda-robot-pro, eda-super-bear, and eda-tv-pro boards to ensure consistency in configuration.
360 lines
13 KiB
Python
Executable File
360 lines
13 KiB
Python
Executable File
import sys
|
|
import os
|
|
import json
|
|
import zipfile
|
|
import argparse
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
# Switch to project root directory
|
|
os.chdir(Path(__file__).resolve().parent.parent)
|
|
|
|
################################################################################
|
|
# Common utility functions
|
|
################################################################################
|
|
|
|
def get_board_type_from_compile_commands() -> Optional[str]:
|
|
"""Parse the current compiled BOARD_TYPE from build/compile_commands.json"""
|
|
compile_file = Path("build/compile_commands.json")
|
|
if not compile_file.exists():
|
|
return None
|
|
with compile_file.open() as f:
|
|
data = json.load(f)
|
|
for item in data:
|
|
if not item["file"].endswith("main.cc"):
|
|
continue
|
|
cmd = item["command"]
|
|
if "-DBOARD_TYPE=\\\"" in cmd:
|
|
return cmd.split("-DBOARD_TYPE=\\\"")[1].split("\\\"")[0].strip()
|
|
return None
|
|
|
|
|
|
def get_project_version() -> Optional[str]:
|
|
"""Read set(PROJECT_VER "x.y.z") from root CMakeLists.txt"""
|
|
with Path("CMakeLists.txt").open() as f:
|
|
for line in f:
|
|
if line.startswith("set(PROJECT_VER"):
|
|
return line.split("\"")[1]
|
|
return None
|
|
|
|
|
|
def merge_bin() -> None:
|
|
if os.system("idf.py merge-bin") != 0:
|
|
print("merge-bin failed", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
|
|
def zip_bin(name: str, version: str) -> None:
|
|
"""Zip build/merged-binary.bin to releases/v{version}_{name}.zip"""
|
|
out_dir = Path("releases")
|
|
out_dir.mkdir(exist_ok=True)
|
|
output_path = out_dir / f"v{version}_{name}.zip"
|
|
|
|
if output_path.exists():
|
|
output_path.unlink()
|
|
|
|
with zipfile.ZipFile(output_path, "w", compression=zipfile.ZIP_DEFLATED) as zipf:
|
|
zipf.write("build/merged-binary.bin", arcname="merged-binary.bin")
|
|
print(f"zip bin to {output_path} done")
|
|
|
|
def _get_manufacturer(cfg: dict) -> Optional[str]:
|
|
"""Read manufacturer from config.json"""
|
|
m = cfg.get("manufacturer")
|
|
if isinstance(m, str) and m.strip():
|
|
return m.strip()
|
|
return None
|
|
|
|
################################################################################
|
|
# board / variant related functions
|
|
################################################################################
|
|
|
|
_BOARDS_DIR = Path("main/boards")
|
|
|
|
def _collect_variants(config_filename: str = "config.json") -> list[dict[str, str]]:
|
|
"""Traverse all boards under main/boards, collect variant information.
|
|
|
|
Return example:
|
|
[{"board": "bread-compact-ml307", "name": "bread-compact-ml307", "full_name": "bread-compact-ml307"}, ...]
|
|
[{"board": "waveshare/esp32-p4-nano", "name": "esp32-p4-nano-10.1-a", "full_name": "waveshare-esp32-p4-nano-10.1-a"}, ...]
|
|
"""
|
|
variants: list[dict[str, str]] = []
|
|
errors: list[str] = []
|
|
|
|
for cfg_path in _BOARDS_DIR.rglob(config_filename):
|
|
board_dir = cfg_path.parent
|
|
if board_dir.name == "common":
|
|
continue
|
|
board = board_dir.relative_to(_BOARDS_DIR).as_posix()
|
|
|
|
try:
|
|
with cfg_path.open() as f:
|
|
cfg = json.load(f)
|
|
|
|
manufacturer = _get_manufacturer(cfg)
|
|
|
|
# Check manufacturer consistency with directory structure
|
|
if "/" in board:
|
|
# Board is in a subdirectory (e.g., waveshare/esp32-p4-nano)
|
|
expected_manufacturer = board.split("/")[0]
|
|
if not manufacturer:
|
|
errors.append(
|
|
f"{cfg_path}: Board is in '{expected_manufacturer}/' subdirectory, "
|
|
f"but config.json is missing \"manufacturer\": \"{expected_manufacturer}\""
|
|
)
|
|
elif manufacturer != expected_manufacturer:
|
|
errors.append(
|
|
f"{cfg_path}: manufacturer mismatch, "
|
|
f"directory is '{expected_manufacturer}/' but config.json has \"{manufacturer}\""
|
|
)
|
|
else:
|
|
# Board is directly under boards/ directory
|
|
if manufacturer:
|
|
errors.append(
|
|
f"{cfg_path}: Board is not in a manufacturer subdirectory, "
|
|
f"but config.json defines manufacturer \"{manufacturer}\", "
|
|
f"please move board to main/boards/{manufacturer}/{board}/"
|
|
)
|
|
|
|
for build in cfg.get("builds", []):
|
|
name = build["name"]
|
|
full_name = f"{manufacturer}-{name}" if manufacturer else name
|
|
variants.append({
|
|
"board": board,
|
|
"name": name,
|
|
"full_name": full_name
|
|
})
|
|
|
|
except Exception as e:
|
|
print(f"[ERROR] Failed to parse {cfg_path}: {e}", file=sys.stderr)
|
|
|
|
# Report all errors at once
|
|
if errors:
|
|
print("\n[ERROR] Found manufacturer configuration issues:", file=sys.stderr)
|
|
for err in errors:
|
|
print(f" - {err}", file=sys.stderr)
|
|
print(file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
return variants
|
|
|
|
|
|
|
|
def _find_board_config(board_type: str) -> Optional[str]:
|
|
"""Find the corresponding CONFIG_BOARD_TYPE_xxx for the given board_type
|
|
|
|
Search backwards from 'set(BOARD_TYPE "xxx")' to find the nearest if(CONFIG_BOARD_TYPE_).
|
|
"""
|
|
board_leaf = board_type.split("/")[-1]
|
|
pattern = f'set(BOARD_TYPE "{board_leaf}")'
|
|
|
|
cmake_file = Path("main/CMakeLists.txt")
|
|
lines = cmake_file.read_text(encoding="utf-8").splitlines()
|
|
|
|
for idx, line in enumerate(lines):
|
|
if pattern in line:
|
|
# Found the BOARD_TYPE line, search backwards for the config
|
|
for back_idx in range(idx - 1, -1, -1):
|
|
back_line = lines[back_idx]
|
|
if "if(CONFIG_BOARD_TYPE_" in back_line:
|
|
return back_line.strip().split("if(")[1].split(")")[0]
|
|
break
|
|
return None
|
|
|
|
|
|
# Kconfig "select" entries are not automatically applied when we simply append
|
|
# sdkconfig lines from config.json, so add the required dependencies here to
|
|
# mimic menuconfig behaviour.
|
|
_AUTO_SELECT_RULES: dict[str, list[str]] = {
|
|
"CONFIG_USE_ESP_BLUFI_WIFI_PROVISIONING": [
|
|
"CONFIG_BT_ENABLED=y",
|
|
"CONFIG_BT_BLUEDROID_ENABLED=y",
|
|
"CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y",
|
|
"CONFIG_BT_BLE_50_FEATURES_SUPPORTED=n",
|
|
"CONFIG_BT_BLE_BLUFI_ENABLE=y",
|
|
"CONFIG_MBEDTLS_DHM_C=y",
|
|
],
|
|
}
|
|
|
|
|
|
def _apply_auto_selects(sdkconfig_append: list[str]) -> list[str]:
|
|
"""Apply hardcoded auto-select rules to sdkconfig_append."""
|
|
items: list[str] = []
|
|
existing_keys: set[str] = set()
|
|
|
|
def _append_if_missing(entry: str) -> None:
|
|
key = entry.split("=", 1)[0]
|
|
if key not in existing_keys:
|
|
items.append(entry)
|
|
existing_keys.add(key)
|
|
|
|
# Preserve original order while tracking keys
|
|
for entry in sdkconfig_append:
|
|
_append_if_missing(entry)
|
|
|
|
# Apply auto-select rules
|
|
for key, deps in _AUTO_SELECT_RULES.items():
|
|
for entry in sdkconfig_append:
|
|
name, _, value = entry.partition("=")
|
|
if name == key and value.lower().startswith("y"):
|
|
for dep in deps:
|
|
_append_if_missing(dep)
|
|
break
|
|
|
|
return items
|
|
|
|
################################################################################
|
|
# Check board_type in CMakeLists
|
|
################################################################################
|
|
|
|
def _board_type_exists(board_type: str) -> bool:
|
|
cmake_file = Path("main/CMakeLists.txt").read_text(encoding="utf-8")
|
|
board_leaf = board_type.split("/")[-1]
|
|
pattern = f'set(BOARD_TYPE "{board_leaf}")'
|
|
return pattern in cmake_file
|
|
|
|
################################################################################
|
|
# Compile implementation
|
|
################################################################################
|
|
|
|
def release(board_type: str, config_filename: str = "config.json", *, filter_name: Optional[str] = None) -> None:
|
|
"""Compile and package all/specified variants of the specified board_type
|
|
|
|
Args:
|
|
board_type: directory name under main/boards
|
|
config_filename: config.json name (default: config.json)
|
|
filter_name: if specified, only compile the build["name"] that matches
|
|
"""
|
|
cfg_path = _BOARDS_DIR / Path(board_type) / config_filename
|
|
if not cfg_path.exists():
|
|
print(f"[WARN] {cfg_path} does not exist, skipping {board_type}")
|
|
return
|
|
|
|
project_version = get_project_version()
|
|
print(f"Project Version: {project_version} ({cfg_path})")
|
|
|
|
with cfg_path.open() as f:
|
|
cfg = json.load(f)
|
|
target = cfg["target"]
|
|
manufacturer = _get_manufacturer(cfg)
|
|
|
|
builds = cfg.get("builds", [])
|
|
if filter_name:
|
|
builds = [b for b in builds if b["name"] == filter_name]
|
|
if not builds:
|
|
print(f"[ERROR] Variant {filter_name} not found in {board_type}'s {config_filename}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
for build in builds:
|
|
name = build["name"]
|
|
board_leaf = board_type.split("/")[-1]
|
|
|
|
if board_leaf not in name:
|
|
raise ValueError(f"build.name {name} must contain {board_leaf}")
|
|
|
|
final_name = f"{manufacturer}-{name}" if manufacturer else name
|
|
output_path = Path("releases") / f"v{project_version}_{final_name}.zip"
|
|
if output_path.exists():
|
|
print(f"Skipping {final_name} because {output_path} already exists")
|
|
continue
|
|
|
|
# Process sdkconfig_append
|
|
board_type_config = _find_board_config(board_type)
|
|
sdkconfig_append = [f"{board_type_config}=y"]
|
|
sdkconfig_append.extend(build.get("sdkconfig_append", []))
|
|
sdkconfig_append = _apply_auto_selects(sdkconfig_append)
|
|
|
|
print("-" * 80)
|
|
print(f"name: {final_name}")
|
|
print(f"target: {target}")
|
|
if manufacturer:
|
|
print(f"manufacturer: {manufacturer}")
|
|
for item in sdkconfig_append:
|
|
print(f"sdkconfig_append: {item}")
|
|
|
|
os.environ.pop("IDF_TARGET", None)
|
|
|
|
# Call set-target
|
|
if os.system(f"idf.py set-target {target}") != 0:
|
|
print("set-target failed", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Append sdkconfig
|
|
with Path("sdkconfig").open("a") as f:
|
|
f.write("\n")
|
|
f.write("# Append by release.py\n")
|
|
for append in sdkconfig_append:
|
|
f.write(f"{append}\n")
|
|
# Build with macro BOARD_NAME defined to name
|
|
if os.system(f"idf.py -DBOARD_NAME={name} -DBOARD_TYPE={board_type} build") != 0:
|
|
print("build failed")
|
|
sys.exit(1)
|
|
|
|
# merge-bin
|
|
merge_bin()
|
|
|
|
# Zip
|
|
zip_bin(final_name, project_version)
|
|
|
|
################################################################################
|
|
# CLI entry
|
|
################################################################################
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("board", nargs="?", default=None, help="Board type or 'all'")
|
|
parser.add_argument("-c", "--config", default="config.json", help="Config filename (default: config.json)")
|
|
parser.add_argument("--list-boards", action="store_true", help="List all supported boards and variants")
|
|
parser.add_argument("--json", action="store_true", help="Output in JSON format (use with --list-boards)")
|
|
parser.add_argument("--name", help="Variant name to compile (original name without manufacturer prefix)")
|
|
|
|
args = parser.parse_args()
|
|
|
|
# List mode
|
|
if args.list_boards:
|
|
variants = _collect_variants(config_filename=args.config)
|
|
if args.json:
|
|
print(json.dumps(variants))
|
|
else:
|
|
for v in variants:
|
|
print(f"{v['board']}: {v['name']}")
|
|
sys.exit(0)
|
|
|
|
# Current directory firmware packaging mode
|
|
if args.board is None:
|
|
merge_bin()
|
|
curr_board_type = get_board_type_from_compile_commands()
|
|
if curr_board_type is None:
|
|
print("Failed to parse board_type from compile_commands.json", file=sys.stderr)
|
|
sys.exit(1)
|
|
project_ver = get_project_version()
|
|
zip_bin(curr_board_type, project_ver)
|
|
sys.exit(0)
|
|
|
|
# Compile mode
|
|
board_type_input: str = args.board
|
|
name_filter: Optional[str] = args.name
|
|
|
|
# Check board_type in CMakeLists
|
|
if board_type_input != "all" and not _board_type_exists(board_type_input):
|
|
print(f"[ERROR] board_type {board_type_input} not found in main/CMakeLists.txt", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
variants_all = _collect_variants(config_filename=args.config)
|
|
|
|
# Filter board_type list
|
|
target_board_types: set[str]
|
|
if board_type_input == "all":
|
|
target_board_types = {v["board"] for v in variants_all}
|
|
else:
|
|
target_board_types = {board_type_input}
|
|
|
|
for bt in sorted(target_board_types):
|
|
if not _board_type_exists(bt):
|
|
print(f"[ERROR] board_type {bt} not found in main/CMakeLists.txt", file=sys.stderr)
|
|
sys.exit(1)
|
|
cfg_path = _BOARDS_DIR / bt / args.config
|
|
if bt == board_type_input and not cfg_path.exists():
|
|
print(f"Board {bt} has no {args.config} config file, skipping")
|
|
sys.exit(0)
|
|
release(bt, config_filename=args.config, filter_name=name_filter if bt == board_type_input else None)
|