add virtual_separator virtual_rotavap

fix transfer_pump

unilabos/devices/virtual/virtual_rotavap.py

@@ -0,0 +1,172 @@
+import asyncio
+import logging
+from typing import Dict, Any, Optional
+
+
+class VirtualRotavap:
+    """Virtual rotary evaporator device for EvaporateProtocol testing"""
+
+    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
+        # 处理可能的不同调用方式
+        if device_id is None and "id" in kwargs:
+            device_id = kwargs.pop("id")
+        if config is None and "config" in kwargs:
+            config = kwargs.pop("config")
+
+        # 设置默认值
+        self.device_id = device_id or "unknown_rotavap"
+        self.config = config or {}
+
+        self.logger = logging.getLogger(f"VirtualRotavap.{self.device_id}")
+        self.data = {}
+
+        # 添加调试信息
+        print(f"=== VirtualRotavap {self.device_id} is being created! ===")
+        print(f"=== Config: {self.config} ===")
+        print(f"=== Kwargs: {kwargs} ===")
+
+        # 从config或kwargs中获取配置参数
+        self.port = self.config.get("port") or kwargs.get("port", "VIRTUAL")
+        self._max_temp = self.config.get("max_temp") or kwargs.get("max_temp", 180.0)
+        self._max_rotation_speed = self.config.get("max_rotation_speed") or kwargs.get("max_rotation_speed", 280.0)
+
+        # 处理其他kwargs参数，但跳过已知的配置参数
+        skip_keys = {"port", "max_temp", "max_rotation_speed"}
+        for key, value in kwargs.items():
+            if key not in skip_keys and not hasattr(self, key):
+                setattr(self, key, value)
+
+    async def initialize(self) -> bool:
+        """Initialize virtual rotary evaporator"""
+        print(f"=== VirtualRotavap {self.device_id} initialize() called! ===")
+        self.logger.info(f"Initializing virtual rotary evaporator {self.device_id}")
+        self.data.update(
+            {
+                "status": "Idle",
+                "rotavap_state": "Ready",
+                "current_temp": 25.0,
+                "target_temp": 25.0,
+                "max_temp": self._max_temp,
+                "rotation_speed": 0.0,
+                "max_rotation_speed": self._max_rotation_speed,
+                "vacuum_pressure": 1.0,  # atmospheric pressure
+                "evaporated_volume": 0.0,
+                "progress": 0.0,
+                "message": "",
+            }
+        )
+        return True
+
+    async def cleanup(self) -> bool:
+        """Cleanup virtual rotary evaporator"""
+        self.logger.info(f"Cleaning up virtual rotary evaporator {self.device_id}")
+        return True
+
+    async def evaporate(
+        self, vessel: str, pressure: float = 0.5, temp: float = 60.0, time: float = 300.0, stir_speed: float = 100.0
+    ) -> bool:
+        """Execute evaporate action - matches Evaporate action"""
+        self.logger.info(f"Evaporate: vessel={vessel}, pressure={pressure}, temp={temp}, time={time}")
+
+        # 验证参数
+        if temp > self._max_temp:
+            self.logger.error(f"Temperature {temp} exceeds maximum {self._max_temp}")
+            self.data["message"] = f"温度 {temp} 超过最大值 {self._max_temp}"
+            return False
+
+        if stir_speed > self._max_rotation_speed:
+            self.logger.error(f"Rotation speed {stir_speed} exceeds maximum {self._max_rotation_speed}")
+            self.data["message"] = f"旋转速度 {stir_speed} 超过最大值 {self._max_rotation_speed}"
+            return False
+
+        if pressure < 0.01 or pressure > 1.0:
+            self.logger.error(f"Pressure {pressure} bar is out of valid range (0.01-1.0)")
+            self.data["message"] = f"真空度 {pressure} bar 超出有效范围 (0.01-1.0)"
+            return False
+
+        # 开始蒸发
+        self.data.update(
+            {
+                "status": "Running",
+                "rotavap_state": "Evaporating",
+                "target_temp": temp,
+                "current_temp": temp,
+                "rotation_speed": stir_speed,
+                "vacuum_pressure": pressure,
+                "vessel": vessel,
+                "target_time": time,
+                "progress": 0.0,
+                "message": f"正在蒸发: {vessel}",
+            }
+        )
+
+        # 模拟蒸发过程
+        simulation_time = min(time / 60.0, 10.0)  # 最多模拟10秒
+        for progress in range(0, 101, 10):
+            await asyncio.sleep(simulation_time / 10)
+            self.data["progress"] = progress
+            self.data["evaporated_volume"] = progress * 0.5  # 假设最多蒸发50mL
+
+        # 蒸发完成
+        evaporated_vol = 50.0  # 假设蒸发了50mL
+        self.data.update(
+            {
+                "status": "Idle",
+                "rotavap_state": "Ready",
+                "current_temp": 25.0,
+                "target_temp": 25.0,
+                "rotation_speed": 0.0,
+                "vacuum_pressure": 1.0,
+                "evaporated_volume": evaporated_vol,
+                "progress": 100.0,
+                "message": f"蒸发完成: {evaporated_vol}mL",
+            }
+        )
+
+        self.logger.info(f"Evaporation completed: {evaporated_vol}mL from {vessel}")
+        return True
+
+    # 状态属性
+    @property
+    def status(self) -> str:
+        return self.data.get("status", "Unknown")
+
+    @property
+    def rotavap_state(self) -> str:
+        return self.data.get("rotavap_state", "Unknown")
+
+    @property
+    def current_temp(self) -> float:
+        return self.data.get("current_temp", 25.0)
+
+    @property
+    def target_temp(self) -> float:
+        return self.data.get("target_temp", 25.0)
+
+    @property
+    def max_temp(self) -> float:
+        return self.data.get("max_temp", self._max_temp)
+
+    @property
+    def rotation_speed(self) -> float:
+        return self.data.get("rotation_speed", 0.0)
+
+    @property
+    def max_rotation_speed(self) -> float:
+        return self.data.get("max_rotation_speed", self._max_rotation_speed)
+
+    @property
+    def vacuum_pressure(self) -> float:
+        return self.data.get("vacuum_pressure", 1.0)
+
+    @property
+    def evaporated_volume(self) -> float:
+        return self.data.get("evaporated_volume", 0.0)
+
+    @property
+    def progress(self) -> float:
+        return self.data.get("progress", 0.0)
+
+    @property
+    def message(self) -> str:
+        return self.data.get("message", "")

unilabos/devices/virtual/virtual_separator.py

@@ -0,0 +1,184 @@
+import asyncio
+import logging
+from typing import Dict, Any, Optional
+
+
+class VirtualSeparator:
+    """Virtual separator device for SeparateProtocol testing"""
+
+    def __init__(self, device_id: Optional[str] = None, config: Optional[Dict[str, Any]] = None, **kwargs):
+        # 处理可能的不同调用方式
+        if device_id is None and "id" in kwargs:
+            device_id = kwargs.pop("id")
+        if config is None and "config" in kwargs:
+            config = kwargs.pop("config")
+
+        # 设置默认值
+        self.device_id = device_id or "unknown_separator"
+        self.config = config or {}
+
+        self.logger = logging.getLogger(f"VirtualSeparator.{self.device_id}")
+        self.data = {}
+
+        # 添加调试信息
+        print(f"=== VirtualSeparator {self.device_id} is being created! ===")
+        print(f"=== Config: {self.config} ===")
+        print(f"=== Kwargs: {kwargs} ===")
+
+        # 从config或kwargs中获取配置参数
+        self.port = self.config.get("port") or kwargs.get("port", "VIRTUAL")
+        self._volume = self.config.get("volume") or kwargs.get("volume", 250.0)
+        self._has_phases = self.config.get("has_phases") or kwargs.get("has_phases", True)
+
+        # 处理其他kwargs参数，但跳过已知的配置参数
+        skip_keys = {"port", "volume", "has_phases"}
+        for key, value in kwargs.items():
+            if key not in skip_keys and not hasattr(self, key):
+                setattr(self, key, value)
+
+    async def initialize(self) -> bool:
+        """Initialize virtual separator"""
+        print(f"=== VirtualSeparator {self.device_id} initialize() called! ===")
+        self.logger.info(f"Initializing virtual separator {self.device_id}")
+        self.data.update(
+            {
+                "status": "Ready",
+                "separator_state": "Ready",
+                "volume": self._volume,
+                "has_phases": self._has_phases,
+                "phase_separation": False,
+                "stir_speed": 0.0,
+                "settling_time": 0.0,
+                "progress": 0.0,
+                "message": "",
+            }
+        )
+        return True
+
+    async def cleanup(self) -> bool:
+        """Cleanup virtual separator"""
+        self.logger.info(f"Cleaning up virtual separator {self.device_id}")
+        return True
+
+    async def separate(
+        self,
+        purpose: str,
+        product_phase: str,
+        from_vessel: str,
+        separation_vessel: str,
+        to_vessel: str,
+        waste_phase_to_vessel: str = "",
+        solvent: str = "",
+        solvent_volume: float = 50.0,
+        through: str = "",
+        repeats: int = 1,
+        stir_time: float = 30.0,
+        stir_speed: float = 300.0,
+        settling_time: float = 300.0,
+    ) -> bool:
+        """Execute separate action - matches Separate action"""
+        self.logger.info(f"Separate: purpose={purpose}, product_phase={product_phase}, from_vessel={from_vessel}")
+
+        # 验证参数
+        if product_phase not in ["top", "bottom"]:
+            self.logger.error(f"Invalid product_phase {product_phase}, must be 'top' or 'bottom'")
+            self.data["message"] = f"产物相位 {product_phase} 无效，必须是 'top' 或 'bottom'"
+            return False
+
+        if purpose not in ["wash", "extract"]:
+            self.logger.error(f"Invalid purpose {purpose}, must be 'wash' or 'extract'")
+            self.data["message"] = f"分离目的 {purpose} 无效，必须是 'wash' 或 'extract'"
+            return False
+
+        # 开始分离
+        self.data.update(
+            {
+                "status": "Running",
+                "separator_state": "Separating",
+                "purpose": purpose,
+                "product_phase": product_phase,
+                "from_vessel": from_vessel,
+                "separation_vessel": separation_vessel,
+                "to_vessel": to_vessel,
+                "waste_phase_to_vessel": waste_phase_to_vessel,
+                "solvent": solvent,
+                "solvent_volume": solvent_volume,
+                "repeats": repeats,
+                "stir_speed": stir_speed,
+                "settling_time": settling_time,
+                "phase_separation": True,
+                "progress": 0.0,
+                "message": f"正在分离: {from_vessel} -> {to_vessel}",
+            }
+        )
+
+        # 模拟分离过程
+        total_time = (stir_time + settling_time) * repeats
+        simulation_time = min(total_time / 60.0, 15.0)  # 最多模拟15秒
+
+        for repeat in range(repeats):
+            # 搅拌阶段
+            for progress in range(0, 51, 10):
+                await asyncio.sleep(simulation_time / (repeats * 10))
+                overall_progress = ((repeat * 100) + (progress * 0.5)) / repeats
+                self.data["progress"] = overall_progress
+                self.data["message"] = f"第{repeat+1}次分离 - 搅拌中 ({progress}%)"
+
+            # 静置分相阶段
+            for progress in range(50, 101, 10):
+                await asyncio.sleep(simulation_time / (repeats * 10))
+                overall_progress = ((repeat * 100) + (progress * 0.5)) / repeats
+                self.data["progress"] = overall_progress
+                self.data["message"] = f"第{repeat+1}次分离 - 静置分相中 ({progress}%)"
+
+        # 分离完成
+        self.data.update(
+            {
+                "status": "Ready",
+                "separator_state": "Ready",
+                "phase_separation": False,
+                "stir_speed": 0.0,
+                "progress": 100.0,
+                "message": f"分离完成: {repeats}次分离操作",
+            }
+        )
+
+        self.logger.info(f"Separation completed: {repeats} cycles from {from_vessel} to {to_vessel}")
+        return True
+
+    # 状态属性
+    @property
+    def status(self) -> str:
+        return self.data.get("status", "Unknown")
+
+    @property
+    def separator_state(self) -> str:
+        return self.data.get("separator_state", "Unknown")
+
+    @property
+    def volume(self) -> float:
+        return self.data.get("volume", self._volume)
+
+    @property
+    def has_phases(self) -> bool:
+        return self.data.get("has_phases", self._has_phases)
+
+    @property
+    def phase_separation(self) -> bool:
+        return self.data.get("phase_separation", False)
+
+    @property
+    def stir_speed(self) -> float:
+        return self.data.get("stir_speed", 0.0)
+
+    @property
+    def settling_time(self) -> float:
+        return self.data.get("settling_time", 0.0)
+
+    @property
+    def progress(self) -> float:
+        return self.data.get("progress", 0.0)
+
+    @property
+    def message(self) -> str:
+        return self.data.get("message", "")

