修改摸底测试功能、修改pattern控制逻辑

drivers/UCD323_Function.py

@@ -16,6 +16,7 @@ class UCDController:
         self.config = None
         self.color_mode = None
         self.status = False
+        self.current_interface = "HDMI"
 
         self.current_timing = None
         self.current_pattern = None
@@ -42,12 +43,14 @@ class UCDController:
             try:
                 self.role = temp_dev.select_role(UniTAP.dev.UCD323.HDMISource)
                 self.dev = temp_dev
+                self.current_interface = "HDMI"
 
             except Exception as role_error:
                 self._close_device_object(temp_dev)
                 raise role_error
 
-            self.timing_manager = self.role.hdtx.pg.timing_manager
+            pg, _ = self.get_tx_modules()
+            self.timing_manager = pg.timing_manager
             self.color_mode = UniTAP.ColorInfo()
             self.status = True
 
@@ -72,6 +75,7 @@ class UCDController:
             self.current_pattern_param = None
             self.current_pattern_params = None
             self.current_pattern_index = 0
+            self.current_interface = "HDMI"
 
             self.lUniTAP = None
 
@@ -94,6 +98,7 @@ class UCDController:
             self.current_pattern_param = None
             self.current_pattern_params = None
             self.current_pattern_index = 0
+            self.current_interface = "HDMI"
 
             try:
                 self.lUniTAP = None
@@ -139,10 +144,51 @@ class UCDController:
             self.current_pattern_param = None
             self.current_pattern_params = None
             self.current_pattern_index = 0
+            self.current_interface = "HDMI"
 
         except Exception as e:
             pass
 
+    def get_tx_modules(self):
+        """根据当前接口返回 (pg, ag) 模块。"""
+        if not self.role:
+            raise RuntimeError("UCD 未打开，无法获取 TX 模块")
+
+        interface = getattr(self, "current_interface", None)
+        if interface in (None, "HDMI"):
+            return self.role.hdtx.pg, self.role.hdtx.ag
+        if interface in ("DP", "Type-C"):
+            return self.role.dptx.pg, self.role.dptx.ag
+        raise ValueError(f"不支持的接口类型: {interface}")
+
+    def _resolve_timing(self, pg=None):
+        """优先从 current_timing 读取 timing，必要时回退到 TX 模块。"""
+        if self.current_timing is not None:
+            return self.current_timing
+
+        if pg is not None:
+            get_vm = getattr(pg, "get_vm", None)
+            if callable(get_vm):
+                try:
+                    vm = get_vm()
+                    return getattr(vm, "timing", None)
+                except Exception:
+                    pass
+
+        return None
+
+    def get_current_resolution(self, default=(3840, 2160)):
+        """从当前 timing 获取 (width, height)，失败时返回 default。"""
+        try:
+            pg, _ = self.get_tx_modules()
+            timing = self._resolve_timing(pg)
+            if timing and hasattr(timing, "h_active") and hasattr(timing, "v_active"):
+                return timing.h_active, timing.v_active
+        except Exception:
+            pass
+
+        return default
+
     def _cleanup(self):
         """清理设备资源"""
         try:
@@ -161,6 +207,9 @@ class UCDController:
         self.config = config
         test_type = self.config.current_test_type
 
+        pg, _ = self.get_tx_modules()
+        self.timing_manager = pg.timing_manager
+
         if test_type == "hdr_movie":
             color_format_str = self.config.current_test_types[test_type]["color_format"]
             color_format = UCDEnum.ColorInfo.get_color_format(color_format_str)
@@ -197,9 +246,58 @@ class UCDController:
         """运行设备"""
         self.apply_video_mode()
         self.apply_pattern()
-        self.role.hdtx.pg.apply()
+        pg, _ = self.get_tx_modules()
+        pg.apply()
         return True
 
+    def send_image_pattern(self, image_path):
+        """发送图片 Pattern（依赖当前 timing/color_mode 状态）。"""
+        if not self.status or not self.role:
+            return False
+
+        try:
+            pg, _ = self.get_tx_modules()
+            self.apply_video_mode()
+            pg.set_pattern(pattern=image_path)
+            pg.apply()
+            return True
+        except Exception:
+            return False
+
+    def send_solid_rgb_pattern(self, rgb):
+        """发送纯色 RGB Pattern（依赖当前 timing/color_mode 状态）。"""
+        if not self.status or not self.role:
+            return False
+
+        try:
+            self.current_pattern = UCDEnum.VideoPatternInfo.get_video_pattern("solidcolor")
+            if self.current_pattern is None:
+                return False
+
+            return self.send_current_pattern_params(list(rgb))
+        except Exception:
+            return False
+
+    def send_current_pattern_params(self, pattern_params):
+        """发送当前已配置的 pattern，并可附带当前 pattern 参数。"""
+        if not self.status or not self.role:
+            return False
+
+        try:
+            if self.current_pattern is None:
+                return False
+
+            if pattern_params is not None and not self.set_pattern(
+                self.current_pattern,
+                pattern_params,
+            ):
+                return False
+
+            self.run()
+            return True
+        except Exception:
+            return False
+
     def set_color_mode(self, cf, bpc, cm):
         """设置颜色模式"""
         current_dynamic_range = None
