cleaning up board config and switch tool

2026-04-19 06:23:44 +02:00 · 2025-09-06 17:10:46 +02:00
parent ad7b9b8be9
commit 909a2779ac
12 changed files with 284 additions and 3176 deletions
--- a/tools/switchBoardType.py
+++ b/tools/switchBoardType.py
@@ -1,5 +1,6 @@
 import os
 import argparse
+from typing import Dict, Optional, List

 HEADER_COLOR = "\033[95m"
 OKGREEN = '\033[92m'
@@ -7,38 +8,125 @@ WARNING = '\033[93m'
 OKBLUE = '\033[94m'
 ENDC = '\033[0m'

-sdkconfig_defaults = "sdkconfig.base_defaults"
-supported_boards = [
-  "xiao-esp32s3",
-  "project_babble",
-  "facefocusvr_face",
-  "facefocusvr_eye"
-]
-
-parser = argparse.ArgumentParser()
-parser.add_argument("-b", "--board", help="Board to switch to", choices=supported_boards)
-parser.add_argument("--dry-run", help="Dry run, won't modify files", action="store_true", required=False)
-parser.add_argument("--diff", help="Show the difference between base config and selected board", action="store_true", required=False)
-parser.add_argument("--ssid", help="Set the SSID for the selected board", required=False, type=str, default="")
-parser.add_argument("--password", help="Set the password For the provided network", required=False, type=str, default="")
-parser.add_argument("--clear-wifi", help="Should we clear the wifi details", action="store_true", required=False)
-args = parser.parse_args()
-
+BOARDS_DIR_NAME = "boards"
+SDKCONFIG_DEFAULTS_FILENAME = "sdkconfig.base_defaults"

 def get_root_path() -> str:
  return os.path.split(os.path.dirname(os.path.realpath(__file__)))[0]


+def get_boards_root() -> str:
+  return os.path.join(get_root_path(), BOARDS_DIR_NAME)
+
+
+def enumerate_board_configs() -> Dict[str, str]:
+  """Walk the boards directory and build a mapping of board names to absolute file paths.
+
+  Naming strategy:
+    - Relative path from boards/ to file with path separators replaced by '_'.
+    - If the last two path segments are identical (e.g. project_babble/project_babble) collapse to a single segment.
+    - For facefocusvr eye boards we keep eye_L / eye_R suffix to distinguish configs even though WHO_AM_I is same.
+  """
+  boards_dir = get_boards_root()
+  mapping: Dict[str, str] = {}
+  if not os.path.isdir(boards_dir):
+    return mapping
+  for root, _dirs, files in os.walk(boards_dir):
+    for f in files:
+      if f == SDKCONFIG_DEFAULTS_FILENAME:
+        continue
+      rel_path = os.path.relpath(os.path.join(root, f), boards_dir)
+      parts = rel_path.split(os.sep)
+      if len(parts) >= 2 and parts[-1] == parts[-2]:  # collapse duplicate tail
+        parts = parts[:-1]
+      board_key = "_".join(parts)
+      mapping[board_key] = os.path.join(root, f)
+  return mapping
+
+
+BOARD_CONFIGS = enumerate_board_configs()
+
+def build_arg_parser() -> argparse.ArgumentParser:
+  p = argparse.ArgumentParser()
+  p.add_argument("-b", "--board", help="Board name (run with --list to see options). Flexible: accepts path-like or partial if unique.")
+  p.add_argument("--list", help="List discovered boards and exit", action="store_true")
+  p.add_argument("--dry-run", help="Dry run, won't modify files", action="store_true")
+  p.add_argument("--diff", help="Show the difference between base config and selected board", action="store_true")
+  p.add_argument("--ssid", help="Set the WiFi SSID", type=str, default="")
+  p.add_argument("--password", help="Set the WiFi password", type=str, default="")
+  p.add_argument("--clear-wifi", help="Clear WiFi credentials", action="store_true")
+  return p
+
+def list_boards():
+  print("Discovered boards:")
+  width = max((len(k) for k in BOARD_CONFIGS), default=0)
+  for name, path in sorted(BOARD_CONFIGS.items()):
+    print(f"  {name.ljust(width)}  ->  {os.path.relpath(path, get_root_path())}")
+
+def _suggest_boards(partial: str) -> List[str]:
+  if not partial:
+    return []
+  partial_low = partial.lower()
+  contains = [b for b in BOARD_CONFIGS if partial_low in b.lower()]
+  if contains:
+    return contains[:10]
+  # simple levenshtein distance limited (manual lightweight)
+  def distance(a: str, b: str) -> int:
+    if len(a) < len(b):
+      a, b = b, a
+    prev = list(range(len(b)+1))
+    for i, ca in enumerate(a, 1):
+      cur = [i]
+      for j, cb in enumerate(b, 1):
+        ins = cur[j-1] + 1
+        dele = prev[j] + 1
+        sub = prev[j-1] + (ca != cb)
+        cur.append(min(ins, dele, sub))
+      prev = cur
+    return prev[-1]
+  ranked = sorted(BOARD_CONFIGS, key=lambda k: distance(partial_low, k.lower()))
+  return ranked[:5]
+
+def normalize_board_name(raw: Optional[str]) -> Optional[str]:
+  if raw is None:
+    return None
+  candidate = raw.strip()
+  if not candidate:
+    return None
+  candidate = candidate.replace('\\', '/').rstrip('/')
+  # strip leading folders like tools/, boards/
+  parts = [p for p in candidate.split('/') if p not in ('.', '') and p not in ('tools', 'boards')]
+  if parts:
+    candidate = parts[-1] if len(parts) == 1 else "_".join(parts)
+  candidate = candidate.replace('-', '_')
+  # exact match
+  if candidate in BOARD_CONFIGS:
+    return candidate
+  # try ending match
+  endings = [b for b in BOARD_CONFIGS if b.endswith(candidate)]
+  if len(endings) == 1:
+    return endings[0]
+  if len(endings) > 1:
+    print(f"Ambiguous board '{raw}'. Could be: {', '.join(endings)}")
+    return None
+  # attempt case-insensitive
+  lower_map = {b.lower(): b for b in BOARD_CONFIGS}
+  if candidate.lower() in lower_map:
+    return lower_map[candidate.lower()]
+  return None
+
+
 def get_main_config_path() -> str:
  return os.path.join(get_root_path(), "sdkconfig")


