gd32-probe 1.0.0__tar.gz

gd32_probe-1.0.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: gd32-probe
+Version: 1.0.0
+Summary: GD32F303 专业调试终端 PRO — 人机+AI 共用，对标 Keil 仿真
+Author-email: chenyuewei <228558959@qq.com>
+License: MIT
+Keywords: gd32,cortex-m,debugger,dap-link,embedded,tui
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Embedded Systems
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=0.40.0
+Requires-Dist: pyocd>=0.36.0
+Requires-Dist: pyelftools>=0.30
+
+# gd32-probe — GD32F303 调试终端 PRO
+
+人机 + AI 智能体共用调试控制台，对标 Keil 仿真功能。
+
+## 功能
+
+- 📋 **RTT 日志** — 高速双向日志，不占用串口
+- 📊 **外设寄存器** — 7 类外设 + SCB，位域解码，变更高亮
+- 💾 **内存浏览器** — Hex/ASCII 双栏，地址跳转
+- 👁 **变量监视** — ELF 符号自动解析，实时刷新
+- 🧠 **CPU 核心** — 暂停/运行/单步/复位，HardFault 栈解析
+- ● **硬件断点/观察点** — 读写监控
+- 📡 **SWO 高速日志** — 串行线输出
+- 🔥 **烧录** — ELF/HEX/BIN 一键烧录
+- 🤖 **AI 指令接口** — JSON 文件驱动，Agent 可自动调用
+
+## 安装
+
+```bash
+pip install gd32-probe
+```
+
+## 启动
+
+```bash
+gd32-debug
+```
+
+## 依赖
+
+- Python >= 3.10
+- DAPLink / CMSIS-DAP 调试器
+- GD32F303 目标板
+
+## 命令速查
+
+| 命令 | 说明 |
+|------|------|
+| `reg can0` | CAN0 寄存器 + 位域 |
+| `peek 0x20004000 16` | 读内存 |
+| `var g_freq_hz` | 读 ELF 变量 |
+| `bp add 0x0800A145` | 硬件断点 |
+| `flash` | 烧录 ELF |
+| `Ctrl+R` | 复位 MCU |
+| `F5` | 运行 |
+| `F10` | 单步 |
+
+## License
+
+MIT

gd32_probe-1.0.0/README.md

@@ -0,0 +1,50 @@
+# gd32-probe — GD32F303 调试终端 PRO
+
+人机 + AI 智能体共用调试控制台，对标 Keil 仿真功能。
+
+## 功能
+
+- 📋 **RTT 日志** — 高速双向日志，不占用串口
+- 📊 **外设寄存器** — 7 类外设 + SCB，位域解码，变更高亮
+- 💾 **内存浏览器** — Hex/ASCII 双栏，地址跳转
+- 👁 **变量监视** — ELF 符号自动解析，实时刷新
+- 🧠 **CPU 核心** — 暂停/运行/单步/复位，HardFault 栈解析
+- ● **硬件断点/观察点** — 读写监控
+- 📡 **SWO 高速日志** — 串行线输出
+- 🔥 **烧录** — ELF/HEX/BIN 一键烧录
+- 🤖 **AI 指令接口** — JSON 文件驱动，Agent 可自动调用
+
+## 安装
+
+```bash
+pip install gd32-probe
+```
+
+## 启动
+
+```bash
+gd32-debug
+```
+
+## 依赖
+
+- Python >= 3.10
+- DAPLink / CMSIS-DAP 调试器
+- GD32F303 目标板
+
+## 命令速查
+
+| 命令 | 说明 |
+|------|------|
+| `reg can0` | CAN0 寄存器 + 位域 |
+| `peek 0x20004000 16` | 读内存 |
+| `var g_freq_hz` | 读 ELF 变量 |
+| `bp add 0x0800A145` | 硬件断点 |
+| `flash` | 烧录 ELF |
+| `Ctrl+R` | 复位 MCU |
+| `F5` | 运行 |
+| `F10` | 单步 |
+
+## License
+
+MIT