unilabos/devices/virtual/virtual_transferpump.py

@@ -14,9 +14,10 @@ class VirtualPumpMode(Enum):
 class VirtualPump:
     """虚拟泵类 - 模拟泵的基本功能，无需实际硬件"""
     
-    def __init__(self, device_id: str = None, max_volume: float = 25.0, mode: VirtualPumpMode = VirtualPumpMode.Normal):
+    def __init__(self, device_id: str = None, max_volume: float = 25.0, mode: VirtualPumpMode = VirtualPumpMode.Normal, transfer_rate=0):
         self.device_id = device_id or "virtual_pump"
         self.max_volume = max_volume
+        self._transfer_rate = transfer_rate
         self.mode = mode
         
         # 状态变量
@@ -24,7 +25,7 @@ class VirtualPump:
         self._position = 0.0  # 当前柱塞位置 (ml)
         self._max_velocity = 5.0  # 默认最大速度 (ml/s)
         self._current_volume = 0.0  # 当前注射器中的体积
-        
+
         self.logger = logging.getLogger(f"VirtualPump.{self.device_id}")
         
     async def initialize(self) -> bool:
@@ -60,6 +61,10 @@ class VirtualPump:
     def max_velocity(self) -> float:
         return self._max_velocity
     
+    @property
+    def transfer_rate(self) -> float:
+        return self._transfer_rate
+
     def set_max_velocity(self, velocity: float):
         """设置最大速度 (ml/s)"""
         self._max_velocity = max(0.1, min(50.0, velocity))  # 限制在合理范围内