collector: 更新采集工程至 v1.3.8（DECXIN 相机归属与命名两处修复。v1.3.7：单插的 DECXIN 在夹爪 rig 插着时从设备面板消失，两层独立根因——v1.3.0 的 VID/PID 一刀切改为按 USB 根端口判归属，且 list_v4l_devices 改按物理 USB 设备分组，救回被 by-id 链接名顶掉的那颗孤儿。v1.3.8：同型号两颗 DECXIN 的 by-id 链接归属会在重枚举时翻转导致面板设备消失又出现并丢名字，判定前缀被共用后两颗都退拓扑路径，判据刻意不是「数前缀重复」而是「没链接那台的(厂商,型号)与有链接那台相同」。两版各配套回归测试，真机验证通过）

collector/README.md

@@ -1,6 +1,6 @@
 # collector — Multimodal Data Acquisition SDK · 多模态数据采集 SDK
 
-![Version](https://img.shields.io/badge/version-1.3.6-blue)
+![Version](https://img.shields.io/badge/version-1.3.8-blue)
 ![Python](https://img.shields.io/badge/python-3.12-blue)
 ![License](https://img.shields.io/badge/license-TBD-lightgrey)
 
@@ -375,6 +375,63 @@ are documented in [docs/index.md](docs/index.md#开发约定).
 
 ### Changelog
 
+- **v1.3.8** — fixes a leftover from v1.3.7: the two DECXINs' by-id link
+  **ownership flips on re-enumeration**. Both report serial `01.00.00`, so both
+  want the same link name, only one gets it — and *which* one depends on
+  registration order. v1.3.7 pushed only the **link-less** camera down to the
+  topology path and left the link holder on by-id, so when the link flipped
+  both cameras changed key at once and the bug survived. Caught live in
+  `logs/main.log`: `Connected: DECXIN_head` immediately followed by
+  `Disconnected: DECXIN DECXIN CAMERA` — the panel drops the device along with
+  the name the user gave it. `list_v4l_devices()` now reports
+  `by_id_ambiguous`, and **both** cameras fall back to the topology path, so
+  each keeps a single key whoever wins the link.
+  The detection deliberately is *not* "count duplicate prefixes": at any
+  instant only one camera holds a link, so the other never enters the count and
+  that check would never fire. The rule is instead "a link-less physical device
+  whose (vendor, model) matches a **linked** one" — two cameras of the same
+  model with **different** serials each keep their own link and are not
+  downgraded. `by_id_path` is untouched (still a real path or `None`;
+  `ui/lite_window.py` opens the device with it). One-time cost: the standalone
+  DECXIN keys as `uvc:usb-1-5`, so the `DECXIN_head` entry saved under the old
+  by-id-shaped key no longer matches — rename it once.
+- **v1.3.7** — a standalone DECXIN camera no longer disappears from the device
+  panel while the gripper rig is plugged in.
+  **Two independent root causes — fixing only the first looks like it works
+  until the rig is plugged in again:**
+  (1) v1.3.0 added `1bcf:2d4f` to the gripper-component blacklist wholesale, so
+  the camera could never enter the generic UVC list — while the "gripper" group
+  that should have claimed it requires the ESP32 control board to be present.
+  Rejected by both, it vanished. `data/device_names.json` still carries
+  `uvc:usb-DECXIN_DECXIN_CAMERA_01.00.00` = `"DECXIN_head"`, proof that plugged
+  in alone it was a plain UVC camera. Ownership is now decided by **USB root
+  hub**: the board sits at `1-2.2.1` and the rig's DECXIN at `1-2.2.2` (both
+  root hub `1-2`), while a standalone DECXIN sits at `1-5` — only a DECXIN on
+  the board's root hub counts as part of the rig. `gripper_root_hubs()` derives
+  that set from the board's tty path, and a camera whose own root hub cannot be
+  read is conservatively excluded (better hidden than opened twice against the
+  rig). Sightac and the FT602 are *not* released: the former has no standalone
+  use, the latter is already covered by `is_sdk`.
+  (2) more fundamentally, **udev's by-id link names collide**. The two DECXINs
+  report identical vendor / model / serial strings (`DECXIN` / `DECXIN CAMERA` /
+  `01.00.00`), so their by-id link names are identical too — and a link name is
+  unique, so whichever registers last wins and the other becomes an orphan with
+  no link at all. `core.camera.list_v4l_devices()` used **by-id as its
+  enumeration entry point**, so the orphan never even reached the filter. It now
+  groups by **physical USB device** (`_v4l_nodes_by_physical_device`, keyed on
+  the topology path such as `1-5`, falling back to the sysfs realpath for
+  non-USB nodes) and keeps the lowest stream index per device; with no link the
+  display name falls back to the USB vendor/product strings, which decode to the
+  same name the by-id path produced. `by_id_path` stays "a real path, or None" —
+  `ui/lite_window.py` uses it as the path to *open* the device, so it must never
+  be fabricated. Device keys now degrade from the by-id prefix to
+  `usb-<topology path>` (also stable across reboots) before falling back to the
+  drifting video index. Known side effect: with both cameras plugged in the
+  standalone one keys as `uvc:usb-1-5` and does **not** inherit the saved
+  `DECXIN_head` name (that key is by-id-shaped and now belongs to the filtered
+  rig camera); name it once in each configuration if it must stay stable. The
+  Lite edition now scans the gripper first so it has the root hubs before
+  filtering UVC.
 - **v1.3.6** — the Lite edition records the UMI gripper, and every SLAM point now
   carries the host timestamp of the frame it came from.
   **Lite + gripper:** the Lite edition did not record the gripper at all; that
@@ -1029,6 +1086,43 @@ i18n 文案经 `tr()` 翻译、PyQt5 信号参数用 `object` 封送大整数、
 
 ### 更新记录
 
+- **v1.3.8** — 修 v1.3.7 的遗留：两颗 DECXIN 的 by-id 链接**归属会在重新枚举时
+  翻转**。两颗序列号都是 `01.00.00`，都要同一个链接名，而只有一颗拿得到——**谁
+  拿到取决于注册顺序**。v1.3.7 只把**没链接**那颗压到拓扑路径、拿到链接那颗仍用
+  by-id，于是链接一翻转两颗一起换 key，问题照旧。真机 `logs/main.log` 抓到：
+  `Connected: DECXIN_head` 紧跟 `Disconnected: DECXIN DECXIN CAMERA`——面板上
+  设备连同用户起的名字一起消失。现由 `list_v4l_devices()` 报 `by_id_ambiguous`，
+  **两颗都退拓扑路径**，谁拿到链接都各守一个 key。
+  判据**刻意不是「数前缀重复」**：任一时刻只有一颗真拿到链接，另一颗压根进不了
+  计数，那么数永远数不出来。改为「一台没链接的物理设备，其 (厂商, 型号) 与另一台
+  **有链接**的相同」——同型号但**序列号不同**的两台各有各的链接，不会被误判降级。
+  `by_id_path` 不动（仍是「真路径或 None」，`ui/lite_window.py` 拿它开设备）。
+  一次性代价：单插那颗 DECXIN 的 key 变成 `uvc:usb-1-5`，挂在旧 by-id 形式 key
+  下的 `DECXIN_head` 不再匹配——重命名一次即可。
+- **v1.3.7** — 单插的 DECXIN 相机在夹爪 rig 插着时不再从设备面板消失。
+  **两层独立根因，只修第一层会看起来「好了」、rig 一插就复发**：
+  ①v1.3.0 把 `1bcf:2d4f` 整颗加进夹爪组件黑名单，它永远进不了通用 UVC
+  列表；而本该收它的「夹爪」分组又要求 ESP32 控制板在场——两边都不收就消失了。
+  `data/device_names.json` 里躺着 `uvc:usb-DECXIN_DECXIN_CAMERA_01.00.00`
+  = `"DECXIN_head"`，证明它单插时本来就是普通 UVC 相机。改按 **USB 根端口**
+  判归属：控制板在 `1-2.2.1`、rig 那颗 DECXIN 在 `1-2.2.2`（同属根端口 `1-2`），
+  单插那颗在 `1-5`——只有挂在控制板根端口下的 DECXIN 才算 rig 的。`gripper_root_hubs()`
+  从控制板的 tty 路径取该集合；相机自身根端口取不到时**保守排除**（宁可藏，
+  不可与 rig 双开）。Sightac 与 FT602 不放开：前者单插无用，后者另有 `is_sdk`
+  兜底。
+  ②更底层：**udev 的 by-id 链接名会撞**。两颗 DECXIN 的厂商/型号/序列号字符串
+  完全相同（`DECXIN` / `DECXIN CAMERA` / `01.00.00`），by-id 链接名也就完全相同
+  ——而链接名唯一，**只有后注册那颗有链接，另一颗成孤儿**。
+  `core.camera.list_v4l_devices()` 原本**以 by-id 为枚举入口**，孤儿压根进不了
+  枚举，轮不到过滤器。改按**物理 USB 设备**分组（`_v4l_nodes_by_physical_device`，
+  键取拓扑路径如 `1-5`，非 USB 节点退回 sysfs realpath），每个物理设备只留最小
+  流索引；无链接时显示名退回 USB 厂商+型号字符串（与 by-id 解码同名）。
+  `by_id_path` 保持「有就是真路径、没有就是 None」——`ui/lite_window.py` 拿它当
+  **打开设备**的路径，不能伪造。设备 key 从 by-id 前缀退到 `usb-<拓扑路径>`
+  （同样跨重启稳定），最后才退到会漂移的 video 索引。已知副作用：两套都插时
+  单插那颗 key 是 `uvc:usb-1-5`、**不会自动接上旧的 `DECXIN_head`**（那个 key
+  是 by-id 形式、此时归已被过滤的 rig 那颗）；要名字稳定就在两种配置下各命名
+  一次。极简版改为先扫夹爪、拿到根端口再过滤 UVC。
 - **v1.3.6** — 极简版能录 UMI 夹爪了；每个 SLAM 点带上了它那张取样帧的宿主时刻。
   **极简版 + 夹爪**：极简版此前完全不录夹爪，本次推翻该排除。夹爪整条链（力 /
   10×10×3 力矩阵 / 夹爪状态 / SLAM 轨迹）全部落盘，但界面**不显示**任何夹爪

collector/config/__init__.py

@@ -3,21 +3,26 @@
 版本号集中定义于此：settings.APP_VERSION 及其他模块均从这里取值。
 """
 
-__version__ = "1.3.6"
+__version__ = "1.3.8"
 
-# v1.3.6 —— 夹爪并入极简版（只录不显）+ SLAM 轨迹点带上取样帧的宿主时刻戳。
-#   1) 极简版新增夹爪：力 / 10×10×3 力矩阵 / 夹爪状态 / SLAM 轨迹照常落盘，界面
-#      不显示任何夹爪信息，夹爪 RGB 直接当主视频源。载荷是硬约束——Linux 包把
-#      ~460MB 原生栈当必需资源下发，start_lite.sh 逐项校验、缺则报 [错误 B] 拒启
-#      （老机器升级会被拦住而不是跑一半才炸）；Windows 包有意不带、靠载荷缺失降级。
-#      力矩阵编码搬到 core/gripper_codec.py（数据契约只此一份，UI 侧 re-export）。
-#   2) SLAM 点新增 observation.{prefix}slam_trajectory_ns：native 在 stereoCallback
-#      入口取一次 CLOCK_MONOTONIC，随帧走到 stdout 的 Host:(<ns>)，与点列表锁步落盘。
-#      真机验收（episode-085/086）：点数=戳数、零全 0 行、最近邻残差中位 6.9ms
-#      （按行号配对为 83ms）。旧 native 二进制不打印该字段，照旧可读。
-#   另回收 native 树 339MB 被解引用成实体副本的 .so（tools/dedup_gripper_native.py）。
+# v1.3.8 —— 修 v1.3.7 遗留：同型号同序列号两颗（真机两颗 DECXIN：序列号都是
+#   01.00.00）的 by-id 链接**归属会在重新枚举时翻转**（谁后注册谁拿到），于是
+#   同一台相机在 `uvc:usb-1-5` 与 `uvc:usb-DECXIN_..._01.00.00` 两个 key 之间
+#   跳 —— 面板表现为设备消失又出现（真机 logs/main.log 抓到 `Connected:
+#   DECXIN_head` 紧跟 `Disconnected: DECXIN DECXIN CAMERA`）、用户起的名字丢失。
+#   v1.3.7 只让「拿不到链接」那颗退拓扑路径，拿到链接那颗仍用 by-id ⇒ 翻转时
+#   两颗一起跳，问题没解决。现改为：判定前缀被共用后**两颗都退拓扑路径**。
+#   判据不能是「数前缀重复」—— 任一时刻只有一台真拿到链接，另一台压根进不了
+#   计数；改为「一台没链接的物理设备，其 (厂商, 型号) 与另一台有链接的相同」
+#   （同型号但序列号不同的两台各有各的链接，不会被误判降级）。
+#   代价：那颗单插 DECXIN 的 key 从 by-id 形式变成 `uvc:usb-1-5`，data/
+#   device_names.json 里挂在旧 key 下的名字需重命名一次（旧 key 已不再产生）。
 #
 # 历史版本一行一条，完整说明见 README 的「更新记录」：
+#   v1.3.7  单插的 DECXIN 相机在夹爪 rig 插着时从设备面板消失。**两层独立根因**：
+#           v1.3.0 的 1bcf:2d4f 一刀切黑名单（改按 USB 根端口判归属）+ by-id
+#           链接被同型号相机顶掉（改按物理 USB 设备分组枚举）
+#   v1.3.6  夹爪并入极简版（只录不显）+ SLAM 点带上取样帧的宿主时刻戳
 #   v1.3.5  相机服务静默卡死自愈；夹爪扫描配对改走 ESP32 NVS 序列号
 #   v1.3.4  新夹爪接入即自动生成运行标定并连接，不再需要人工两步
 #   v1.3.3  力矩阵 / 触觉力与 RGB 视频的时间戳对齐（补 capture_ns 稀疏列）

collector/core/camera.py

@@ -294,34 +294,149 @@ def _discover_indices(max_index: int = 8) -> list:
     return sorted(all_indices)
 
 
+def _usb_ident_strings(index: int) -> tuple:
+    """USB 设备节点的 (厂商, 型号) 字符串；取不到给空串。
+
+    无 by-id 链接时用它拼显示名 —— 同型号同序列号两台并存会被 udev 顶掉
+    链接，此时只剩 sysfs 字符串可读。
+    """
+    node = os.path.realpath(f"/sys/class/video4linux/video{index}")
+    for _ in range(6):
+        try:
+            with open(os.path.join(node, "product")) as f:
+                product = f.read().strip()
+            if product:
+                try:
+                    with open(os.path.join(node, "manufacturer")) as f:
+                        manufacturer = f.read().strip()
+                except OSError:
+                    manufacturer = ""
+                return manufacturer, product
+        except OSError:
+            pass
+        parent = os.path.dirname(node)
+        if parent == node:
+            break
+        node = parent
+    return "", ""
+
+
+def _physical_usb_path(index: int) -> Optional[str]:
+    """videoN 所属物理 USB 设备的拓扑路径（如 "1-5"）；非 USB/取不到返回 None。
+
+    同一台相机的多个流（videoN / videoN+1）共享同一路径，可当分组键 ——
+    与 by-id 不同，**同型号同序列号两台并存时不会撞**。
+    """
+    try:
+        node = os.path.realpath(f"/sys/class/video4linux/video{index}/device")
+    except OSError:
+        return None
+    for component in reversed(node.split(os.sep)):
+        physical = component.split(":", 1)[0]
+        if re.fullmatch(r"\d+-\d+(?:\.\d+)*", physical):
+            return physical
+    return None
+
+
+def _v4l_nodes_by_physical_device(max_index: int) -> dict:
+    """{物理设备键: [video_index, ...]}，覆盖 sysfs 里**所有** v4l 节点。
+
+    键优先取 USB 拓扑路径，非 USB 节点退回 sysfs realpath，保证同一物理
+    设备的多个流聚到一组。
+    """
+    groups: dict = {}
+    root = "/sys/class/video4linux"
+    try:
+        entries = os.listdir(root)
+    except OSError:
+        return groups
+    for entry in entries:
+        if not re.fullmatch(r"video\d+", entry):
+            continue
+        idx = int(entry[len("video"):])
+        if idx >= max_index:
+            continue
+        key = _physical_usb_path(idx) or os.path.realpath(
+            os.path.join(root, entry, "device")
+        )
+        groups.setdefault(key, []).append(idx)
+    return groups
+
+
+def _ambiguous_by_id_prefixes(groups: dict) -> set:
+    """by-id 前缀不可当稳定标识的那些前缀（被多台物理设备共用）。
+
+    udev 的 by-id 链接名 = `usb-<厂商>_<型号>_<序列号>`，而链接名在一个目录
+    内唯一：同型号**同序列号**的两台并存时，**只有一台真拿到链接**，另一台
+    by_id_path 为 None。要命的是**谁拿到取决于注册顺序**，重新枚举时会在两台
+    之间翻转 ⇒ 同一台相机在两个 key（by-id 形式 / usb-<拓扑路径>）之间跳，
+    面板表现为设备消失又出现、并把用户起的名字丢掉（真机 logs/main.log 抓到
+    `Connected: DECXIN_head` 紧跟 `Disconnected: DECXIN DECXIN CAMERA`）。
+
+    **判据不能是「数前缀重复」**：任一时刻只有一台有链接，另一台压根进不了
+    计数。改为 —— 一台**没链接**的物理设备，其 (厂商, 型号) 与另一台**有
+    链接**的相同，说明那台的链接是踩了它才拿到的。同型号**不同序列号**的两台
+    各有各的链接、不会被误判（它们的 by-id key 仍然是稳的，不降级）。
+    """
+    linked = {}         # (厂商, 型号) → [前缀, ...]
+    unlinked = set()    # 拿不到链接的物理设备的 (厂商, 型号)
+    for idx_list in groups.values():
+        idx = min(idx_list)
+        ident = tuple(s.strip().lower() for s in _usb_ident_strings(idx))
+        if not any(ident):
+            continue        # 读不到厂商/型号 → 无从判定，不参与（保守）
+        path = _find_persistent_v4l_path(idx)
+        if not path:
+            unlinked.add(ident)
+            continue
+        prefix = os.path.basename(path).rsplit("-video-index", 1)[0]
+        linked.setdefault(ident, []).append(prefix)
+    ambiguous = set()
+    for ident in unlinked:
+        ambiguous.update(linked.get(ident, ()))
+    return ambiguous
+
+
 def list_v4l_devices(max_index: int = 16) -> list:
     """sysfs 只读枚举 V4L2 设备（不 open、不 test_read，轮询安全）。
 
-    以 /dev/v4l/by-id 分组识别物理设备，每个物理设备只保留主视频流
-    （最小索引）。返回列表每项:
-      {video_index, name, serial, by_id_path, vid, pid, is_sdk}
-    name 从 by-id 前缀解码（去 "usb-" 前缀、字段分隔符转空格）;
+    按**物理 USB 设备**分组（不是 by-id）：同型号同序列号两台并存时 udev
+    的 by-id 链接名唯一（`usb-<厂商>_<���号>_<序列号>` 完全相同），后注册的
+    那台会顶掉前一台的链接 —— 以 by-id 为枚举入口会让被顶掉那台**整个从
+    面板消失**。每个物理设备只保留主视频流（最小索引）。返回列表每项:
+      {video_index, name, serial, by_id_path, by_id_ambiguous, usb_path,
+       vid, pid, is_sdk}
+    by_id_path 尽力而为：无对应链接（被顶掉/无 by-id 规则）时为 None，
+    调用方须回退到 video_index 打开。**by_id_ambiguous 为真表示这个前缀被
+    多台共用、归属会在重新枚举时翻转，不能当 key**（见
+    _ambiguous_by_id_prefixes）；注意它只影响「能不能拿前缀当标识」，
+    by_id_path 本身仍是真路径、照旧可用于打开设备。name 优先从 by-id 前缀
+    解码（去 "usb-" 前缀、字段分隔符转空格），无链接时回退 sysfs name 文件;
     serial 启发式取前缀最后一段（仅纯字母数字且 ≥8 字符才认作序号）。
     被占用的设备不会被打开，仍会稳定出现在列表中。
     """
     devices = []
-    for prefix, idx_list in sorted(_by_id_device_streams().items()):
-        idx_list = sorted(idx_list)
-        idx = idx_list[0]           # 主视频流
-        if idx >= max_index:
-            continue
+    groups = _v4l_nodes_by_physical_device(max_index)
+    ambiguous = _ambiguous_by_id_prefixes(groups)
+    for _key, idx_list in sorted(groups.items()):
+        idx = min(idx_list)         # 主视频流
+        by_id_path = _find_persistent_v4l_path(idx)
+        prefix = (os.path.basename(by_id_path).rsplit("-video-index", 1)[0]
+                  if by_id_path else "")
+        name, serial = "", ""
         if prefix.startswith("usb-"):
             # usb-<vendor>_<model>_<serial> → 分段转空格
             segments = [s for s in re.split(r"[-_]", prefix[len("usb-"):]) if s]
-            serial = ""
             if segments and segments[-1].isalnum() and len(segments[-1]) >= 8:
                 serial = segments[-1]   # 序号单独显示，不进名称
                 segments = segments[:-1]
             name = " ".join(segments).strip()
-        else:
-            name, serial = "", ""
         if not name:
-            # 非 USB 前缀无法解码，回退 sysfs name 文件
+            # 无 by-id（被 udev 顶掉/无规则）→ 退回 USB 厂商+型号字符串，
+            # 与 by-id 解码结果同名；再取不到才用 sysfs name 文件
+            manufacturer, product = _usb_ident_strings(idx)
+            name = " ".join(p for p in (manufacturer, product) if p).strip()
+        if not name:
             try:
                 with open(f"/sys/class/video4linux/video{idx}/name") as f:
                     name = f.read().strip()
@@ -332,7 +447,9 @@ def list_v4l_devices(max_index: int = 16) -> list:
             "video_index": idx,
             "name": name,
             "serial": serial,
-            "by_id_path": _find_persistent_v4l_path(idx),
+            "by_id_path": by_id_path,
+            "by_id_ambiguous": prefix in ambiguous,
+            "usb_path": _physical_usb_path(idx),
             "vid": vp[0] if vp else None,
             "pid": vp[1] if vp else None,
             "is_sdk": _is_sdk_device(idx),

collector/core/device_detector.py

@@ -147,12 +147,15 @@ def _list_uvc_devices_windows(max_index: int) -> List[DeviceInfo]:
     return infos
 
 
-def _list_uvc_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[DeviceInfo]:
+def _list_uvc_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX,
+                      *, gripper_hubs=None) -> List[DeviceInfo]:
     """UVC 网络摄像头（排除 RealSense UVC 节点、FTDI SDK 设备与夹爪组件）。
 
     夹爪组件的 Sightac/DECXIN/FTDI 相机由 libuvc 服务或 Fays 桥接独占，
-    绝不作为通用 UVC 相机出现。Linux: sysfs 只读枚举（/dev/v4l/by-id
-    分组，轮询安全）。Windows: pygrabber DirectShow 枚举。
+    绝不作为通用 UVC 相机出现；但只有与控制板同根端口的那颗才算 rig 的，
+    单插的 DECXIN 按普通 UVC 放出来（见 _is_gripper_component_camera）。
+    Linux: sysfs 只读枚举（/dev/v4l/by-id 分组，轮询安全）。
+    Windows: pygrabber DirectShow 枚举。
     """
     if os.name == "nt":
         return _list_uvc_devices_windows(max_index)
@@ -162,12 +165,19 @@ def _list_uvc_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[D
             continue
         if d.get("is_realsense"):
             continue
-        if _is_gripper_component_camera(d):
+        if _is_gripper_component_camera(d, gripper_hubs=gripper_hubs):
             continue
-        # key 用 by-id 前缀（跨插拔稳定）；无 by-id 时退化为索引
+        # key 用 by-id 前缀（跨插拔稳定）；同型号同序列号两台并存时 udev 的
+        # by-id 链接名唯一、被对方顶掉，退化为 USB 拓扑路径（同样跨重启
+        # 稳定），最后才退到可能漂移的 video 索引。
+        # by_id_ambiguous＝该前缀被多台共用，**链接归属会在重新枚举时翻转**
+        # （谁后注册谁拿到），此时前缀本身就不再稳定 —— 拿到链接的那台也得
+        # 放弃它，否则同一台相机在两个 key 之间跳、面板上设备消失又出现。
         prefix = str(d["video_index"])
-        if d.get("by_id_path"):
+        if d.get("by_id_path") and not d.get("by_id_ambiguous"):
             prefix = os.path.basename(d["by_id_path"]).rsplit("-video-index", 1)[0]
+        elif d.get("usb_path"):
+            prefix = f"usb-{d['usb_path']}"
         infos.append(DeviceInfo(
             key=f"uvc:{prefix}",
             kind="uvc",
@@ -436,7 +446,11 @@ def detect_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[Devi
     except Exception:
         gripper_devices = []
     try:
-        devices += _list_uvc_devices(max_index)
+        # rig 的组件相机（DECXIN/Sightac/FT602）归 libuvc 服务独占，不进通用
+        # 列表；只有与控制板同根端口的那颗才算 rig 的，单插的 DECXIN 放行。
+        devices += _list_uvc_devices(
+            max_index, gripper_hubs=gripper_root_hubs(gripper_devices)
+        )
     except Exception:
         pass
     try:
@@ -554,21 +568,101 @@ _GRIPPER_USB_PID = 0x1001
 # 夹爪组件相机（Sightac 触觉 ×2 / DECXIN RGB / Fays FT602），libuvc 服务与
 # Fays 桥接独占，绝不进通用 UVC 列表
 _GRIPPER_COMPONENT_UVC = {("0c45", "636f"), ("1bcf", "2d4f"), ("0403", "602e")}
+_GRIPPER_COMPONENT_TOKENS = ("0c45_636f", "1bcf_2d4f", "0403_602e",
+                             "sightac", "decxin", "ftdi superspeed")
+# 组件里唯一有独立用途的一颗：DECXIN 单插时跑 USB-DECXIN--- 手部关键点任务
+# （v1.3.0 前它是普通 UVC 相机，device_names.json 里还留着 "DECXIN_head"）。
+# rig 上那颗与 Sightac 一起挂在控制板的根端口下，单插那颗在别的根端口 ——
+# 真机实测：控制板 1-2.2.1、rig 的 DECXIN 1-2.2.2（同属根端口 1-2），
+# 单插的 DECXIN 1-5。原生 discover-uvc-config 按同一拓扑分组，把单插那颗
+# 标成 ungrouped。Sightac/FT602 不放开：前者单插无用，后者另有 is_sdk 兜底。
+_GRIPPER_STANDALONE_UVC = {("1bcf", "2d4f")}
+_GRIPPER_STANDALONE_TOKENS = ("1bcf_2d4f", "decxin")
+
+
+def _usb_root_hub_from_sysfs(sysfs_node: str) -> Optional[str]:
+    """从 sysfs 设备节点取 USB 根端口（"1-2.2.1" → "1-2"）；取不到返回 None。
+
+    与 core/gripper/devices/usb_camera_sets.py 的 _root_hub_from_physical
+    同一约定。此处自带一份，是因为本模块必须能在 Windows 上 import（见
+    core/gripper_codec.py 的 fcntl 陷阱），不反向依赖 core.gripper。
+    """
+    try:
+        resolved = os.path.realpath(sysfs_node)
+    except OSError:
+        return None
+    for component in reversed(resolved.split(os.sep)):
+        physical = component.split(":", 1)[0]
+        match = re.fullmatch(r"(\d+-\d+)(?:\.\d+)*", physical)
+        if match is not None:
+            return match.group(1)
+    return None
+
+
+def _v4l_root_hub(video_index) -> Optional[str]:
+    """V4L2 节点（/dev/videoN）所在的 USB 根端口。"""
+    if video_index is None:
+        return None
+    return _usb_root_hub_from_sysfs(
+        f"/sys/class/video4linux/video{video_index}/device"
+    )
+
+
+def _tty_root_hub(device_path: str) -> Optional[str]:
+    """ttyACM 控制板所在的 USB 根端口；用来定位夹爪 rig 占了哪个根端口。"""
+    basename = os.path.basename(str(device_path or "").strip())
+    if not re.fullmatch(r"ttyACM\d+", basename):
+        return None
+    return _usb_root_hub_from_sysfs(f"/sys/class/tty/{basename}/device")
+
 
+def gripper_root_hubs(gripper_devices) -> set:
+    """夹爪控制板占用的 USB 根端口集合；空集＝本次没接 rig。
 
-def _is_gripper_component_camera(d: dict) -> bool:
-    """按 VID/PID 识别夹爪组件相机；VID/PID 缺失时用 by-id 字符串兜底。"""
+    rig 的 DECXIN/Sightac 与控制板同根端口，据此把单插的 DECXIN 从夹爪
+    组件的排除名单里摘出来（见 _is_gripper_component_camera）。
+    """
+    hubs = set()
+    for info in gripper_devices or ():
+        hub = _tty_root_hub(getattr(info, "address", "") or "")
+        if hub:
+            hubs.add(hub)
+    return hubs
+
+
+def _is_gripper_component_camera(d: dict, *, gripper_hubs=None) -> bool:
+    """按 VID/PID 识别夹爪组件相机；VID/PID 缺失时用 by-id 字符串兜底。
+
+    gripper_hubs 是控制板占用的根端口集合（gripper_root_hubs()）:
+      None     → 未知，一律按组件处理（保守，维持旧契约）
+      set()    → 没接 rig，没有 libuvc 服务独占 → 可独立使用的 DECXIN 放行
+      {"1-2"}  → 只放行不在这些根端口下的 DECXIN，即单插的那颗
+    相机自身根端口取不到时同样按组件处理 —— 宁可藏，不可与 rig 双开。
+    """
+    releasable = gripper_hubs is not None
+    hubs = set(gripper_hubs or ())
     vid = str(d.get("vid") or "").lower()
     pid = str(d.get("pid") or "").lower()
-    if vid and pid:
-        return (vid, pid) in _GRIPPER_COMPONENT_UVC
-    by_id = (d.get("by_id_path") or "").lower()
-    name = (d.get("name") or "").lower()
-    return any(
-        token in by_id or token in name
-        for token in ("0c45_636f", "1bcf_2d4f", "0403_602e",
-                      "sightac", "decxin", "ftdi superspeed")
-    )
+    if not (vid and pid):
+        by_id = (d.get("by_id_path") or "").lower()
+        name = (d.get("name") or "").lower()
+        if releasable and any(
+            token in by_id or token in name
+            for token in _GRIPPER_STANDALONE_TOKENS
+        ):
+            hub = _v4l_root_hub(d.get("video_index"))
+            if hub is not None and hub not in hubs:
+                return False
+        return any(
+            token in by_id or token in name
+            for token in _GRIPPER_COMPONENT_TOKENS
+        )
+    key = (vid, pid)
+    if key in _GRIPPER_STANDALONE_UVC and releasable:
+        hub = _v4l_root_hub(d.get("video_index"))
+        if hub is not None and hub not in hubs:
+            return False
+    return key in _GRIPPER_COMPONENT_UVC
 
 
 def _list_gripper_devices() -> List[DeviceInfo]:

collector/docs/config.md

@@ -117,7 +117,7 @@ config/ 是应用全局配置、国际化与版本号所在的配置包。版本
 **JSON 字段约定**（由本模块的读写函数定义）：
 
 - `data/server_config.json`：`server_url`（str）、`username`（str）、`password`（str）、`upload_auto_sync`（bool，缺省 `True`）、`upload_delete_after`（bool，缺省 `False`）。
-- `data/device_names.json`：key = `DeviceInfo.stable_key`（形如 `"uvc:{by-id前缀}"` / `"d435:{serial}"` / `"ble:{MAC}"` 等），value = `{"name": str, "sensor"?: str}`（`sensor` 仅 `data_ble` 设备用，绑定 parquet 列名 `right_glove`/`left_glove`，按 MAC 持久化）；旧版纯字符串自动升级为 `{"name": …}`。
+- `data/device_names.json`：key = `DeviceInfo.stable_key`（形如 `"uvc:{by-id前缀}"` / `"uvc:usb-1-5"`（无 by-id 链接、或该前缀被同型号多台共用而归属会翻转时，退到 USB 拓扑路径）/ `"d435:{serial}"` / `"ble:{MAC}"` 等），value = `{"name": str, "sensor"?: str}`（`sensor` 仅 `data_ble` 设备用，绑定 parquet 列名 `right_glove`/`left_glove`，按 MAC 持久化）；旧版纯字符串自动升级为 `{"name": …}`。
 - `data/device_params.json`：key 同 `stable_key`，value = `{"exposure": {"auto": bool, "value": float}, "original": {同结构}}`；`auto=True` 时 `value` 忽略；`original` 首次看到才写入、之后永不覆盖，供"恢复默认"回到开机原厂曝光。
 
 **调用关系**：被 `core/`（`pipeline.py`、`camera.py`、`hand_tracking.py`、`stereo_depth.py`、`device_detector.py`、`d435_camera.py`、`egodata_writer.py`、`task_record.py`、`render_engine.py`、`helpers.py`（`as _settings`）等）、`ui/`（`main_window.py`、`camera_widget.py`、`device_panel.py`、`playback_dialog.py`、`upload_dialog.py`、`task_page.py`）以及 `tools/tests/` 多个用例 import。自身仅依赖 `os` 与 `config.__version__`。

collector/docs/core.md

@@ -71,11 +71,13 @@
 | 名称 | 签名要点 | 作用 | 返回/副作用 |
 |---|---|---|---|
 | `CameraState` | 类常量 | 状态枚举 | `DISCONNECTED/IDLE/RECORDING/ERROR` |
-| `list_v4l_devices` | `(max_index=16)` | sysfs 只读枚举 V4L2 设备，by-id 分组、每物理设备只留主视频流 | 每项 `{video_index, name, serial, by_id_path, vid, pid, is_sdk, is_realsense}` |
+| `list_v4l_devices` | `(max_index=16)` | sysfs 只读枚举 V4L2 设备，**按物理 USB 设备**分组（键取拓扑路径如 `1-5`，非 USB 节点退回 realpath）、每物理设备只留主视频流 | 每项 `{video_index, name, serial, by_id_path, by_id_ambiguous, usb_path, vid, pid, is_sdk, is_realsense}`；无对应链接时 `by_id_path` 为 `None`。`by_id_ambiguous=True` = 该前缀被同型号多台共用、链接归属会在重枚举时翻转，**不能当 key**（见 `_ambiguous_by_id_prefixes`）；`by_id_path` 本身不受影响，仍是「真路径或 None」，照旧可用于打开设备 |
 | `detect_cameras` | `(max_index=8)` | 打开测试（test_read）枚举可用相机 | `[(idx, backend), ...]` |
 | `_try_open_camera`（内部） | `(index, test_read=False, fallback_all_by_id=False)` | 按后端列表（Linux: V4L2/FFMPEG/ANY；Windows: DShow/MSMF/ANY）尝试打开 | `(VideoCapture, backend名)` 或 `(None, "")` |
 | `_is_sdk_device` / `_is_realsense_node`（内部） | `(index)` | sysfs name/VID:PID 判 FTDI SDK 设备与 RealSense 节点 | `bool` |
 | `_usb_vid_pid`（内部） | `(video_index)` | 沿 sysfs 设备树向上（≤6 层）找 `idVendor`/`idProduct` | `(vid, pid)` 小写十六进制或 `None` |
+| `_physical_usb_path` / `_usb_ident_strings`（内部） | `(index)` | 节点所属物理 USB 设备的拓扑路径 / 沿 sysfs 向上（≤6 层）找 USB `manufacturer`+`product` 字符串 | `str`（如 `"1-5"`）或 `None` / `(厂商, 型号)`，取不到给空串 |
+| `_v4l_nodes_by_physical_device`（内部） | `(max_index)` | sysfs 里**所有** v4l 节点按物理设备分组——同型号同序列号两台并存时 udev 的 by-id 链接名会相撞，只有拓扑分得开 | `{物理设备键: [video_index, ...]}` |
 | `CameraWorker` | `(camera_index=0, resolution=None, record_queue=None)` | UVC 采集 worker；默认分辨率 `settings.DEFAULT_RESOLUTION`（1280×960@30，MJPG） | 信号：`frame_ready(ndarray)`、`state_changed(str)`、`error_occurred(str)`、`fps_updated(float)`、`camera_opened(int,int,str)` |
 | `CameraWorker.start` / `stop` / `pause` / `resume` | 无参 | 生命周期控制（stop join ≤5s） | 无 |
 | `CameraWorker.state` / `is_connected` / `resolution` / `latest_capture_ts_us` | property | 状态、连接、实际分辨率、最新帧采集时间戳（Unix 微秒，线程安全） | 对应值 |
@@ -134,10 +136,13 @@ RGB（BGR 三通道）+ 深度（uint16，归一化毫米）两路信号。左
 | `detect_devices` | `(max_index=settings.DEVICE_SCAN_MAX_INDEX)` | 四段枚举（UVC+D435+S80M+BLE），各自容错整体不崩 | `List[DeviceInfo]` |
 | `DeviceScanner` | `(parent=None, max_index=None)` | 后台线程扫描，`_busy` 守卫防轮询堆积 | 信号 `scan_finished(list)`；`request_scan()`/`stop()` |
 | `set_ble_scan_suppressed` | `(on: bool)` | 抑制 bleak 主动发现（手套连接中防扫描挤占吞吐），不影响 bluetoothctl 列表 | 无 |
-| `_list_uvc_devices` / `_list_d435_devices` / `_list_s80m_devices` / `_list_ble_devices`（内部） | 各自 max_index | 分段枚举 | `List[DeviceInfo]` |
+| `_list_uvc_devices`（内部） | `(max_index, *, gripper_hubs=None)` | UVC 分段枚举；`gripper_hubs`＝夹爪控制板占用的 USB 根端口集合，用来把单插的 DECXIN 与 rig 那颗同 VID/PID 的相机分开（`None`＝未知，一律按组件排除） | `List[DeviceInfo]` |
+| `_list_d435_devices` / `_list_s80m_devices` / `_list_ble_devices`（内部） | 各自 max_index | 分段枚举 | `List[DeviceInfo]` |
+| `gripper_root_hubs` | `(gripper_devices)` | 从夹爪控制板的 tty 路径取它占用的 USB 根端口集合；空集＝本次没接 rig | `set[str]` |
+| `_is_gripper_component_camera`（内部） | `(d, *, gripper_hubs=None)` | 按 VID/PID 判夹爪组件相机；DECXIN 若在非控制板根端口下则放行（单插那颗，有独立用途），Sightac/FT602 始终排除；相机自身根端口取不到时保守排除 | `bool` |
 | `_is_glove_name`（内部） | `(name)` | 广播名判手套：含 "matrix" 或单字母 `l/r/left/right/l_glove/r_glove/left_glove/right_glove` | `bool` |
 
-**关键数据**：`DeviceInfo.key` 格式约定：`"uvc:{by-id前缀或索引}"`、`"d435:{serial}"`、`"s80m:ftdi"`、`"ble:{MAC}"`；`kind` 取值 `uvc | d435 | s80m | data_ble | ble`（`data_ble`=手套）。BLE 常量 `BLE_DISCOVERY_INTERVAL_S=20.0`、`BLE_DISCOVERY_TIMEOUT_S=5.0`。S80M：FTDI 命中一次即返回单条（SDK 配置写死 video0/video2）。RealSense UVC 节点判定：vendor 8086 且 PID 0b07（D435）或驱动 name 含 "RealSense"（D435i 为 0b3a、其余型号 PID 各异，name 兜底）。
+**关键数据**：`DeviceInfo.key` 格式约定：`"uvc:{by-id前缀 | usb-<拓扑路径> | 索引}"`（无链接、**或前缀被同型号多台共用**（`by_id_ambiguous`，链接归属会在重枚举时翻转）→ 退到拓扑路径，两者都跨重启稳定，索引兜底但会漂移）、`"d435:{serial}"`、`"s80m:ftdi"`、`"ble:{MAC}"`；`kind` 取值 `uvc | d435 | s80m | data_ble | ble`（`data_ble`=手套）。BLE 常量 `BLE_DISCOVERY_INTERVAL_S=20.0`、`BLE_DISCOVERY_TIMEOUT_S=5.0`。S80M：FTDI 命中一次即返回单条（SDK 配置写死 video0/video2）。RealSense UVC 节点判定：vendor 8086 且 PID 0b07（D435）或驱动 name 含 "RealSense"（D435i 为 0b3a、其余型号 PID 各异，name 兜底）。
 
 **调用关系**：被 `ui/main_window.py`（`DeviceScanner`）、`ui/device_panel.py`、`tools/tests/device_panel_gui_smoke_test.py`（`DeviceInfo`/`detect_devices`）、`tools/tests/glove_widget_test.py`、`tools/tests/multi_device_registry_test.py` 引用；调用了 `core/camera.py`。
 

collector/docs/data.md

@@ -45,7 +45,7 @@
 }
 ```
 
-- **key**：设备稳定标识 `DeviceInfo.stable_key`，形式如 `uvc:{by-id 前缀}`、
+- **key**：设备稳定标识 `DeviceInfo.stable_key`，形式如 `uvc:{by-id 前缀}`（同型号同序列号两台并存时 udev 的 by-id 链接名相撞、只有一台拿得到链接，**且谁拿到取决于注册顺序、重枚举时会翻转** ⇒ 两台都退到 `uvc:usb-<USB 拓扑路径>` 如 `uvc:usb-1-5`，同样跨重启稳定）、
   `d435:{serial}`、`ble:{MAC}` 等（含设备序列号/MAC，属本地敏感信息，不入库）。
 - **value**：规范形式为 `{"name": str, "sensor"?: str}`；旧版本可能是纯字符串，
   读取时自动兼容升级。

collector/tools/tests/test_device_detector.py

@@ -100,6 +100,59 @@ def _main():
     check(infos[0].video_index == 2 and infos[0].serial == "2024010100",
           f"webcam 索引/序号正确: idx={infos[0].video_index} serial={infos[0].serial}")
 
+    print("── 2b. list_v4l_devices 按物理设备分组（by-id 被顶掉也可见） ──")
+    # 两颗同型号同序列号 DECXIN：udev 的 by-id 链接名唯一（厂商_型号_序列号
+    # 完全相同），只有后注册那颗有链接，另一颗成孤儿。以 by-id 为枚举入口
+    # 会让孤儿**整个从面板消失**（真机：video8/9 曾是这种孤儿）。
+    nodes = {"1-5": [8, 9], "1-2.2.2": [10, 11]}
+    hub_of = {8: "1-5", 9: "1-5", 10: "1-2.2.2", 11: "1-2.2.2"}
+    with patch("core.camera._v4l_nodes_by_physical_device",
+               return_value=nodes), \
+         patch("core.camera._physical_usb_path",
+               side_effect=lambda i: hub_of.get(i)), \
+         patch("core.camera._find_persistent_v4l_path",
+               side_effect=lambda i: ("/dev/v4l/by-id/usb-DECXIN_DECXIN_CAMERA"
+                                      "_01.00.00-video-index0" if i == 10 else None)), \
+         patch("core.camera._usb_vid_pid", return_value=("1bcf", "2d4f")), \
+         patch("core.camera._usb_ident_strings",
+               return_value=("DECXIN", "DECXIN CAMERA")), \
+         patch("core.camera._is_sdk_device", return_value=False), \
+         patch("core.camera._is_realsense_node", return_value=False):
+        devs = cam.list_v4l_devices(16)
+    check(sorted(d["video_index"] for d in devs) == [8, 10],
+          f"两颗各取主视频流（不是聚成一颗）: {[d['video_index'] for d in devs]}")
+    orphan = next(d for d in devs if d["video_index"] == 8)
+    check(orphan["by_id_path"] is None and orphan["usb_path"] == "1-5"
+          and orphan["name"] == "DECXIN DECXIN CAMERA",
+          f"孤儿靠 USB 拓扑+字符串兜底: {orphan}")
+    # 同型号 + 有一台拿不到链接 ⇒ 那个前缀不能当 key：**谁拿链接取决于注册
+    # 顺序、重新枚举时会翻转**，于是拿到链接的 video10 自己也得放弃 by-id
+    # 前缀。注意判据不能是「数前缀重复」—— 任一时刻只有一台有链接，另一台
+    # 压根进不了计数，这么写永远数不出来。
+    check(next(d for d in devs if d["video_index"] == 10)["by_id_ambiguous"] is True,
+          "同型号无链接设备在场 → 该 by-id 前缀标记有歧义（拿链接的也要退）")
+    check(orphan["by_id_ambiguous"] is False,
+          "孤儿无前缀，不参与歧义标记（by_id_path=None 本就退拓扑）")
+
+    # 对照：同型号**不同序列号**两台各有各的链接 → 前缀唯一，不许误判降级
+    link2 = {8: "/dev/v4l/by-id/usb-DECXIN_DECXIN_CAMERA_01.00.00-video-index0",
+             10: "/dev/v4l/by-id/usb-DECXIN_DECXIN_CAMERA_01.00.01-video-index0"}
+    with patch("core.camera._v4l_nodes_by_physical_device", return_value=nodes), \
+         patch("core.camera._physical_usb_path",
+               side_effect=lambda i: hub_of.get(i)), \
+         patch("core.camera._find_persistent_v4l_path",
+               side_effect=lambda i: link2.get(i)), \
+         patch("core.camera._usb_vid_pid", return_value=("1bcf", "2d4f")), \
+         patch("core.camera._usb_ident_strings",
+               return_value=("DECXIN", "DECXIN CAMERA")), \
+         patch("core.camera._is_sdk_device", return_value=False), \
+         patch("core.camera._is_realsense_node", return_value=False):
+        devs2 = cam.list_v4l_devices(16)
+    check(all(d["by_id_ambiguous"] is False for d in devs2)
+          and len({d["by_id_path"] for d in devs2}) == 2,
+          f"同型号不同序列号各持前缀 → 不降级: "
+          f"{[(d['video_index'], d['by_id_ambiguous']) for d in devs2]}")
+
     print("── 3. _list_s80m_devices 多台按序列号区分（mock _ftdi_camera_groups） ──")
     fake_cams = [
         {"usb_path": "1-3.4.1", "serial": "000000000001", "stereo_index": 0},
@@ -174,6 +227,94 @@ def _main():
          "name": "Sightac"}),
         "VID/PID 缺失时 by-id 兜底排除")
 
+    print("── 4c. 单插 DECXIN 按 USB 根端口与 rig 区分 ──")
+    # 真机：控制板 1-2.2.1、rig 的 DECXIN 1-2.2.2（同根端口 1-2），
+    # 单插的 DECXIN 1-5。同 VID/PID 只能靠拓扑分开。
+    decxin = {"vid": "1bcf", "pid": "2d4f", "video_index": 8}
+    with patch("core.device_detector._v4l_root_hub", return_value="1-5"):
+        check(not det._is_gripper_component_camera(decxin, gripper_hubs=set()),
+              "没接 rig → 单插 DECXIN 放行")
+        check(not det._is_gripper_component_camera(decxin,
+                                                   gripper_hubs={"1-2"}),
+              "与控制板不同根端口 → 单插 DECXIN 放行")
+    with patch("core.device_detector._v4l_root_hub", return_value="1-2"):
+        check(not det._is_gripper_component_camera(decxin, gripper_hubs=set()),
+              "没接 rig → rig 位置的 DECXIN 也放行")
+        check(det._is_gripper_component_camera(decxin, gripper_hubs={"1-2"}),
+              "与控制板同根端口 → rig 的 DECXIN 排除")
+    with patch("core.device_detector._v4l_root_hub", return_value=None):
+        check(det._is_gripper_component_camera(decxin, gripper_hubs={"1-2"}),
+              "根端口取不到 → 保守排除，不与 rig 双开")
+    check(det._is_gripper_component_camera(decxin),
+          "不传 gripper_hubs（未知）→ 维持旧契约排除")
+    with patch("core.device_detector._v4l_root_hub", return_value="1-5"):
+        check(det._is_gripper_component_camera(
+            {"vid": "0c45", "pid": "636f", "video_index": 9},
+            gripper_hubs=set()), "Sightac 单插也无独立用途 → 始终排除")
+
+    # 端到端：两颗同型号 DECXIN 同时在位，只放行单插那颗
+    def _mk_decxin(idx, tail):
+        return {"video_index": idx, "name": "DECXIN DECXIN CAMERA 01.00.00",
+                "serial": "01.00.00",
+                "by_id_path": f"/dev/v4l/by-id/usb-DECXIN_DECXIN_CAMERA_{tail}"
+                              f"-video-index0",
+                "vid": "1bcf", "pid": "2d4f",
+                "is_sdk": False, "is_realsense": False}
+    # hub_of 按 _v4l_root_hub 的契约给**根端口**（1-2.2.2 的根端口是 1-2）
+    hub_of = {8: "1-5", 10: "1-2"}
+    with patch("core.device_detector.list_v4l_devices",
+               return_value=[_mk_decxin(8, "01.00.00"), _mk_decxin(10, "01.00.01")]), \
+         patch("core.device_detector._v4l_root_hub",
+               side_effect=lambda i: hub_of.get(i)):
+        infos = _list_uvc_devices(16, gripper_hubs={"1-2"})
+    check([i.video_index for i in infos] == [8]
+          and infos[0].key == "uvc:usb-DECXIN_DECXIN_CAMERA_01.00.00",
+          f"只放行单插那颗且 key 与 device_names 稳定: "
+          f"{[(i.video_index, i.key) for i in infos]}")
+
+    # by-id 被顶掉时 key 退到 USB 拓扑路径（跨重启稳定），不是会漂移的索引
+    with patch("core.device_detector.list_v4l_devices", return_value=[
+            {"video_index": 8, "name": "DECXIN DECXIN CAMERA", "serial": "",
+             "by_id_path": None, "usb_path": "1-5",
+             "vid": "1bcf", "pid": "2d4f",
+             "is_sdk": False, "is_realsense": False}]), \
+         patch("core.device_detector._v4l_root_hub", return_value="1-5"):
+        infos = _list_uvc_devices(16, gripper_hubs={"1-2"})
+    check([i.key for i in infos] == ["uvc:usb-1-5"],
+          f"by-id 被顶掉 → key 退到 USB 拓扑路径: {[i.key for i in infos]}")
+
+    # by-id 前缀有歧义（被同型号两台共用，链接归属会在重枚举时翻转）→
+    # **拿到链接的那台也不能用**，否则同一台相机在 by-id key 与拓扑 key 之间
+    # 跳，面板表现为设备消失又出现、并把用户起的名字丢掉
+    with patch("core.device_detector.list_v4l_devices", return_value=[
+            {**_mk_decxin(8, "01.00.00"), "usb_path": "1-5",
+             "by_id_ambiguous": True},
+            {**_mk_decxin(10, "01.00.00"), "usb_path": "1-2.2.2",
+             "by_id_ambiguous": True}]), \
+         patch("core.device_detector._v4l_root_hub", return_value="1-5"):
+        infos = _list_uvc_devices(16, gripper_hubs={"1-2"})
+    keys = sorted(i.key for i in infos)
+    check(keys == ["uvc:usb-1-2.2.2", "uvc:usb-1-5"] and len(set(keys)) == 2,
+          f"前缀有歧义 → 两颗都退拓扑路径且 key 互不相同: {keys}")
+
+    # 歧义 + 连拓扑路径都取不到 → 退到索引（最后一档兜底，不许抛异常）
+    with patch("core.device_detector.list_v4l_devices", return_value=[
+            {**_mk_decxin(8, "01.00.00"), "usb_path": "",
+             "by_id_ambiguous": True}]), \
+         patch("core.device_detector._v4l_root_hub", return_value="1-5"):
+        infos = _list_uvc_devices(16, gripper_hubs={"1-2"})
+    check([i.key for i in infos] == ["uvc:8"],
+          f"歧义且无拓扑路径 → 退索引兜底: {[i.key for i in infos]}")
+
+    # gripper_root_hubs：从控制板 tty 路径取根端口
+    with patch("core.device_detector._tty_root_hub",
+               side_effect=lambda p: "1-2" if p == "/dev/ttyACM0" else None):
+        check(det.gripper_root_hubs(
+            [DeviceInfo(key="gripper:s", kind="gripper", display_name="g",
+                        address="/dev/ttyACM0")]) == {"1-2"},
+              "控制板根端口取自 tty 路径")
+    check(det.gripper_root_hubs([]) == set(), "没接 rig → 空集")
+
     # 夹爪枚举：mock 串口枚举 + 资源可用 → 一条 gripper 条目
     class _Port:
         def __init__(self, vid, pid, sn, dev):

collector/ui/lite_window.py

@@ -49,6 +49,7 @@ from core.device_detector import (DeviceInfo, _list_ble_devices,
                                   _list_gripper_devices,
                                   _list_usb_glove_devices,
                                   _list_uvc_devices,
+                                  gripper_root_hubs,
                                   set_ble_scan_suppressed,
                                   usb_glove_prefer_side)
 from core.encoder_probe import list_working_ffmpegs
@@ -593,12 +594,14 @@ class LiteWindow(QMainWindow):
             d435 = _list_d435_devices()
             usb = _list_usb_glove_devices()
             ble = _list_ble_devices()
-            uvc = _list_uvc_devices()
             # 夹爪：_list_gripper_devices 内部先查 paths.gripper_resources_available()
             # （native/ 未随包交付 → 空列表 → 组框照建、里面空着；Windows 上
             # core.gripper 因顶层 import fcntl 直接导入失败，同样被它内部
             # 的 except 兜成空列表）
             gripper = _list_gripper_devices()
+            # rig 的 DECXIN 与单插的同 VID/PID，按控制板根端口区分后再放行
+            # （见 _is_gripper_component_camera）；先扫夹爪才拿得到根端口
+            uvc = _list_uvc_devices(gripper_hubs=gripper_root_hubs(gripper))
             try:
                 self._scan_result.emit(d435, usb, ble, uvc, gripper)
             except RuntimeError: