优化了全protocol的运行时间，除了pumptransfer相关的还没

unilabos/devices/virtual/virtual_multiway_valve.py

@@ -1,16 +1,20 @@
 import time
+import logging
 from typing import Union, Dict, Optional
 
 
 class VirtualMultiwayValve:
     """
-    虚拟九通阀门 - 0号位连接transfer pump，1-8号位连接其他设备
+    虚拟九通阀门 - 0号位连接transfer pump，1-8号位连接其他设备 🔄
     """
     def __init__(self, port: str = "VIRTUAL", positions: int = 8):
         self.port = port
         self.max_positions = positions  # 1-8号位
         self.total_positions = positions + 1  # 0-8号位，共9个位置
         
+        # 添加日志记录器
+        self.logger = logging.getLogger(f"VirtualMultiwayValve.{port}")
+        
         # 状态属性
         self._status = "Idle"
         self._valve_state = "Ready"
@@ -29,6 +33,10 @@ class VirtualMultiwayValve:
             7: "port_7",         # 7号位
             8: "port_8"          # 8号位
         }
+        
+        print(f"🔄 === 虚拟多通阀门已创建 === ✨")
+        print(f"🎯 端口: {port} | 📊 位置范围: 0-{self.max_positions} | 🏠 初始位置: 0 (transfer_pump)")
+        self.logger.info(f"🔧 多通阀门初始化: 端口={port}, 最大位置={self.max_positions}")
 
     @property
     def status(self) -> str:
@@ -47,16 +55,16 @@ class VirtualMultiwayValve:
         return self._target_position
 
     def get_current_position(self) -> int:
-        """获取当前阀门位置"""
+        """获取当前阀门位置 📍"""
         return self._current_position
 
     def get_current_port(self) -> str:
-        """获取当前连接的端口名称"""
+        """获取当前连接的端口名称 🔌"""
         return self.position_map.get(self._current_position, "unknown")
 
     def set_position(self, command: Union[int, str]):
         """
-        设置阀门位置 - 支持0-8位置
+        设置阀门位置 - 支持0-8位置 🎯
         
         Args:
             command: 目标位置 (0-8) 或位置字符串
@@ -71,112 +79,162 @@ class VirtualMultiwayValve:
                 pos = int(command)
                 
             if pos < 0 or pos > self.max_positions:
-                raise ValueError(f"Position must be between 0 and {self.max_positions}")
+                error_msg = f"位置必须在 0-{self.max_positions} 范围内"
+                self.logger.error(f"❌ {error_msg}: 请求位置={pos}")
+                raise ValueError(error_msg)
+            
+            # 获取位置描述emoji
+            if pos == 0:
+                pos_emoji = "🚰"
+                pos_desc = "泵位置"
+            else:
+                pos_emoji = "🔌"
+                pos_desc = f"端口{pos}"
+            
+            old_position = self._current_position
+            old_port = self.get_current_port()
+            
+            self.logger.info(f"🔄 阀门切换: {old_position}({old_port}) → {pos}({self.position_map.get(pos, 'unknown')}) {pos_emoji}")
             
             self._status = "Busy"
             self._valve_state = "Moving"
             self._target_position = pos
             
             # 模拟阀门切换时间
-            switch_time = abs(self._current_position - pos) * 0.5  # 每个位置0.5秒
-            time.sleep(switch_time)
+            switch_time = abs(self._current_position - pos) * 0.5  # 每个位置0.1秒
+
+            if switch_time > 0:
+                self.logger.info(f"⏱️ 阀门移动中... 预计用时: {switch_time:.1f}秒 🔄")
+                time.sleep(switch_time)
             
             self._current_position = pos
             self._status = "Idle"
             self._valve_state = "Ready"
             
             current_port = self.get_current_port()
-            return f"Position set to {pos} ({current_port})"
+            success_msg = f"✅ 阀门已切换到位置 {pos} ({current_port}) {pos_emoji}"
+            
+            self.logger.info(success_msg)
+            return success_msg
             
         except ValueError as e:
+            error_msg = f"❌ 阀门切换失败: {str(e)}"
             self._status = "Error"
             self._valve_state = "Error"
-            return f"Error: {str(e)}"
+            self.logger.error(error_msg)
+            return error_msg
 
     def set_to_pump_position(self):
-        """切换到transfer pump位置（0号位）"""
+        """切换到transfer pump位置（0号位）🚰"""
+        self.logger.info(f"🚰 切换到泵位置...")
         return self.set_position(0)
 
     def set_to_port(self, port_number: int):
         """
