import time import threading from datetime import datetime, timedelta class MockSeparator: def __init__(self, port: str = "MOCK"): self.port = port # 基本状态属性 self._status: str = "Idle" # 当前总体状态 self._valve_state: str = "Closed" # 阀门状态：Open 或 Closed self._settling_time: float = 0.0 # 静置时间（秒） # 搅拌相关属性 self._shake_time: float = 0.0 # 剩余摇摆时间（秒） self._shake_status: str = "Not Shaking" # 摇摆状态 # 用于后台模拟 shake 动作 self._operation_thread = None self._thread_lock = threading.Lock() self._running = False # Separate action 相关属性 self._current_device: str = "MockSeparator1" self._purpose: str = "" # wash or extract self._product_phase: str = "" # top or bottom self._from_vessel: str = "" self._separation_vessel: str = "" self._to_vessel: str = "" self._waste_phase_to_vessel: str = "" self._solvent: str = "" self._solvent_volume: float = 0.0 self._through: str = "" self._repeats: int = 1 self._stir_time: float = 0.0 self._stir_speed: float = 0.0 self._time_spent = timedelta() self._time_remaining = timedelta() self._start_time = datetime.now() # 添加这一行 @property def current_device(self) -> str: return self._current_device @property def purpose(self) -> str: return self._purpose @property def valve_state(self) -> str: return self._valve_state @property def settling_time(self) -> float: return self._settling_time @property def status(self) -> str: return self._status @property def shake_time(self) -> float: with self._thread_lock: return self._shake_time @property def shake_status(self) -> str: with self._thread_lock: return self._shake_status @property def product_phase(self) -> str: return self._product_phase @property def from_vessel(self) -> str: return self._from_vessel @property def separation_vessel(self) -> str: return self._separation_vessel @property def to_vessel(self) -> str: return self._to_vessel @property def waste_phase_to_vessel(self) -> str: return self._waste_phase_to_vessel @property def solvent(self) -> str: return self._solvent @property def solvent_volume(self) -> float: return self._solvent_volume @property def through(self) -> str: return self._through @property def repeats(self) -> int: return self._repeats @property def stir_time(self) -> float: return self._stir_time @property def stir_speed(self) -> float: return self._stir_speed @property def time_spent(self) -> float: if self._running: self._time_spent = datetime.now() - self._start_time return self._time_spent.total_seconds() @property def time_remaining(self) -> float: if self._running: elapsed = (datetime.now() - self._start_time).total_seconds() total_time = (self._stir_time + self._settling_time + 10) * self._repeats remain = max(0, total_time - elapsed) self._time_remaining = timedelta(seconds=remain) return self._time_remaining.total_seconds() 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 = 0.0, through: str = "", repeats: int = 1, stir_time: float = 0.0, stir_speed: float = 0.0, settling_time: float = 60.0) -> dict: """ 执行分离操作 """ with self._thread_lock: # 检查是否已经在运行 if self._running: return { "success": False, "status": "Error: Operation already in progress" } # 必填参数验证 if not all([from_vessel, separation_vessel, to_vessel]): self._status = "Error: Missing required vessel parameters" return {"success": False} # 验证参数 if purpose not in ["wash", "extract"]: self._status = "Error: Invalid purpose" return {"success": False} if product_phase not in ["top", "bottom"]: self._status = "Error: Invalid product phase" return {"success": False} # 数值参数验证 try: solvent_volume = float(solvent_volume) repeats = int(repeats) stir_time = float(stir_time) stir_speed = float(stir_speed) settling_time = float(settling_time) except ValueError: self._status = "Error: Invalid numeric parameters" return {"success": False} # 设置参数 self._purpose = purpose self._product_phase = product_phase self._from_vessel = from_vessel self._separation_vessel = separation_vessel self._to_vessel = to_vessel self._waste_phase_to_vessel = waste_phase_to_vessel self._solvent = solvent self._solvent_volume = float(solvent_volume) self._through = through self._repeats = int(repeats) self._stir_time = float(stir_time) self._stir_speed = float(stir_speed) self._settling_time = float(settling_time) # 重置计时器 self._start_time = datetime.now() self._time_spent = timedelta() total_time = (self._stir_time + self._settling_time + 10) * self._repeats self._time_remaining = timedelta(seconds=total_time) # 启动分离操作 self._status = "Starting Separation" self._running = True # 在锁内创建和启动线程 self._operation_thread = threading.Thread(target=self._operation_loop) self._operation_thread.daemon = True self._operation_thread.start() # 等待确认操作已经开始 time.sleep(0.1) # 短暂等待确保操作线程已启动 return { "success": True, "status": self._status, "current_device": self._current_device, "time_spent": self._time_spent.total_seconds(), "time_remaining": self._time_remaining.total_seconds() } def shake(self, shake_time: float) -> str: """ 模拟 shake（搅拌）操作： - 进入 "Shaking" 状态，倒计时 shake_time 秒 - shake 结束后，进入 "Settling" 状态，静置时间固定为 5 秒 - 最后恢复为 Idle """ try: shake_time = float(shake_time) except ValueError: self._status = "Error: Invalid shake time" return "Error" with self._thread_lock: self._status = "Shaking" self._settling_time = 0.0 self._shake_time = shake_time self._shake_status = "Shaking" def _run_shake(): remaining = shake_time while remaining > 0: time.sleep(1) remaining -= 1 with self._thread_lock: self._shake_time = remaining with self._thread_lock: self._status = "Settling" self._settling_time = 60.0 # 固定静置时间为60秒 self._shake_status = "Settling" while True: with self._thread_lock: if self._settling_time <= 0: self._status = "Idle" self._shake_status = "Idle" break time.sleep(1) with self._thread_lock: self._settling_time = max(0.0, self._settling_time - 1) self._operation_thread = threading.Thread(target=_run_shake) self._operation_thread.daemon = True self._operation_thread.start() return "Success" def set_valve(self, command: str) -> str: """ 阀门控制命令：传入 "open" 或 "close" """ command = command.lower() if command == "open": self._valve_state = "Open" self._status = "Valve Opened" elif command == "close": self._valve_state = "Closed" self._status = "Valve Closed" else: self._status = "Error: Invalid valve command" return "Error" return "Success" def _operation_loop(self): """分离操作主循环""" try: current_repeat = 1 # 立即更新状态，确保不会停留在Starting Separation with self._thread_lock: self._status = f"Separation Cycle {current_repeat}/{self._repeats}" while self._running and current_repeat <= self._repeats: # 第一步：搅拌 if self._stir_time > 0: with self._thread_lock: self._status = f"Stirring (Repeat {current_repeat}/{self._repeats})" remaining_stir = self._stir_time while remaining_stir > 0 and self._running: time.sleep(1) remaining_stir -= 1 # 第二步：静置 if self._settling_time > 0: with self._thread_lock: self._status = f"Settling (Repeat {current_repeat}/{self._repeats})" remaining_settle = self._settling_time while remaining_settle > 0 and self._running: time.sleep(1) remaining_settle -= 1 # 第三步：打开阀门排出 with self._thread_lock: self._valve_state = "Open" self._status = f"Draining (Repeat {current_repeat}/{self._repeats})" # 模拟排出时间（5秒） time.sleep(10) # 关闭阀门 with self._thread_lock: self._valve_state = "Closed" # 检查是否继续下一次重复 if current_repeat < self._repeats: current_repeat += 1 else: with self._thread_lock: self._status = "Separation Complete" break except Exception as e: with self._thread_lock: self._status = f"Error in separation: {str(e)}" finally: with self._thread_lock: self._running = False self._valve_state = "Closed" if self._status == "Starting Separation": self._status = "Error: Operation failed to start" elif self._status != "Separation Complete": self._status = "Stopped" def stop_operations(self) -> str: """停止任何正在执行的操作""" with self._thread_lock: self._running = False if self._operation_thread and self._operation_thread.is_alive(): self._operation_thread.join(timeout=1.0) self._operation_thread = None self._settling_time = 0.0 self._status = "Idle" self._shake_status = "Idle" self._shake_time = 0.0 self._time_remaining = timedelta() return "Success" def get_status_info(self) -> dict: """获取当前设备状态信息""" with self._thread_lock: current_time = datetime.now() if self._start_time: self._time_spent = current_time - self._start_time return { "status": self._status, "valve_state": self._valve_state, "settling_time": self._settling_time, "shake_time": self._shake_time, "shake_status": self._shake_status, "current_device": self._current_device, "purpose": self._purpose, "product_phase": self._product_phase, "from_vessel": self._from_vessel, "separation_vessel": self._separation_vessel, "to_vessel": self._to_vessel, "waste_phase_to_vessel": self._waste_phase_to_vessel, "solvent": self._solvent, "solvent_volume": self._solvent_volume, "through": self._through, "repeats": self._repeats, "stir_time": self._stir_time, "stir_speed": self._stir_speed, "time_spent": self._time_spent.total_seconds(), "time_remaining": self._time_remaining.total_seconds() } # 主函数用于测试 if __name__ == "__main__": separator = MockSeparator() print("启动简单版分离器测试...") print("初始状态:", separator.get_status_info()) # 触发 shake 操作，模拟 10 秒的搅拌 print("执行 shake 操作...") print(separator.shake(10.0)) # 循环显示状态变化 for i in range(20): time.sleep(1) info = separator.get_status_info() print( f"第{i+1}秒: 状态={info['status']}, 静置时间={info['settling_time']:.1f}秒, " f"阀门状态={info['valve_state']}, shake_time={info['shake_time']:.1f}, " f"shake_status={info['shake_status']}" ) # 模拟打开阀门 print("打开阀门...", separator.set_valve("open")) print("最终状态:", separator.get_status_info())