-def get_board_config_path() -> str:
-  return os.path.join(get_root_path(), f"sdkconfig.board.{args.board}")
+def get_board_config_path(board_key: str) -> str:
+  return BOARD_CONFIGS[board_key]


 def get_base_config_path() -> str:
-  return os.path.join(get_root_path(), sdkconfig_defaults)
+  # base defaults moved under boards directory
+  return os.path.join(get_boards_root(), SDKCONFIG_DEFAULTS_FILENAME)


 def parse_config(config_file) -> dict:
@@ -53,15 +141,17 @@ def parse_config(config_file) -> dict:
  return config


-def handle_wifi_config(_new_config: dict, _main_config: dict) -> dict:
-  if args.ssid:
-    _new_config["CONFIG_WIFI_SSID"] = f"\"{args.ssid}\""
-    _new_config["CONFIG_WIFI_PASSWORD"] = f"\"{args.password}\""
+def handle_wifi_config(_new_config: dict, _main_config: dict, _args) -> dict:
+  if _args.ssid:
+    _new_config["CONFIG_WIFI_SSID"] = f"\"{_args.ssid}\""
+    _new_config["CONFIG_WIFI_PASSWORD"] = f"\"{_args.password}\""
  else:
-    _new_config["CONFIG_WIFI_SSID"] = _main_config["CONFIG_WIFI_SSID"]
-    _new_config["CONFIG_WIFI_PASSWORD"] = _main_config["CONFIG_WIFI_PASSWORD"]
+    if "CONFIG_WIFI_SSID" in _main_config:
+      _new_config["CONFIG_WIFI_SSID"] = _main_config["CONFIG_WIFI_SSID"]
+    if "CONFIG_WIFI_PASSWORD" in _main_config:
+      _new_config["CONFIG_WIFI_PASSWORD"] = _main_config["CONFIG_WIFI_PASSWORD"]

-  if args.clear_wifi:
+  if _args.clear_wifi:
    _new_config["CONFIG_WIFI_SSID"] = "\"\""
    _new_config["CONFIG_WIFI_PASSWORD"] = "\"\""
  return _new_config
@@ -79,51 +169,65 @@ def compute_diff(_parsed_base_config: dict, _parsed_board_config: dict) -> dict:
  return _diff


-print(f"{OKGREEN}Switching configuration to board:{ENDC} {OKBLUE}{args.board}{ENDC}")
-print(f"{OKGREEN}Using defaults from :{ENDC} {get_base_config_path()}", )
-print(f"{OKGREEN}Using board config from :{ENDC} {get_board_config_path()}")
+def main():
+  parser = build_arg_parser()
+  args = parser.parse_args()

-main_config = open(get_main_config_path(), "r+")
-parsed_main_config = parse_config(main_config)
-main_config.close()
+  if args.list:
+    list_boards()
+    return