-        切换到指定端口位置
+        切换到指定端口位置 🔌
         
         Args:
             port_number: 端口号 (1-8)
         """
         if port_number < 1 or port_number > self.max_positions:
-            raise ValueError(f"Port number must be between 1 and {self.max_positions}")
+            error_msg = f"端口号必须在 1-{self.max_positions} 范围内"
+            self.logger.error(f"❌ {error_msg}: 请求端口={port_number}")
+            raise ValueError(error_msg)
+        
+        self.logger.info(f"🔌 切换到端口 {port_number}...")
         return self.set_position(port_number)
 
     def open(self):
-        """打开阀门 - 设置到transfer pump位置（0号位）"""
+        """打开阀门 - 设置到transfer pump位置（0号位）🔓"""
+        self.logger.info(f"🔓 打开阀门，设置到泵位置...")
         return self.set_to_pump_position()
 
     def close(self):
-        """关闭阀门 - 对于多通阀门，设置到一个"关闭"状态"""
+        """关闭阀门 - 对于多通阀门，设置到一个"关闭"状态 🔒"""
+        self.logger.info(f"🔒 关闭阀门...")
+        
         self._status = "Busy"
         self._valve_state = "Closing"
         time.sleep(0.5)
-        
+
         # 可以选择保持当前位置或设置特殊关闭状态
         self._status = "Idle"
         self._valve_state = "Closed"
         
-        return f"Valve closed at position {self._current_position}"
+        close_msg = f"🔒 阀门已关闭，保持在位置 {self._current_position} ({self.get_current_port()})"
+        self.logger.info(close_msg)
+        return close_msg
 
     def get_valve_position(self) -> int:
-        """获取阀门位置 - 兼容性方法"""
+        """获取阀门位置 - 兼容性方法 📍"""
         return self._current_position
 
     def is_at_position(self, position: int) -> bool:
-        """检查是否在指定位置"""
-        return self._current_position == position
+        """检查是否在指定位置 🎯"""
+        result = self._current_position == position
+        self.logger.debug(f"🎯 位置检查: 当前={self._current_position}, 目标={position}, 匹配={result}")
+        return result
 
     def is_at_pump_position(self) -> bool:
-        """检查是否在transfer pump位置"""
-        return self._current_position == 0
+        """检查是否在transfer pump位置 🚰"""
+        result = self._current_position == 0
+        pump_status = "是" if result else "否"
+        self.logger.debug(f"🚰 泵位置检查: {pump_status} (当前位置: {self._current_position})")
+        return result
 
     def is_at_port(self, port_number: int) -> bool:
-        """检查是否在指定端口位置"""
-        return self._current_position == port_number
+        """检查是否在指定端口位置 🔌"""
+        result = self._current_position == port_number
+        port_status = "是" if result else "否"
+        self.logger.debug(f"🔌 端口{port_number}检查: {port_status} (当前位置: {self._current_position})")
+        return result
 
     def get_available_positions(self) -> list:
-        """获取可用位置列表"""
-        return list(range(0, self.max_positions + 1))
+        """获取可用位置列表 📋"""
+        positions = list(range(0, self.max_positions + 1))
+        self.logger.debug(f"📋 可用位置: {positions}")
+        return positions
 
     def get_available_ports(self) -> Dict[int, str]:
-        """获取可用端口映射"""
+        """获取可用端口映射 🗺️"""
+        self.logger.debug(f"🗺️ 端口映射: {self.position_map}")
         return self.position_map.copy()
 
     def reset(self):
-        """重置阀门到transfer pump位置（0号位）"""
+        """重置阀门到transfer pump位置（0号位）🔄"""
+        self.logger.info(f"🔄 重置阀门到泵位置...")
         return self.set_position(0)
 
     def switch_between_pump_and_port(self, port_number: int):
         """