@@ -246,7 +344,8 @@ class UCDController:
         video_mode = UniTAP.VideoMode(
             timing=self.current_timing, color_info=self.color_mode
         )
-        self.role.hdtx.pg.set_vm(vm=video_mode)
+        pg, _ = self.get_tx_modules()
+        pg.set_vm(vm=video_mode)
         return True
 
     def set_pattern(self, pattern, pattern_params=None):
@@ -292,10 +391,11 @@ class UCDController:
     def apply_pattern(self):
         """应用当前pattern"""
         if self.current_pattern:
-            self.role.hdtx.pg.set_pattern(self.current_pattern)
+            pg, _ = self.get_tx_modules()
+            pg.set_pattern(self.current_pattern)
 
             if self.current_pattern_param:
-                self.role.hdtx.pg.set_pattern_params(self.current_pattern_param)
+                pg.set_pattern_params(self.current_pattern_param)
             return True
         return False
 

drivers/ucd_helpers.py

@@ -1,80 +1,46 @@
 """通用 UCD323/UCDController 辅助函数。
 
-封装"按当前接口取 tx 模块"、"读取分辨率"、"发送图片 Pattern"等所有
-测试模块共用的低层 UCD 操作，避免在多个业务模块中重复 if/else。
+保留为兼容层和薄代理，避免业务模块直接依赖控制器内部实现细节。
 """
 
-import UniTAP
-
 
 def get_tx_modules(ucd):
-    """根据当前接口返回 (pg, ag) 模块。
-
-    兼容 UCD323Controller（多接口，含 current_interface 属性）
-    与老的 UCDController（仅 HDMI）。
-    """
-    interface = getattr(ucd, "current_interface", None)
-    if interface in (None, "HDMI"):
-        return ucd.role.hdtx.pg, ucd.role.hdtx.ag
-    if interface in ("DP", "Type-C"):
-        return ucd.role.dptx.pg, ucd.role.dptx.ag
-    raise ValueError(f"不支持的接口类型: {interface}")
+    """根据当前接口返回 (pg, ag) 模块。"""
+    return ucd.get_tx_modules()
 
 
 def get_current_resolution(ucd, default=(3840, 2160)):
     """从 UCD 当前 timing 获取 (width, height)，失败时返回 default。"""
-    try:
-        pg, _ = get_tx_modules(ucd)
-        vm = pg.get_vm()
-        timing = getattr(vm, "timing", None)
-        if timing and hasattr(timing, "h_active") and hasattr(timing, "v_active"):
-            return timing.h_active, timing.v_active
-    except Exception:
-        pass
-
-    timing = getattr(ucd, "current_timing", None)
-    if timing and hasattr(timing, "h_active") and hasattr(timing, "v_active"):
-        return timing.h_active, timing.v_active
-
-    return default
+    return ucd.get_current_resolution(default)
 
 
-def send_image_pattern(ucd, image_path, *, bpc=8, color_format=None, colorimetry=None):
-    """通过 UCD 发送一张本地图片作为显示 Pattern。
-
-    自动停止音频以避免蜂鸣声。颜色参数留空时使用 RGB / sRGB 默认值。
-    返回 True/False。
-    """
+def send_image_pattern(ucd, image_path):
+    """通过 UCDController 发送一张本地图片作为显示 Pattern。"""
     if not getattr(ucd, "status", False):
         return False
 
-    try:
-        pg, ag = get_tx_modules(ucd)
-    except Exception:
+    send_via_controller = getattr(ucd, "send_image_pattern", None)
+    if not callable(send_via_controller):
+        return False
+    return bool(send_via_controller(image_path))
+
+
+def send_solid_rgb_pattern(ucd, rgb, *, raise_on_error=False):
+    """通过 UCDController 当前状态发送一组纯色 RGB Pattern。"""
+    if not getattr(ucd, "status", False):
+        if raise_on_error:
+            raise RuntimeError("UCD 未连接，无法发送纯色 Pattern")
         return False
 
-    try:
-        ag.stop_generate()
-    except Exception:
-        pass
-
-    color_mode = UniTAP.ColorInfo()
-    color_mode.color_format = color_format or UniTAP.ColorInfo.ColorFormat.CF_RGB
-    color_mode.bpc = bpc
-    color_mode.colorimetry = colorimetry or UniTAP.ColorInfo.Colorimetry.CM_sRGB
-
-    timing = None
-    try:
-        vm = pg.get_vm()
-        timing = getattr(vm, "timing", None)
-    except Exception:
-        pass
-
-    try:
-        if timing:
-            pg.set_vm(vm=UniTAP.VideoMode(timing=timing, color_info=color_mode))
-        pg.set_pattern(pattern=image_path)
-        pg.apply()
-        return True
-    except Exception:
+    send_via_controller = getattr(ucd, "send_solid_rgb_pattern", None)
+    if not callable(send_via_controller):
+        if raise_on_error:
+            raise RuntimeError("UCDController 未实现 send_solid_rgb_pattern")
         return False
+
+    ok = bool(send_via_controller(list(rgb)))
+    if not ok and raise_on_error:
+        raise RuntimeError(f"发送纯色 Pattern 失败: {rgb}")
+    return ok
+
+