-base_config = open(get_base_config_path(), "r")
-board_config = open(get_board_config_path(), "r")
+  board_input = args.board
+  if not board_input:
+    parser.error("--board is required (or use --list)")
+  normalized = normalize_board_name(board_input)
+  if not normalized:
+    print(f"{WARNING}Unknown board '{board_input}'.")
+    suggestions = _suggest_boards(board_input)
+    if suggestions:
+      print("Did you mean: " + ", ".join(suggestions))
+    print("Use --list to see all boards.")
+    raise SystemExit(2)

-parsed_base_config = parse_config(base_config)
-parsed_board_config = parse_config(board_config)
+  if not os.path.isfile(get_base_config_path()):
+    raise SystemExit(f"Base defaults file not found: {get_base_config_path()}")

-base_config.close()
-board_config.close()
+  print(f"{OKGREEN}Switching configuration to board:{ENDC} {OKBLUE}{normalized}{ENDC}")
+  print(f"{OKGREEN}Using defaults from :{ENDC} {get_base_config_path()}")
+  print(f"{OKGREEN}Using board config from :{ENDC} {get_board_config_path(normalized)}")

-new_board_config = {**parsed_base_config, **parsed_board_config}
-new_board_config = handle_wifi_config(new_board_config, parsed_main_config)
+  with open(get_main_config_path(), "r+") as main_config:
+    parsed_main_config = parse_config(main_config)

-if args.diff:
-  print("---"*5, f"{WARNING}DIFF{ENDC}", "---"*5)
-  diff = compute_diff(parsed_main_config, new_board_config)
-  if not diff:
-    print(f"{HEADER_COLOR}[DIFF]{ENDC} Nothing has changed between the base config and {OKBLUE}{args.board}{ENDC} config")
+  with open(get_base_config_path(), "r") as base_config, open(get_board_config_path(normalized), "r") as board_config:
+    parsed_base_config = parse_config(base_config)
+    parsed_board_config = parse_config(board_config)
+
+  new_board_config = {**parsed_base_config, **parsed_board_config}
+  new_board_config = handle_wifi_config(new_board_config, parsed_main_config, args)
+
+  if args.diff:
+    print("---"*5, f"{WARNING}DIFF{ENDC}", "---"*5)
+    diff = compute_diff(parsed_main_config, new_board_config)
+    if not diff:
+      print(f"{HEADER_COLOR}[DIFF]{ENDC} No changes between existing main config and {OKBLUE}{normalized}{ENDC}")
+    else:
+      print(f"{HEADER_COLOR}[DIFF]{ENDC} Keys differing (main -> new {OKBLUE}{normalized}{ENDC}):")
+      for key in sorted(diff):
+        print(f"{HEADER_COLOR}[DIFF]{ENDC} {key} : {diff[key]}")
+    print("---"*14)
+
+  if not args.dry_run:
+    print(f"{WARNING}Writing changes to main config file{ENDC}")
+    with open(get_main_config_path(), "w") as main_config:
+      for key, value in new_board_config.items():
+        if value:
+          main_config.write(f"{key}={value}\n")
+        else:
+          main_config.write(f"{key}\n")
  else:
-    print(f"{HEADER_COLOR}[DIFF]{ENDC} The following keys have changed between the base config and {OKBLUE}{args.board}{ENDC} config:")
-    for key in diff:
-      print(f"{HEADER_COLOR}[DIFF]{ENDC} {key} : {diff[key]}")
-  print("---"*14)
+    print(f"{WARNING}[DRY-RUN]{ENDC} Skipping writing to files")
+  print(f"{OKGREEN}Done. ESP-IDF is setup to build for:{ENDC} {OKBLUE}{normalized}{ENDC}")

-if not args.dry_run:
-  # the main idea is to always replace the main config with the base config
-  # and then add the board config on top of that, overriding where necessary.
-  # This way we can have known working defaults safe from accidental modifications by espidf
-  # with know working per-board config 
-  # and a still modifiable sdkconfig for espidf
-
-  print(f"{WARNING}Writing changes to main config file{ENDC}")
-  with open(get_main_config_path(), "w") as main_config:
-    for key, value in new_board_config.items():
-      if value:
-        main_config.write(f"{key}={value}\n")
-      else:
-        main_config.write(f"{key}\n")
-else:
-  print(f"{WARNING}[DRY-RUN]{ENDC} Skipping writing to files")
-print(f"{OKGREEN}Done. ESP-IDF is setup to build for:{ENDC} {OKBLUE}{args.board}{ENDC}")
+if __name__ == "__main__":  # pragma: no cover
+  main()