microchip-devtools 0.1.0__py3-none-any.whl

microchip_devtools/_project.py

@@ -0,0 +1,14 @@
+"""Project context helpers — read from environment vars set by Makefile.py."""
+
+import os
+from pathlib import Path
+
+
+def project_name() -> str:
+    """Return project name from env var or current directory name."""
+    return os.environ.get("VOLTU_PROJECT_NAME", Path.cwd().name)
+
+
+def project_root() -> Path:
+    """Return project root from env var or current working directory."""
+    return Path(os.environ.get("VOLTU_PROJECT_ROOT", str(Path.cwd())))

microchip_devtools/format/uncrustify.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+microchip_devtools.format.uncrustify — Python wrapper for uncrustify.
+
+Walks one or more source roots, collects C/H files, runs uncrustify,
+and reports which files were actually reformatted.
+
+CLI usage:
+    mchp-format firmware/src -c uncrustifyVoltuC.cfg -x config mcc build
+
+Python usage:
+    from microchip_devtools.format.uncrustify import format_files
+    rc = format_files(roots=["firmware/src"], config="style.cfg", exclude=["config"])
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+DEFAULT_EXTENSIONS: list[str] = [".c", ".h"]
+DEFAULT_CONFIG: str = "uncrustifyVoltuC.cfg"
+
+
+def _collect_files(
+    roots: list[Path],
+    extensions: list[str],
+    exclude: list[str],
+) -> list[Path]:
+    found: list[Path] = []
+    for root in roots:
+        if not root.is_dir():
+            print(f"uncrustify: warning: root not found: {root}", file=sys.stderr)
+            continue
+        for ext in extensions:
+            for path in sorted(root.rglob(f"*{ext}")):
+                rel = path.as_posix()
+                if not any(pat in rel for pat in exclude):
+                    found.append(path)
+    return found
+
+
+def _run_uncrustify(path: Path, config: str) -> tuple[bool, str]:
+    mtime_before = path.stat().st_mtime
+    result = subprocess.run(
+        [
+            "uncrustify",
+            "-c", config,
+            "--replace",
+            "--no-backup",
+            "--if-changed",
+            str(path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        msg = (result.stderr or result.stdout).strip()
+        return False, msg
+
+    changed = path.stat().st_mtime != mtime_before
+    return changed, ""
+
+
+def format_files(
+    roots: list[str | Path],
+    config: str = DEFAULT_CONFIG,
+    extensions: list[str] | None = None,
+    exclude: list[str] | None = None,
+) -> int:
+    if extensions is None:
+        extensions = DEFAULT_EXTENSIONS
+    if exclude is None:
+        exclude = []
+
+    root_paths = [Path(r) for r in roots]
+    files = _collect_files(root_paths, extensions, exclude)
+
+    if not files:
+        print("uncrustify: no files matched — check roots and exclude patterns")
+        return 0
+
+    formatted: list[Path] = []
+    errors: list[tuple[Path, str]] = []
+
+    for path in files:
+        changed, err = _run_uncrustify(path, config)
+        if err:
+            errors.append((path, err))
+        elif changed:
+            formatted.append(path)
+
+    for f in formatted:
+        print(f"    FM  {f}")
+
+    if errors:
+        print(f"\n  [{len(errors)} error(s)]", file=sys.stderr)
+        for f, msg in errors:
+            print(f"  ERROR  {f}\n         {msg}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Run uncrustify on a source tree and report reformatted files.",
+    )
+    parser.add_argument("roots", nargs="+", metavar="ROOT")
+    parser.add_argument("-c", "--config", default=DEFAULT_CONFIG, metavar="FILE")
+    parser.add_argument("-e", "--ext", nargs="+", default=DEFAULT_EXTENSIONS, metavar="EXT")
+    parser.add_argument("-x", "--exclude", nargs="+", default=[], metavar="PATTERN")
+
+    args = parser.parse_args()
+    sys.exit(format_files(args.roots, args.config, args.ext, args.exclude))
+
+
+if __name__ == "__main__":
+    main()

microchip_devtools/list_cmds.py

@@ -0,0 +1,31 @@
+from rich.console import Console
+from rich.table import Table
+from rich.theme import Theme
+
+_THEME = Theme(
+    {
+        "cmd": "bold cyan",
+        "desc": "default",
+    }
+)
+
+COMMANDS = [
+    ("mchp-list", "List all available mchp commands"),
+    ("mchp-setup", "Check prerequisites and install project deps"),
+    ("mchp-xc32", "Detect XC32 fmt=3 compiler bug in ELF/object files"),
+    ("mchp-hex", "Merge bootloader + app HEX into a single image"),
+    ("mchp-fmt", "Format C/H source files with uncrustify"),
+    ("mchp-mcc", "Force full MCC regeneration workflow"),
+    ("mchp-periph", "Validate MCC-generated peripheral config files"),
+    ("mchp-hw", "Show hardware config parsed from Harmony YML files"),
+]
+
+
+def main():
+    console = Console(theme=_THEME, highlight=False)
+    table = Table(box=None, show_header=False, padding=(0, 2, 0, 0))
+    table.add_column(style="cmd", no_wrap=True)
+    table.add_column(style="desc")
+    for cmd, desc in COMMANDS:
+        table.add_row(cmd, desc)
+    console.print(table)

microchip_devtools/mcc/check_peripheral.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+microchip_devtools.mcc.check_peripheral — Validate MCC-generated peripheral config files.
+
+Prevents two silent hardware bugs:
+
+  Bug 1 — MIPS interrupt vector stub missing in interrupts_a.S for a handler
+           declared in interrupts.c. Without a stub, the ISR never fires.
+
+  Bug 3 — Peripheral clock gated in PMD (plib_clk.c) while enabled in MCC
+           (core.yml). PMD registers are write-once per reset.
+
+Usage:
+    mchp-check-peripheral [--root PATH] [--project-name NAME] [--stubs-file PATH]
+
+Exit code:
+    0 — all checks passed
+    1 — one or more checks failed
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+from microchip_devtools._project import project_name as _env_project_name
+from microchip_devtools._project import project_root as _env_project_root
+
+
+def _read(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        print(f"[ERROR] File not found: {path}", file=sys.stderr)
+        sys.exit(1)
+
+
+def _fail(msg: str) -> None:
+    print(f"[FAIL]  {msg}", file=sys.stderr)
+
+
+def _ok(msg: str) -> None:
+    print(f"[OK]    {msg}")
+
+
+def _parse_handler_declarations(text: str) -> list[str]:
+    return re.findall(r'^void\s+(\w+_Handler)\s*\(void\)\s*;', text, re.MULTILINE)
+
+
+def _parse_extern_handlers(text: str) -> set[str]:
+    return set(re.findall(r'^\s+\.extern\s+(\w+_Handler)', text, re.MULTILINE))
+
+
+def check_vector_stubs(
+    interrupts_c_text: str,
+    interrupts_as_text: str,
+    known_missing: dict[str, str] | None = None,
+) -> int:
+    """Bug 1 check: every handler in interrupts.c must have a stub in interrupts_a.S."""
+    if known_missing is None:
+        known_missing = {}
+
+    declared  = _parse_handler_declarations(interrupts_c_text)
+    externed  = _parse_extern_handlers(interrupts_as_text)
+
+    print(f"[INFO] interrupts.c: {len(declared)} handler declaration(s)")
+    print(f"[INFO] interrupts_a.S: {len(externed)} .extern handler reference(s)\n")
+
+    failures = 0
+    for handler in sorted(declared):
+        if handler in known_missing:
+            print(f"[SKIP]  {handler}: no stub (accepted — {known_missing[handler]})")
+            continue
+        if handler not in externed:
+            _fail(
+                f"{handler} is declared in interrupts.c "
+                f"but has NO dispatch stub in interrupts_a.S — "
+                f"this interrupt will NEVER fire."
+            )
+            failures += 1
+        else:
+            _ok(f"{handler}: stub present in interrupts_a.S")
+    return failures
+
+
+def _parse_pmd_from_core_yml(text: str) -> dict[int, int]:
+    pmd_expected: dict[int, int] = {}
+    current_reg: int | None = None
+    for line in text.splitlines():
+        m = re.match(r'\s+PMD(\d+)_REG_VALUE:', line)
+        if m:
+            current_reg = int(m.group(1))
+            continue
+        if current_reg is not None:
+            mv = re.search(r"value:\s+'(\d+)'", line)
+            if mv:
+                pmd_expected[current_reg] = int(mv.group(1))
+                current_reg = None
+                continue
+            if re.match(r'\s{4}\w', line) and not re.match(r'\s{6,}', line):
+                current_reg = None
+    return pmd_expected
+
+
+def _parse_pmd_from_plib_clk(text: str) -> dict[int, int]:
+    pmd_actual: dict[int, int] = {}
+    for m in re.finditer(r'\bPMD(\d+)\s*=\s*(0x[0-9a-fA-F]+)[Uu]?\s*;', text):
+        pmd_actual[int(m.group(1))] = int(m.group(2), 16)
+    return pmd_actual
+
+
+def check_pmd_registers(core_yml_text: str, plib_clk_text: str) -> int:
+    """Bug 3 check: PMD register values in core.yml must match plib_clk.c."""
+    pmd_expected = _parse_pmd_from_core_yml(core_yml_text)
+    pmd_actual   = _parse_pmd_from_plib_clk(plib_clk_text)
+
+    print(f"[INFO] core.yml: {len(pmd_expected)} PMD register(s) declared")
+    print(f"[INFO] plib_clk.c: {len(pmd_actual)} PMD register(s) found\n")
+
+    failures = 0
+    for reg in sorted(pmd_expected.keys()):
+        expected = pmd_expected[reg]
+        if reg not in pmd_actual:
+            _fail(
+                f"PMD{reg} is declared in core.yml "
+                f"but not found in plib_clk.c — cannot verify clock gate."
+            )
+            failures += 1
+            continue
+        actual = pmd_actual[reg]
+        if actual != expected:
+            diff = actual ^ expected
+            _fail(
+                f"PMD{reg} mismatch — "
+                f"plib_clk.c=0x{actual:08X}  core.yml=0x{expected:08X}  "
+                f"diff_bits=0x{diff:08X}  "
+                f"(MCC regeneration likely reverted a manual clock-enable fix)"
+            )
+            failures += 1
+        else:
+            _ok(f"PMD{reg}: 0x{actual:08X} matches core.yml")
+    return failures
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Validate MCC-generated peripheral config files (Bug 1 + Bug 3)."
+    )
+    parser.add_argument(
+        "--root", type=Path, default=None,
+        help="Project root (default: $VOLTU_PROJECT_ROOT or cwd)",
+    )
+    parser.add_argument(
+        "--project-name", default=None,
+        help="Project name (default: $VOLTU_PROJECT_NAME or folder name)",
+    )
+    parser.add_argument(
+        "--stubs-file", type=Path, default=None,
+        help="JSON file with known-missing stubs: {HandlerName: reason}",
+    )
+    args = parser.parse_args()
+
+    root = args.root or _env_project_root()
+    name = args.project_name or _env_project_name()
+
+    interrupts_c  = root / "firmware/src/config/default/interrupts.c"
+    interrupts_as = root / "firmware/src/config/default/interrupts_a.S"
+    core_yml      = root / f"firmware/{name}.X/{name}_default/components/core.yml"
+    plib_clk_c    = root / "firmware/src/config/default/peripheral/clk/plib_clk.c"
+
+    known_missing: dict[str, str] = {}
+    if args.stubs_file and args.stubs_file.exists():
+        known_missing = json.loads(args.stubs_file.read_text(encoding="utf-8"))
+    else:
+        default_stubs = root / "pymake" / "check_peripheral_stubs.json"
+        if default_stubs.exists():
+            known_missing = json.loads(default_stubs.read_text(encoding="utf-8"))
+
+    print("--- Peripheral Configuration Check ---\n")
+
+    interrupts_c_text  = _read(interrupts_c)
+    interrupts_as_text = _read(interrupts_as)
+    core_yml_text      = _read(core_yml)
+    plib_clk_text      = _read(plib_clk_c)
+
+    print("== Bug 1: Vector stubs (interrupts.c vs interrupts_a.S) ==")
+    failures  = check_vector_stubs(interrupts_c_text, interrupts_as_text, known_missing)
+
+    print("\n== Bug 3: PMD clock gates (core.yml vs plib_clk.c) ==")
+    failures += check_pmd_registers(core_yml_text, plib_clk_text)
+
+    print()
+    if failures:
+        print(
+            f"[RESULT] FAILED — {failures} check(s) failed. "
+            f"Fix the generated files or re-run MCC.",
+            file=sys.stderr,
+        )
+        return 1
+
+    print("[RESULT] PASSED — all peripheral configuration checks OK.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())