gd32_probe-1.0.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=75", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gd32-probe"
+version = "1.0.0"
+description = "GD32F303 专业调试终端 PRO — 人机+AI 共用，对标 Keil 仿真"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "chenyuewei", email = "228558959@qq.com"}]
+keywords = ["gd32", "cortex-m", "debugger", "dap-link", "embedded", "tui"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: Software Development :: Embedded Systems",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "textual>=0.40.0",
+    "pyocd>=0.36.0",
+    "pyelftools>=0.30",
+]
+
+[project.scripts]
+gd32-debug = "gd32_probe.app:main"
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]

gd32_probe-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gd32_probe-1.0.0/src/gd32_probe/__main__.py

@@ -0,0 +1,9 @@
+"""gd32_probe 入口 — 可直接 python -m gd32_probe"""
+
+from .app import GD32Debugger
+
+def main():
+    GD32Debugger().run()
+
+if __name__ == "__main__":
+    main()

gd32_probe-1.0.0/src/gd32_probe/app.py

@@ -0,0 +1,356 @@
+"""gd32_probe.app — GD32F303 调试终端 PRO 主应用"""
+
+import asyncio
+from pathlib import Path
+
+from textual import work, on
+from textual.app import App, ComposeResult
+from textual.containers import Horizontal, Vertical, Container
+from textual.widgets import Header, Footer, Static, Input, Label, Button
+from textual.reactive import reactive
+from textual.binding import Binding
+
+from .core import dap_client, elf_parser, rtt_buf, ai_iface, swo_manager
+from .views.rtt_log import RTTLogTab
+from .views.register import RegTab
+from .views.memory import MemTab
+from .views.watch import WatchTab
+from .views.cpu import CpuTab
+from .views.swo import SwoTab
+from .views.flash_view import FlashTab
+from .views.breakpoint import BpTab
+from .views import classify
+
+ELF_PATH = Path("F:/workspace/ultrasonic_psfb_re/build_gcc_app/ultrasonic_psfb_re.elf")
+POLL_MS  = 150
+
+TABS = [
+    ("📋 RTT",    RTTLogTab),
+    ("📊 寄存器", RegTab),
+    ("💾 内存",   MemTab),
+    ("👁 监视",   WatchTab),
+    ("🧠 CPU",    CpuTab),
+    ("● 断点",   BpTab),
+    ("📡 SWO",    SwoTab),
+    ("🔥 烧录",   FlashTab),
+]
+
+class StatusBar(Static):
+    status = reactive("● 断开")
+    def render(self):
+        c = "green" if "连接" in self.status else "red"
+        return f"[{c}]{self.status}[/]"
+
+class GD32Debugger(App):
+    CSS = """
+    #top-bar         { height: 1; padding: 0 1; background: $surface; }
+    #tab-bar         { height: 1; background: $surface-darken-2; }
+    #tab-bar Button  { min-width: 8; margin: 0; }
+    #tab-bar Button.active { background: $accent; color: $text; }
+    #content-area    { height: 1fr; }
+    #rtt-log, #swo-log, #bp-view, #flash-log { height: 1fr; background: $surface-darken-1; }
+    #reg-tree        { width: 30; height: 1fr; border: solid $secondary; }
+    #reg-detail      { height: 1fr; border: solid $secondary; background: $surface-darken-1; }
+    #mem-view        { height: 1fr; background: $surface-darken-1; }
+    #watch-view      { height: 1fr; background: $surface-darken-1; }
+    #cpu-view        { height: 1fr; background: $surface-darken-1; }
+    #mem-bar, #cpu-bar, #swo-bar, #flash-bar, #bp-bar, #rtt-ctrl { height: 3; }
+    #mem-addr, #bp-addr, #flash-path { width: 40; }
+    #cmd-panel       { height: 3; border: solid $accent; background: $surface; }
+    #cmd-input       { margin: 0 1; }
+    #cmd-label       { margin: 0 1; color: $text-muted; }
+    #flash-progress  { height: 1; color: $text-muted; }
+    StatusBar        { width: 42; }
+    .hidden          { display: none; }
+    """
+
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "退出"),
+        Binding("ctrl+r", "reset_mcu", "复位MCU"),
+        Binding("f5",     "resume_mcu", "运行"),
+        Binding("f10",    "step_mcu", "单步"),
+        Binding("ctrl+1", "tab(0)", "RTT"),
+        Binding("ctrl+2", "tab(1)", "寄存器"),
+        Binding("ctrl+3", "tab(2)", "内存"),
+        Binding("ctrl+4", "tab(3)", "监视"),
+        Binding("ctrl+5", "tab(4)", "CPU"),
+        Binding("ctrl+6", "tab(5)", "断点"),
+        Binding("ctrl+7", "tab(6)", "SWO"),
+        Binding("ctrl+8", "tab(7)", "烧录"),
+    ]
+
+    _tick = 0; _log_wr = 0; _log_rd = 0; _log_first = True; _log_fail = 0
+    _active_tab = 0
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        yield Horizontal(
+            Static(f" 🖥  GD32F303 调试终端 PRO  |  {ELF_PATH.name if ELF_PATH.exists() else '无ELF'}"),
+            StatusBar(id="status"), id="top-bar")
+
+        with Horizontal(id="tab-bar"):
+            for label, _ in TABS:
+                yield Button(label, classes="active" if label == TABS[0][0] else "")
+
+        yield Container(id="content-area")
+
+        yield Vertical(
+            Label("> reg|peek|var|bp|wp|flash|hardfault|send|help  Ctrl+R:复位 F5:运行 F10:单步", id="cmd-label"),
+            Input(id="cmd-input", placeholder="reg can0 / peek 0x20004000 / bp add 0x0800xxxx / flash ..."),
+            id="cmd-panel")
+        yield Footer()
+
+    def on_mount(self):
+        self.content = self.query_one("#content-area", Container)
+        self.inp = self.query_one("#cmd-input", Input)
+        self.st  = self.query_one(StatusBar)
+        self.tab_btns = list(self.query("#tab-bar Button"))
+
+        # 创建所有标签页
+        self.tab_widgets = []
+        for i, (label, cls) in enumerate(TABS):
+            w = cls()
+            w.id = f"tab-{i}"
+            self.content.mount(w)
+            self.tab_widgets.append(w)
+            if i != 0:
+                w.add_class("hidden")
+
+        self.rtt_tab = self.tab_widgets[0]
+        self.poll_loop()
+
+    def switch_tab(self, idx: int):
+        if idx < 0 or idx >= len(self.tab_widgets):
+            return
+        for i, w in enumerate(self.tab_widgets):
+            if i == idx:
+                w.remove_class("hidden")
+            else:
+                w.add_class("hidden")
+        for i, btn in enumerate(self.tab_btns):
+            if i == idx:
+                btn.add_class("active")
+            else:
+                btn.remove_class("active")
+        self._active_tab = idx
+
+    def action_tab(self, idx_str: str):
+        self.switch_tab(int(idx_str))
+
+    @on(Button.Pressed, "#tab-bar Button")
+    def on_tab_button(self, event: Button.Pressed):
+        for i, btn in enumerate(self.tab_btns):
+            if btn is event.button:
+                self.switch_tab(i)
+                return
+
+    @on(Button.Pressed, "#rtt-reset")
+    def on_rtt_reset(self):
+        dap_client.reset("software")
+        self._log_first = True
+        self.rtt_tab.write_line("[yellow]🔄 MCU 已复位[/]")
+
+    @on(Button.Pressed, "#rtt-clear")
+    def on_rtt_clear(self):
+        self.rtt_tab.rlog.clear()
+
+    def on_input_submitted(self, event: Input.Submitted):
+        cmd = event.value.strip()
+        if not cmd:
+            return
+        self.inp.value = ""
+        parts = cmd.split(maxsplit=1)
+        op = parts[0].lower()
+        arg = parts[1] if len(parts) > 1 else ""
+
+        if op == "reg":
+            self._cmd_reg(arg)
+        elif op == "peek":
+            self._cmd_peek(arg)
+        elif op == "var":
+            self._cmd_var(arg)
+        elif op == "bp":
+            self._cmd_bp(arg)
+        elif op == "wp":
+            self._cmd_wp(arg)
+        elif op == "flash":
+            path = Path(arg) if arg else ELF_PATH
+            self._cmd_flash(path)
+        elif op == "hardfault":
+            from .core import hardfault
+            r = hardfault.analyze()
+            if r:
+                self.rtt_tab.write_line(hardfault.format_report(r))
+            else:
+                self.rtt_tab.write_line("[dim]无 HardFault[/]")
+        elif op == "send":
+            ok, err = rtt_buf.write_cmd(arg)
+            self.rtt_tab.write_line(f"[bold magenta]> {arg}[/]" if ok else f"[red]发送失败: {err}[/]")
+        elif op == "help":
+            self.rtt_tab.write_line(
+                "[bold]命令:[/]\n"
+                "  reg <外设> | peek <addr> | var <name> | bp add/del <addr>\n"
+                "  wp add/del <addr> | flash [path] | hardfault | send <text>\n"
+                "  Ctrl+R:复位  F5:运行  F10:单步  Ctrl+1~8:切标签")
+        else:
+            ok, err = rtt_buf.write_cmd(cmd)
+            if ok:
+                self.rtt_tab.write_line(f"[bold magenta]> {cmd}[/]")
+            else:
+                self.rtt_tab.write_line(f"[red]发送失败: {err}[/]")
+
+    def _cmd_reg(self, arg):
+        from .core.periph_defs import PERIPHERALS
+        peri_name = arg.upper()
+        if peri_name == "SCB":
+            self.switch_tab(1)
+            self.tab_widgets[1].show_scb()
+            return
+        for p in PERIPHERALS:
+            if p.name == peri_name:
+                self.switch_tab(1)
+                self.tab_widgets[1].show_periph(p)
+                return
+        self.rtt_tab.write_line(f"[red]未知外设: {peri_name}[/]")
+
+    def _cmd_peek(self, arg):
+        try:
+            p2 = arg.split()
+            addr = int(p2[0], 16)
+            length = int(p2[1]) if len(p2) > 1 else 4
+        except (ValueError, IndexError):
+            self.rtt_tab.write_line("[red]用法: peek 0x40006400 [len][/]")
+            return
+        raw = dap_client.read_mem(addr, length)
+        if raw is None:
+            self.rtt_tab.write_line(f"[red]读取 0x{addr:08X} 失败[/]")
+        else:
+            self.rtt_tab.write_line(f"0x{addr:08X} ({length}B): {raw.hex(' ')}")
+            if length <= 4:
+                val = int.from_bytes(raw, 'little')
+                self.rtt_tab.write_line(f"  = [bold]{val}[/] (0x{val:X})")
+
+    def _cmd_var(self, arg):
+        name = arg.strip()
+        sym = elf_parser.elf_symbols.get(name)
+        if not sym:
+            self.rtt_tab.write_line(f"[red]未找到: {name}[/]")
+            return
+        v = dap_client.read_u32(sym.addr)
+        self.rtt_tab.write_line(f"[cyan]{name}[/] @ 0x{sym.addr:08X} = 0x{v:08X} ({v})" if v is not None else "?")
+
+    def _cmd_bp(self, arg):
+        parts = arg.split()
+        if len(parts) < 2:
+            self.rtt_tab.write_line("[red]用法: bp add|del <addr>[/]")
+            return
+        action, addr_str = parts[0], parts[1]
+        try: addr = int(addr_str, 16)
+        except ValueError: self.rtt_tab.write_line("[red]地址格式错误[/]"); return
+        if action == "add": dap_client.add_breakpoint(addr)
+        elif action == "del": dap_client.remove_breakpoint(addr)
+
+    def _cmd_wp(self, arg):
+        parts = arg.split()
+        if len(parts) < 2:
+            self.rtt_tab.write_line("[red]用法: wp add|del <addr> [size] [r|w|rw][/]")
+            return
+        action, addr_str = parts[0], parts[1]
+        size = int(parts[2]) if len(parts) > 2 else 4
+        rw = parts[3] if len(parts) > 3 else "w"
+        try: addr = int(addr_str, 16)
+        except ValueError: self.rtt_tab.write_line("[red]地址错误[/]"); return
+        if action == "add": dap_client.add_watchpoint(addr, size, rw)
+        elif action == "del": dap_client.remove_watchpoint(addr)
+
+    def _cmd_flash(self, path: Path):
+        if not path.exists():
+            self.rtt_tab.write_line(f"[red]文件不存在: {path}[/]")
+            return
+        self.switch_tab(7)
+        ftab = self.tab_widgets[7]
+        ftab.fpath.value = str(path)
+        from .core import flash
+        def prog(pct, msg):
+            ftab.fprog.update(f"进度: {pct}% — {msg}")
+        ok, written = flash.program_file(path, progress_cb=prog)
+        if ok:
+            self.rtt_tab.write_line(f"[green]✓ 烧录完成 {written}B[/]")
+            ftab.fprog.update("进度: 完成 ✓")
+            dap_client.reset("software")
+            self._log_first = True
+        else:
+            self.rtt_tab.write_line("[red]✗ 烧录失败[/]")
+
+    @work(exclusive=True)
+    async def poll_loop(self):
+        while True:
+            self._tick += 1
+
+            wr, rd, data = rtt_buf.read_log()
+            if wr == 0 or not data:
+                self._log_fail += 1
+                if self._log_fail == 1:
+                    self.st.status = "● 断开"
+            else:
+                if self._log_fail > 0:
+                    dap_client.log("[green]✓ 已恢复连接[/]")
+                self._log_fail = 0
+                self.st.status = f"● 已连接 (wr={wr} rd={rd})"
+
+                if self._log_first:
+                    self._log_first = False
+                    self._log_rd = rd
+
+                if wr == self._log_rd:
+                    new = b""
+                elif wr > self._log_rd:
+                    new = data[self._log_rd:wr]
+                else:
+                    new = data[self._log_rd:] + data[:wr]
+
+                if new:
+                    text = bytes(new).decode("utf-8", errors="replace")
+                    for line in text.split("\n"):
+                        line = line.strip("\r")
+                        if line:
+                            self.rtt_tab.write_log(line)
+                    if wr != self._log_rd:
+                        rtt_buf.write_log_rd(wr)
+                self._log_rd = wr
+
+            if self._tick % 3 == 0 and self._log_fail == 0:
+                if self._active_tab == 3:  # Watch
+                    self.tab_widgets[3].refresh_data()
+                if self._active_tab == 4:  # CPU
+                    self.tab_widgets[4].refresh_data()
+
+            if self._tick % 3 == 0:
+                result = ai_iface.check()
+                if result:
+                    dap_client.log(f"[dim]AI: {result.get('id','?')} ✓[/]")
+
+            await asyncio.sleep(POLL_MS / 1000.0)
+
+    def action_reset_mcu(self):
+        dap_client.reset("software")
+        self._log_first = True
+
+    def action_resume_mcu(self):
+        dap_client.resume()
+
+    def action_step_mcu(self):
+        dap_client.step()
+        if self._active_tab == 4:
+            self.tab_widgets[4].refresh_data()
+
+    def on_unmount(self):
+        swo_manager.stop()
+        dap_client.disconnect()
+
+
+def main():
+    GD32Debugger().run()
+
+if __name__ == "__main__":
+    main()

gd32_probe-1.0.0/src/gd32_probe/core/ai_iface.py

@@ -0,0 +1,129 @@
+"""gd32_probe.core.ai_iface — AI 智能体指令接口"""
+
+import json, os
+from pathlib import Path
+from typing import Optional
+from . import dap_client, periph_defs
+
+CMD_FILE = Path("F:/workspace/_temp/ramlog_ai_cmd.json")
+RES_FILE = Path("F:/workspace/_temp/ramlog_ai_res.json")
+
+def process(cmd: dict) -> dict:
+    c = cmd.get("cmd", "")
+    rid = cmd.get("id", "?")
+    try:
+        if c == "reg":
+            peri_name = cmd.get("periph", "").upper()
+            peri = next((p for p in periph_defs.PERIPHERALS if p.name == peri_name), None)
+            if not peri:
+                return {"id": rid, "error": f"未知外设: {peri_name}",
+                        "available": [p.name for p in periph_defs.PERIPHERALS]}
+            vals = {}
+            for r in peri.registers:
+                v = dap_client.read_u32(peri.base + r.offset)
+                if v is not None:
+                    vals[r.name] = v
+            return {"id": rid, "cmd": "reg", "periph": peri_name, "regs": vals}
+
+        elif c == "peek":
+            addr = int(cmd["addr"], 16) if isinstance(cmd["addr"], str) else cmd["addr"]
+            length = cmd.get("len", 4)
+            raw = dap_client.read_mem(addr, length)
+            if raw is None:
+                return {"id": rid, "error": "读取失败"}
+            return {"id": rid, "addr": f"0x{addr:08X}", "hex": raw.hex(),
+                    "value": f"0x{int.from_bytes(raw,'little'):0{length*2}X}" if length <= 4 else None}
+
+        elif c == "poke":
+            addr = int(cmd["addr"], 16) if isinstance(cmd["addr"], str) else cmd["addr"]
+            val = int(cmd["value"], 16) if isinstance(cmd["value"], str) else cmd["value"]
+            size = cmd.get("size", 4)
+            data = val.to_bytes(size, 'little')
+            ok = dap_client.write_mem(addr, data)
+            return {"id": rid, "ok": ok}
+
+        elif c == "halt":
+            dap_client.halt()
+            return {"id": rid, "halted": True}
+
+        elif c == "resume":
+            dap_client.resume()
+            return {"id": rid, "resumed": True}
+
+        elif c == "reset":
+            mode = cmd.get("mode", "hardware")
+            dap_client.reset(mode)
+            return {"id": rid, "reset": mode}
+
+        elif c == "bp":
+            sub = cmd.get("action", "add")
+            addr = int(cmd["addr"], 16) if isinstance(cmd["addr"], str) else cmd["addr"]
+            if sub == "add":
+                ok = dap_client.add_breakpoint(addr)
+                return {"id": rid, "bp_added": ok, "addr": f"0x{addr:08X}"}
+            elif sub == "remove":
+                ok = dap_client.remove_breakpoint(addr)
+                return {"id": rid, "bp_removed": ok}
+
+        elif c == "wp":
+            sub = cmd.get("action", "add")
+            addr = int(cmd["addr"], 16) if isinstance(cmd["addr"], str) else cmd["addr"]
+            size = cmd.get("size", 4)
+            rw = cmd.get("mode", "w")
+            if sub == "add":
+                ok = dap_client.add_watchpoint(addr, size, rw)
+                return {"id": rid, "wp_added": ok}
+            elif sub == "remove":
+                ok = dap_client.remove_watchpoint(addr)
+                return {"id": rid, "wp_removed": ok}
+
+        elif c == "flash":
+            path_str = cmd.get("file", "")
+            path = Path(path_str)
+            if not path.exists():
+                return {"id": rid, "error": f"文件不存在: {path_str}"}
+            from . import flash
+            ok, written = flash.program_file(path)
+            return {"id": rid, "flashed": ok, "bytes": written}
+
+        elif c == "hardfault":
+            from . import hardfault
+            r = hardfault.analyze()
+            return {"id": rid, "hardfault": r}
+
+        elif c == "var":
+            name = cmd.get("name", "")
+            from . import elf_parser
+            addr = elf_parser.get_var_addr(name)
+            if not addr:
+                return {"id": rid, "error": f"变量未找到: {name}"}
+            v = dap_client.read_u32(addr)
+            return {"id": rid, "var": name, "addr": f"0x{addr:08X}",
+                    "value": f"0x{v:08X}" if v is not None else "?"}
+
+        elif c == "send":
+            text = cmd.get("text", "")
+            from . import rtt_buf
+            ok, err = rtt_buf.write_cmd(text)
+            return {"id": rid, "ok": ok, "error": err if not ok else None}
+
+        return {"id": rid, "error": f"未知指令: {c}",
+                "available": ["reg","peek","poke","halt","resume","reset",
+                              "bp","wp","flash","hardfault","var","send"]}
+    except Exception as e:
+        return {"id": rid, "error": str(e)}
+
+def check() -> Optional[dict]:
+    if not CMD_FILE.exists():
+        return None
+    try:
+        raw = CMD_FILE.read_text("utf-8").strip()
+        if not raw:
+            return None
+        obj = json.loads(raw)
+        CMD_FILE.unlink()
+        result = process(obj)
+        RES_FILE.write_text(json.dumps(result, ensure_ascii=False, indent=2), "utf-8")
+        return result
+    except Exception:
+        return None