-        在transfer pump位置和指定端口之间切换
+        在transfer pump位置和指定端口之间切换 🔄
         
         Args:
             port_number: 目标端口号 (1-8)
         """
         if self._current_position == 0:
             # 当前在pump位置，切换到指定端口
+            self.logger.info(f"🔄 从泵位置切换到端口 {port_number}...")
             return self.set_to_port(port_number)
         else:
             # 当前在某个端口，切换到pump位置
+            self.logger.info(f"🔄 从端口 {self._current_position} 切换到泵位置...")
             return self.set_to_pump_position()
 
     def get_flow_path(self) -> str:
-        """获取当前流路路径描述"""
+        """获取当前流路路径描述 🌊"""
         current_port = self.get_current_port()
         if self._current_position == 0:
-            return f"Transfer pump connected (position {self._current_position})"
+            flow_path = f"🚰 转移泵已连接 (位置 {self._current_position})"
         else:
-            return f"Port {self._current_position} connected ({current_port})"
+            flow_path = f"🔌 端口 {self._current_position} 已连接 ({current_port})"
+        
+        self.logger.debug(f"🌊 当前流路: {flow_path}")
+        return flow_path
 
     def get_info(self) -> dict:
-        """获取阀门详细信息"""
-        return {
+        """获取阀门详细信息 📊"""
+        info = {
             "port": self.port,
             "max_positions": self.max_positions,
             "total_positions": self.total_positions,
@@ -188,18 +246,25 @@ class VirtualMultiwayValve:
             "flow_path": self.get_flow_path(),
             "position_map": self.position_map
         }
+        
+        self.logger.debug(f"📊 阀门信息: 位置={self._current_position}, 状态={self._status}, 端口={self.get_current_port()}")
+        return info
 
     def __str__(self):
-        return f"VirtualMultiwayValve(Position: {self._current_position}/{self.max_positions}, Port: {self.get_current_port()}, Status: {self._status})"
+        current_port = self.get_current_port()
+        status_emoji = "✅" if self._status == "Idle" else "🔄" if self._status == "Busy" else "❌"
+        
+        return f"🔄 VirtualMultiwayValve({status_emoji} 位置: {self._current_position}/{self.max_positions}, 端口: {current_port}, 状态: {self._status})"
 
     def set_valve_position(self, command: Union[int, str]):
         """
-        设置阀门位置 - 兼容pump_protocol调用
+        设置阀门位置 - 兼容pump_protocol调用 🎯
         这是set_position的别名方法，用于兼容pump_protocol.py
         
         Args:
             command: 目标位置 (0-8) 或位置字符串
         """
+        self.logger.debug(f"🎯 兼容性调用: set_valve_position({command})")
         return self.set_position(command)
 
 
@@ -207,25 +272,35 @@ class VirtualMultiwayValve:
 if __name__ == "__main__":
     valve = VirtualMultiwayValve()
     
-    print("=== 虚拟九通阀门测试 ===")
-    print(f"初始状态: {valve}")
-    print(f"当前流路: {valve.get_flow_path()}")
+    print("🔄 === 虚拟九通阀门测试 === ✨")
+    print(f"🏠 初始状态: {valve}")
+    print(f"🌊 当前流路: {valve.get_flow_path()}")
     
     # 切换到试剂瓶1（1号位）
-    print(f"\n切换到1号位: {valve.set_position(1)}")
-    print(f"当前状态: {valve}")
+    print(f"\n🔌 切换到1号位: {valve.set_position(1)}")
+    print(f"📍 当前状态: {valve}")
     
     # 切换到transfer pump位置（0号位）
-    print(f"\n切换到pump位置: {valve.set_to_pump_position()}")
-    print(f"当前状态: {valve}")
+    print(f"\n🚰 切换到pump位置: {valve.set_to_pump_position()}")
+    print(f"📍 当前状态: {valve}")
     
     # 切换到试剂瓶2（2号位）
-    print(f"\n切换到2号位: {valve.set_to_port(2)}")
-    print(f"当前状态: {valve}")
+    print(f"\n🔌 切换到2号位: {valve.set_to_port(2)}")
+    print(f"📍 当前状态: {valve}")
     
     # 显示所有可用位置
-    print(f"\n可用位置: {valve.get_available_positions()}")
-    print(f"端口映射: {valve.get_available_ports()}")
+    print(f"\n📋 可用位置: {valve.get_available_positions()}")
+    print(f"🗺️ 端口映射: {valve.get_available_ports()}")
     
     # 获取详细信息
-    print(f"\n详细信息: {valve.get_info()}")
+    print(f"\n📊 详细信息: {valve.get_info()}")
+    
+    # 测试切换功能
+    print(f"\n🔄 智能切换测试:")
+    print(f"当前位置: {valve._current_position}")
+    print(f"切换结果: {valve.switch_between_pump_and_port(3)}")
+    print(f"新位置: {valve._current_position}")
+    
+    # 重置测试
+    print(f"\n🔄 重置测试: {valve.reset()}")
+    print(f"📍 重置后状态: {valve}")