3d sim (#97)

* 修改lh的json启动

* 修改lh的json启动

* 修改backend，做成sim的通用backend

* 修改yaml的地址，3D模型适配网页生产环境

* 添加laiyu硬件连接

* 修改移液枪的状态判断方法，

修改移液枪的状态判断方法，
添加三轴的表定点与零点之间的转换
添加三轴真实移动的backend

* 修改laiyu移液站

简化移动方法，
取消软件限制位置，
修改当值使用Z轴时也需要重新复位Z轴的问题

* 更新lh以及laiyu workshop

1,现在可以直接通过修改backend，适配其他的移液站，主类依旧使用LiquidHandler，不用重新编写

2,修改枪头判断标准，使用枪头自身判断而不是类的判断，

3,将归零参数用毫米计算，方便手动调整，

4,修改归零方式，上电使用机械归零，确定机械零点，手动归零设置工作区域零点方便计算，二者互不干涉

* 修改枪头动作

* 修改虚拟仿真方法

---------

Co-authored-by: zhangshixiang <@zhangshixiang>
Co-authored-by: Junhan Chang <changjh@dp.tech>

unilabos/devices/liquid_handling/laiyu/backend/__init__.py

@@ -0,0 +1,9 @@
+"""
+LaiYu液体处理设备后端模块
+
+提供设备后端接口和实现
+"""
+
+from .laiyu_backend import LaiYuLiquidBackend, create_laiyu_backend
+
+__all__ = ['LaiYuLiquidBackend', 'create_laiyu_backend']

unilabos/devices/liquid_handling/laiyu/backend/laiyu_backend.py

@@ -0,0 +1,334 @@
+"""
+LaiYu液体处理设备后端实现
+
+提供设备的后端接口和控制逻辑
+"""
+
+import logging
+from typing import Dict, Any, Optional, List
+from abc import ABC, abstractmethod
+
+# 尝试导入PyLabRobot后端
+try:
+    from pylabrobot.liquid_handling.backends import LiquidHandlerBackend
+    PYLABROBOT_AVAILABLE = True
+except ImportError:
+    PYLABROBOT_AVAILABLE = False
+    # 创建模拟后端基类
+    class LiquidHandlerBackend:
+        def __init__(self, name: str):
+            self.name = name
+            self.is_connected = False
+        
+        def connect(self):
+            """连接设备"""
+            pass
+        
+        def disconnect(self):
+            """断开连接"""
+            pass
+
+
+class LaiYuLiquidBackend(LiquidHandlerBackend):
+    """LaiYu液体处理设备后端"""
+    
+    def __init__(self, name: str = "LaiYu_Liquid_Backend"):
+        """
+        初始化LaiYu液体处理设备后端
+        
+        Args:
+            name: 后端名称
+        """
+        if PYLABROBOT_AVAILABLE:
+            # PyLabRobot 的 LiquidHandlerBackend 不接受参数
+            super().__init__()
+        else:
+            # 模拟版本接受 name 参数
+            super().__init__(name)
+        
+        self.name = name
+        self.logger = logging.getLogger(__name__)
+        self.is_connected = False
+        self.device_info = {
+            "name": "LaiYu液体处理设备",
+            "version": "1.0.0",
+            "manufacturer": "LaiYu",
+            "model": "LaiYu_Liquid_Handler"
+        }
+    
+    def connect(self) -> bool:
+        """
+        连接到LaiYu液体处理设备
+        
+        Returns:
+            bool: 连接是否成功
+        """
+        try:
+            self.logger.info("正在连接到LaiYu液体处理设备...")
+            # 这里应该实现实际的设备连接逻辑
+            # 目前返回模拟连接成功
+            self.is_connected = True
+            self.logger.info("成功连接到LaiYu液体处理设备")
+            return True
+        except Exception as e:
+            self.logger.error(f"连接LaiYu液体处理设备失败: {e}")
+            self.is_connected = False
+            return False
+    
+    def disconnect(self) -> bool:
+        """
+        断开与LaiYu液体处理设备的连接
+        
+        Returns:
+            bool: 断开连接是否成功
+        """
+        try:
+            self.logger.info("正在断开与LaiYu液体处理设备的连接...")
+            # 这里应该实现实际的设备断开连接逻辑
+            self.is_connected = False
+            self.logger.info("成功断开与LaiYu液体处理设备的连接")
+            return True
+        except Exception as e:
+            self.logger.error(f"断开LaiYu液体处理设备连接失败: {e}")
+            return False
+    
+    def is_device_connected(self) -> bool:
+        """
+        检查设备是否已连接
+        
+        Returns:
+            bool: 设备是否已连接
+        """
+        return self.is_connected
+    
+    def get_device_info(self) -> Dict[str, Any]:
+        """
+        获取设备信息
+        
+        Returns:
+            Dict[str, Any]: 设备信息字典
+        """
+        return self.device_info.copy()
+    
+    def home_device(self) -> bool:
+        """
+        设备归零操作
+        
+        Returns:
+            bool: 归零是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行归零操作")
+            return False
+        
+        try:
+            self.logger.info("正在执行设备归零操作...")
+            # 这里应该实现实际的设备归零逻辑
+            self.logger.info("设备归零操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"设备归零操作失败: {e}")
+            return False
+    
+    def aspirate(self, volume: float, location: Dict[str, Any]) -> bool:
+        """
+        吸液操作
+        
+        Args:
+            volume: 吸液体积 (微升)
+            location: 吸液位置信息
+            
+        Returns:
+            bool: 吸液是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行吸液操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行吸液操作: 体积={volume}μL, 位置={location}")
+            # 这里应该实现实际的吸液逻辑
+            self.logger.info("吸液操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"吸液操作失败: {e}")
+            return False
+    
+    def dispense(self, volume: float, location: Dict[str, Any]) -> bool:
+        """
+        排液操作
+        
+        Args:
+            volume: 排液体积 (微升)
+            location: 排液位置信息
+            
+        Returns:
+            bool: 排液是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行排液操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行排液操作: 体积={volume}μL, 位置={location}")
+            # 这里应该实现实际的排液逻辑
+            self.logger.info("排液操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"排液操作失败: {e}")
+            return False
+    
+    def pick_up_tip(self, location: Dict[str, Any]) -> bool:
+        """
+        取枪头操作
+        
+        Args:
+            location: 枪头位置信息
+            
+        Returns:
+            bool: 取枪头是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行取枪头操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行取枪头操作: 位置={location}")
+            # 这里应该实现实际的取枪头逻辑
+            self.logger.info("取枪头操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"取枪头操作失败: {e}")
+            return False
+    
+    def drop_tip(self, location: Dict[str, Any]) -> bool:
+        """
+        丢弃枪头操作
+        
+        Args:
+            location: 丢弃位置信息
+            
+        Returns:
+            bool: 丢弃枪头是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行丢弃枪头操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在执行丢弃枪头操作: 位置={location}")
+            # 这里应该实现实际的丢弃枪头逻辑
+            self.logger.info("丢弃枪头操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"丢弃枪头操作失败: {e}")
+            return False
+    
+    def move_to(self, location: Dict[str, Any]) -> bool:
+        """
+        移动到指定位置
+        
+        Args:
+            location: 目标位置信息
+            
+        Returns:
+            bool: 移动是否成功
+        """
+        if not self.is_connected:
+            self.logger.error("设备未连接，无法执行移动操作")
+            return False
+        
+        try:
+            self.logger.info(f"正在移动到位置: {location}")
+            # 这里应该实现实际的移动逻辑
+            self.logger.info("移动操作完成")
+            return True
+        except Exception as e:
+            self.logger.error(f"移动操作失败: {e}")
+            return False
+    
+    def get_status(self) -> Dict[str, Any]:
+        """
+        获取设备状态
+        
+        Returns:
+            Dict[str, Any]: 设备状态信息
+        """
+        return {
+            "connected": self.is_connected,
+            "device_info": self.device_info,
+            "status": "ready" if self.is_connected else "disconnected"
+        }
+    
+    # PyLabRobot 抽象方法实现
+    def stop(self):
+        """停止所有操作"""
+        self.logger.info("停止所有操作")
+        pass
+    
+    @property
+    def num_channels(self) -> int:
+        """返回通道数量"""
+        return 1  # 单通道移液器
+    
+    def can_pick_up_tip(self, tip_rack, tip_position) -> bool:
+        """检查是否可以拾取吸头"""
+        return True  # 简化实现，总是返回True
+    
+    def pick_up_tips(self, tip_rack, tip_positions):
+        """拾取多个吸头"""
+        self.logger.info(f"拾取吸头: {tip_positions}")
+        pass
+    
+    def drop_tips(self, tip_rack, tip_positions):
+        """丢弃多个吸头"""
+        self.logger.info(f"丢弃吸头: {tip_positions}")
+        pass
+    
+    def pick_up_tips96(self, tip_rack):
+        """拾取96个吸头"""
+        self.logger.info("拾取96个吸头")
+        pass
+    
+    def drop_tips96(self, tip_rack):
+        """丢弃96个吸头"""
+        self.logger.info("丢弃96个吸头")
+        pass
+    
+    def aspirate96(self, volume, plate, well_positions):
+        """96通道吸液"""
+        self.logger.info(f"96通道吸液: 体积={volume}")
+        pass
+    
+    def dispense96(self, volume, plate, well_positions):
+        """96通道排液"""
+        self.logger.info(f"96通道排液: 体积={volume}")
+        pass
+    
+    def pick_up_resource(self, resource, location):
+        """拾取资源"""
+        self.logger.info(f"拾取资源: {resource}")
+        pass
+    
+    def drop_resource(self, resource, location):
+        """放置资源"""
+        self.logger.info(f"放置资源: {resource}")
+        pass
+    
+    def move_picked_up_resource(self, resource, location):
+        """移动已拾取的资源"""
+        self.logger.info(f"移动资源: {resource} 到 {location}")
+        pass
+
+
+def create_laiyu_backend(name: str = "LaiYu_Liquid_Backend") -> LaiYuLiquidBackend:
+    """
+    创建LaiYu液体处理设备后端实例
+    
+    Args:
+        name: 后端名称
+        
+    Returns:
+        LaiYuLiquidBackend: 后端实例
+    """
+    return LaiYuLiquidBackend(name)

unilabos/devices/liquid_handling/laiyu/backend/laiyu_v_backend.py

@@ -0,0 +1,385 @@
+      
+import json
+from typing import List, Optional, Union
+
+from pylabrobot.liquid_handling.backends.backend import (
+  LiquidHandlerBackend,
+)
+from pylabrobot.liquid_handling.standard import (
+  Drop,
+  DropTipRack,
+  MultiHeadAspirationContainer,
+  MultiHeadAspirationPlate,
+  MultiHeadDispenseContainer,
+  MultiHeadDispensePlate,
+  Pickup,
+  PickupTipRack,
+  ResourceDrop,
+  ResourceMove,
+  ResourcePickup,
+  SingleChannelAspiration,
+  SingleChannelDispense,
+)
+from pylabrobot.resources import Resource, Tip
+
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import JointState
+import time
+from rclpy.action import ActionClient
+from unilabos_msgs.action import SendCmd
+import re
+
+from unilabos.devices.ros_dev.liquid_handler_joint_publisher import JointStatePublisher
+from unilabos.devices.liquid_handling.laiyu.controllers.pipette_controller import PipetteController, TipStatus
+
+
+class UniLiquidHandlerLaiyuBackend(LiquidHandlerBackend):
+  """Chatter box backend for device-free testing. Prints out all operations."""
+
+  _pip_length = 5
+  _vol_length = 8
+  _resource_length = 20
+  _offset_length = 16
+  _flow_rate_length = 10
+  _blowout_length = 10
+  _lld_z_length = 10
+  _kwargs_length = 15
+  _tip_type_length = 12
+  _max_volume_length = 16
+  _fitting_depth_length = 20
+  _tip_length_length = 16
+  # _pickup_method_length = 20
+  _filter_length = 10
+
+  def __init__(self, num_channels: int = 8 , tip_length: float = 0 , total_height: float = 310, port: str = "/dev/ttyUSB0"):
+    """Initialize a chatter box backend."""
+    super().__init__()
+    self._num_channels = num_channels
+    self.tip_length = tip_length
+    self.total_height = total_height
+# rclpy.init()
+    if not rclpy.ok():
+        rclpy.init()
+    self.joint_state_publisher = None
+    self.hardware_interface = PipetteController(port=port)
+
+  async def setup(self):
+    # self.joint_state_publisher = JointStatePublisher()
+    # self.hardware_interface.xyz_controller.connect_device()
+    # self.hardware_interface.xyz_controller.home_all_axes()
+    await super().setup()
+    self.hardware_interface.connect()
+    self.hardware_interface.initialize()
+
+    print("Setting up the liquid handler.")
+
+  async def stop(self):
+    print("Stopping the liquid handler.")
+
+  def serialize(self) -> dict:
+    return {**super().serialize(), "num_channels": self.num_channels}
+
+  def pipette_aspirate(self, volume: float, flow_rate: float):
+
+    self.hardware_interface.pipette.set_max_speed(flow_rate)
+    res = self.hardware_interface.pipette.aspirate(volume=volume)
+    
+    if not res:
+        self.hardware_interface.logger.error("吸取失败，当前体积: {self.hardware_interface.current_volume}")
+        return
+
+    self.hardware_interface.current_volume += volume 
+
+  def pipette_dispense(self, volume: float, flow_rate: float):
+
+    self.hardware_interface.pipette.set_max_speed(flow_rate)
+    res = self.hardware_interface.pipette.dispense(volume=volume)
+    if not res:
+        self.hardware_interface.logger.error("排液失败，当前体积: {self.hardware_interface.current_volume}")
+        return
+    self.hardware_interface.current_volume -= volume
+
+  @property
+  def num_channels(self) -> int:
+    return self._num_channels
+
+  async def assigned_resource_callback(self, resource: Resource):
+    print(f"Resource {resource.name} was assigned to the liquid handler.")
+
+  async def unassigned_resource_callback(self, name: str):
+    print(f"Resource {name} was unassigned from the liquid handler.")
+
+  async def pick_up_tips(self, ops: List[Pickup], use_channels: List[int], **backend_kwargs):
+    print("Picking up tips:")
+    # print(ops.tip)
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'tip type':<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+      f"{'max volume (µL)':<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+      f"{'fitting depth (mm)':<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+      f"{'tip length (mm)':<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+      # f"{'pickup method':<{ChatterboxBackend._pickup_method_length}} "
+      f"{'filter':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+    )
+    # print(header)
+
+    for op, channel in zip(ops, use_channels):
+      offset = f"{round(op.offset.x, 1)},{round(op.offset.y, 1)},{round(op.offset.z, 1)}"
+      row = (
+        f"  p{channel}: "
+        f"{op.resource.name[-30:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{op.tip.__class__.__name__:<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+        f"{op.tip.maximal_volume:<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+        f"{op.tip.fitting_depth:<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+        f"{op.tip.total_tip_length:<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+        # f"{str(op.tip.pickup_method)[-20:]:<{ChatterboxBackend._pickup_method_length}} "
+        f"{'Yes' if op.tip.has_filter else 'No':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+      )
+      # print(row)
+      # print(op.resource.get_absolute_location())
+    
+    self.tip_length = ops[0].tip.total_tip_length
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
+    # print("moving")
+    self.hardware_interface._update_tip_status()
+    if self.hardware_interface.tip_status == TipStatus.TIP_ATTACHED:
+        print("已有枪头，无需重复拾取")
+        return
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z,speed=100)
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height,speed=100)
+    # self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "pick",channels=use_channels)
+    #   goback()
+
+
+
+
+  async def drop_tips(self, ops: List[Drop], use_channels: List[int], **backend_kwargs):
+    print("Dropping tips:")
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'tip type':<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+      f"{'max volume (µL)':<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+      f"{'fitting depth (mm)':<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+      f"{'tip length (mm)':<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+      # f"{'pickup method':<{ChatterboxBackend._pickup_method_length}} "
+      f"{'filter':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+    )
+    # print(header)
+
+    for op, channel in zip(ops, use_channels):
+      offset = f"{round(op.offset.x, 1)},{round(op.offset.y, 1)},{round(op.offset.z, 1)}"
+      row = (
+        f"  p{channel}: "
+        f"{op.resource.name[-30:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{op.tip.__class__.__name__:<{UniLiquidHandlerLaiyuBackend._tip_type_length}} "
+        f"{op.tip.maximal_volume:<{UniLiquidHandlerLaiyuBackend._max_volume_length}} "
+        f"{op.tip.fitting_depth:<{UniLiquidHandlerLaiyuBackend._fitting_depth_length}} "
+        f"{op.tip.total_tip_length:<{UniLiquidHandlerLaiyuBackend._tip_length_length}} "
+        # f"{str(op.tip.pickup_method)[-20:]:<{ChatterboxBackend._pickup_method_length}} "
+        f"{'Yes' if op.tip.has_filter else 'No':<{UniLiquidHandlerLaiyuBackend._filter_length}}"
+      )
+      # print(row)
+
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z -20
+    # print(x, y, z)
+    # print("moving")
+    self.hardware_interface._update_tip_status()
+    if self.hardware_interface.tip_status == TipStatus.NO_TIP:
+        print("无枪头，无需丢弃")
+        return
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z)
+    self.hardware_interface.eject_tip
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height)  
+
+  async def aspirate(
+    self,
+    ops: List[SingleChannelAspiration],
+    use_channels: List[int],
+    **backend_kwargs,
+  ):
+    print("Aspirating:")
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'vol(ul)':<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'flow rate':<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+      f"{'blowout':<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+      f"{'lld_z':<{UniLiquidHandlerLaiyuBackend._lld_z_length}}  "
+      # f"{'liquids':<20}" # TODO: add liquids
+    )
+    for key in backend_kwargs:
+      header += f"{key:<{UniLiquidHandlerLaiyuBackend._kwargs_length}} "[-16:]
+    # print(header)
+
+    for o, p in zip(ops, use_channels):
+      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
+      row = (
+        f"  p{p}: "
+        f"{o.volume:<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+        f"{o.resource.name[-20:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{str(o.flow_rate):<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+        f"{str(o.blow_out_air_volume):<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+        f"{str(o.liquid_height):<{UniLiquidHandlerLaiyuBackend._lld_z_length}} "
+        # f"{o.liquids if o.liquids is not None else 'none'}"
+      )
+      for key, value in backend_kwargs.items():
+        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
+          value = "".join("T" if v else "F" for v in value)
+        if isinstance(value, list):
+          value = "".join(map(str, value))
+        row += f" {value:<15}"
+      # print(row)
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
+    # print(x, y, z)
+    # print("moving")
+
+    # 判断枪头是否存在
+    self.hardware_interface._update_tip_status()
+    if not self.hardware_interface.tip_status == TipStatus.TIP_ATTACHED:
+        print("无枪头，无法吸液")
+        return
+    # 判断吸液量是否超过枪头容量
+    flow_rate = backend_kwargs["flow_rate"] if "flow_rate" in backend_kwargs else 500
+    blow_out_air_volume = backend_kwargs["blow_out_air_volume"] if "blow_out_air_volume" in backend_kwargs else 0
+    if self.hardware_interface.current_volume + ops[0].volume + blow_out_air_volume > self.hardware_interface.max_volume:
+        self.hardware_interface.logger.error(f"吸液量超过枪头容量: {self.hardware_interface.current_volume + ops[0].volume} > {self.hardware_interface.max_volume}")
+        return
+
+    # 移动到吸液位置
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z)
+    self.pipette_aspirate(volume=ops[0].volume, flow_rate=flow_rate)
+
+
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height)
+    if blow_out_air_volume >0: 
+        self.pipette_aspirate(volume=blow_out_air_volume, flow_rate=flow_rate)
+
+
+
+
+  async def dispense(
+    self,
+    ops: List[SingleChannelDispense],
+    use_channels: List[int],
+    **backend_kwargs,
+  ):
+    # print("Dispensing:")
+    header = (
+      f"{'pip#':<{UniLiquidHandlerLaiyuBackend._pip_length}} "
+      f"{'vol(ul)':<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+      f"{'resource':<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+      f"{'offset':<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+      f"{'flow rate':<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+      f"{'blowout':<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+      f"{'lld_z':<{UniLiquidHandlerLaiyuBackend._lld_z_length}}  "
+      # f"{'liquids':<20}" # TODO: add liquids
+    )
+    for key in backend_kwargs:
+      header += f"{key:<{UniLiquidHandlerLaiyuBackend._kwargs_length}} "[-16:]
+    # print(header)
+
+    for o, p in zip(ops, use_channels):
+      offset = f"{round(o.offset.x, 1)},{round(o.offset.y, 1)},{round(o.offset.z, 1)}"
+      row = (
+        f"  p{p}: "
+        f"{o.volume:<{UniLiquidHandlerLaiyuBackend._vol_length}} "
+        f"{o.resource.name[-20:]:<{UniLiquidHandlerLaiyuBackend._resource_length}} "
+        f"{offset:<{UniLiquidHandlerLaiyuBackend._offset_length}} "
+        f"{str(o.flow_rate):<{UniLiquidHandlerLaiyuBackend._flow_rate_length}} "
+        f"{str(o.blow_out_air_volume):<{UniLiquidHandlerLaiyuBackend._blowout_length}} "
+        f"{str(o.liquid_height):<{UniLiquidHandlerLaiyuBackend._lld_z_length}} "
+        # f"{o.liquids if o.liquids is not None else 'none'}"
+      )
+      for key, value in backend_kwargs.items():
+        if isinstance(value, list) and all(isinstance(v, bool) for v in value):
+          value = "".join("T" if v else "F" for v in value)
+        if isinstance(value, list):
+          value = "".join(map(str, value))
+        row += f" {value:<{UniLiquidHandlerLaiyuBackend._kwargs_length}}"
+      # print(row)
+    coordinate = ops[0].resource.get_absolute_location(x="c",y="c")
+    offset_xyz = ops[0].offset
+    x = coordinate.x + offset_xyz.x
+    y = coordinate.y + offset_xyz.y
+    z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
+    # print(x, y, z)
+    # print("moving")
+
+    # 判断枪头是否存在
+    self.hardware_interface._update_tip_status()
+    if not self.hardware_interface.tip_status == TipStatus.TIP_ATTACHED:
+        print("无枪头，无法排液")
+        return
+    # 判断排液量是否超过枪头容量
+    flow_rate = backend_kwargs["flow_rate"] if "flow_rate" in backend_kwargs else 500
+    blow_out_air_volume = backend_kwargs["blow_out_air_volume"] if "blow_out_air_volume" in backend_kwargs else 0
+    if self.hardware_interface.current_volume - ops[0].volume - blow_out_air_volume < 0:
+        self.hardware_interface.logger.error(f"排液量超过枪头容量: {self.hardware_interface.current_volume - ops[0].volume - blow_out_air_volume} < 0")
+        return
+
+    
+    # 移动到排液位置  
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(x=x, y=-y, z=z)
+    self.pipette_dispense(volume=ops[0].volume, flow_rate=flow_rate)
+
+
+    self.hardware_interface.xyz_controller.move_to_work_coord_safe(z=self.hardware_interface.xyz_controller.machine_config.safe_z_height)
+    if blow_out_air_volume > 0: 
+        self.pipette_dispense(volume=blow_out_air_volume, flow_rate=flow_rate)
+    # self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "",channels=use_channels)
+
+  async def pick_up_tips96(self, pickup: PickupTipRack, **backend_kwargs):
+    print(f"Picking up tips from {pickup.resource.name}.")
+
+  async def drop_tips96(self, drop: DropTipRack, **backend_kwargs):
+    print(f"Dropping tips to {drop.resource.name}.")
+
+  async def aspirate96(
+    self, aspiration: Union[MultiHeadAspirationPlate, MultiHeadAspirationContainer]
+  ):
+    if isinstance(aspiration, MultiHeadAspirationPlate):
+      resource = aspiration.wells[0].parent
+    else:
+      resource = aspiration.container
+    print(f"Aspirating {aspiration.volume} from {resource}.")
+
+  async def dispense96(self, dispense: Union[MultiHeadDispensePlate, MultiHeadDispenseContainer]):
+    if isinstance(dispense, MultiHeadDispensePlate):
+      resource = dispense.wells[0].parent
+    else:
+      resource = dispense.container
+    print(f"Dispensing {dispense.volume} to {resource}.")
+
+  async def pick_up_resource(self, pickup: ResourcePickup):
+    print(f"Picking up resource: {pickup}")
+
+  async def move_picked_up_resource(self, move: ResourceMove):
+    print(f"Moving picked up resource: {move}")
+
+  async def drop_resource(self, drop: ResourceDrop):
+    print(f"Dropping resource: {drop}")
+
+  def can_pick_up_tip(self, channel_idx: int, tip: Tip) -> bool:
+    return True
+    

unilabos/devices/liquid_handling/laiyu/controllers/__init__.py

@@ -0,0 +1,25 @@
+"""
+LaiYu_Liquid 控制器模块
+
+该模块包含了LaiYu_Liquid液体处理工作站的高级控制器：
+- 移液器控制器：提供液体处理的高级接口
+- XYZ运动控制器：提供三轴运动的高级接口
+"""
+
+# 移液器控制器导入
+from .pipette_controller import PipetteController
+
+# XYZ运动控制器导入
+from .xyz_controller import XYZController
+
+__all__ = [
+    # 移液器控制器
+    "PipetteController",
+    
+    # XYZ运动控制器
+    "XYZController",
+]
+
+__version__ = "1.0.0"
+__author__ = "LaiYu_Liquid Controller Team"
+__description__ = "LaiYu_Liquid 高级控制器集合"

unilabos/devices/liquid_handling/laiyu/controllers/coordinate_origin.json

@@ -0,0 +1,14 @@
+{
+  "machine_origin_steps": {
+    "x": -198.43,
+    "y": -94.25,
+    "z": -0.73
+  },
+  "work_origin_steps": {
+    "x": 59.39,
+    "y": 216.99,
+    "z": 2.0
+  },
+  "is_homed": true,
+  "timestamp": "2025-10-29T20:34:11.749055"
+}

unilabos/devices/liquid_handling/laiyu/core/LaiYu_Liquid.py

@@ -0,0 +1,881 @@
+"""
+LaiYu_Liquid 液体处理工作站主要集成文件
+
+该模块实现了 LaiYu_Liquid 与 UniLabOS 系统的集成，提供标准化的液体处理接口。
+主要包含：
+- LaiYuLiquidBackend: 硬件通信后端
+- LaiYuLiquid: 主要接口类
+- 相关的异常类和容器类
+"""
+
+import asyncio
+import logging
+import time
+from typing import List, Optional, Dict, Any, Union, Tuple
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
+
+# 基础导入
+try:
+    from pylabrobot.resources import Deck, Plate, TipRack, Tip, Resource, Well
+    PYLABROBOT_AVAILABLE = True
+except ImportError:
+    # 如果 pylabrobot 不可用，创建基础的模拟类
+    PYLABROBOT_AVAILABLE = False
+    
+    class Resource:
+        def __init__(self, name: str):
+            self.name = name
+    
+    class Deck(Resource):
+        pass
+    
+    class Plate(Resource):
+        pass
+    
+    class TipRack(Resource):
+        pass
+    
+    class Tip(Resource):
+        pass
+    
+    class Well(Resource):
+        pass
+
+# LaiYu_Liquid 控制器导入
+try:
+    from .controllers.pipette_controller import (
+        PipetteController, TipStatus, LiquidClass, LiquidParameters
+    )
+    from .controllers.xyz_controller import (
+        XYZController, MachineConfig, CoordinateOrigin, MotorAxis
+    )
+    CONTROLLERS_AVAILABLE = True
+except ImportError:
+    CONTROLLERS_AVAILABLE = False
+    # 创建模拟的控制器类
+    class PipetteController:
+        def __init__(self, *args, **kwargs):
+            pass
+        
+        def connect(self):
+            return True
+        
+        def initialize(self):
+            return True
+    
+    class XYZController:
+        def __init__(self, *args, **kwargs):
+            pass
+        
+        def connect_device(self):
+            return True
+
+logger = logging.getLogger(__name__)
+
+
+class LaiYuLiquidError(RuntimeError):
+    """LaiYu_Liquid 设备异常"""
+    pass
+
+
+@dataclass
+class LaiYuLiquidConfig:
+    """LaiYu_Liquid 设备配置"""
+    port: str = "/dev/cu.usbserial-3130"  # RS485转USB端口
+    address: int = 1  # 设备地址
+    baudrate: int = 9600  # 波特率
+    timeout: float = 5.0  # 通信超时时间
+    
+    # 工作台尺寸
+    deck_width: float = 340.0  # 工作台宽度 (mm)
+    deck_height: float = 250.0  # 工作台高度 (mm)
+    deck_depth: float = 160.0  # 工作台深度 (mm)
+    
+    # 移液参数
+    max_volume: float = 1000.0  # 最大体积 (μL)
+    min_volume: float = 0.1  # 最小体积 (μL)
+    
+    # 运动参数
+    max_speed: float = 100.0  # 最大速度 (mm/s)
+    acceleration: float = 50.0  # 加速度 (mm/s²)
+    
+    # 安全参数
+    safe_height: float = 50.0  # 安全高度 (mm)
+    tip_pickup_depth: float = 10.0  # 吸头拾取深度 (mm)
+    liquid_detection: bool = True  # 液面检测
+    
+    # 取枪头相关参数
+    tip_pickup_speed: int = 30  # 取枪头时的移动速度 (rpm)
+    tip_pickup_acceleration: int = 500  # 取枪头时的加速度 (rpm/s)
+    tip_approach_height: float = 5.0  # 接近枪头时的高度 (mm)
+    tip_pickup_force_depth: float = 2.0  # 强制插入深度 (mm)
+    tip_pickup_retract_height: float = 20.0  # 取枪头后的回退高度 (mm)
+    
+    # 丢弃枪头相关参数
+    tip_drop_height: float = 10.0  # 丢弃枪头时的高度 (mm)
+    tip_drop_speed: int = 50  # 丢弃枪头时的移动速度 (rpm)
+    trash_position: Tuple[float, float, float] = (300.0, 200.0, 0.0)  # 垃圾桶位置 (mm)
+    
+    # 安全范围配置
+    deck_width: float = 300.0  # 工作台宽度 (mm)
+    deck_height: float = 200.0  # 工作台高度 (mm)
+    deck_depth: float = 100.0  # 工作台深度 (mm)
+    safe_height: float = 50.0  # 安全高度 (mm)
+    position_validation: bool = True  # 启用位置验证
+    emergency_stop_enabled: bool = True  # 启用紧急停止
+
+
+class LaiYuLiquidDeck:
+    """LaiYu_Liquid 工作台管理"""
+    
+    def __init__(self, config: LaiYuLiquidConfig):
+        self.config = config
+        self.resources: Dict[str, Resource] = {}
+        self.positions: Dict[str, Tuple[float, float, float]] = {}
+        
+    def add_resource(self, name: str, resource: Resource, position: Tuple[float, float, float]):
+        """添加资源到工作台"""
+        self.resources[name] = resource
+        self.positions[name] = position
+        
+    def get_resource(self, name: str) -> Optional[Resource]:
+        """获取资源"""
+        return self.resources.get(name)
+        
+    def get_position(self, name: str) -> Optional[Tuple[float, float, float]]:
+        """获取资源位置"""
+        return self.positions.get(name)
+        
+    def list_resources(self) -> List[str]:
+        """列出所有资源"""
+        return list(self.resources.keys())
+
+
+class LaiYuLiquidContainer:
+    """LaiYu_Liquid 容器类"""
+    
+    def __init__(self, name: str, size_x: float = 0, size_y: float = 0, size_z: float = 0, container_type: str = "", volume: float = 0.0, max_volume: float = 1000.0, lid_height: float = 0.0):
+        self.name = name
+        self.size_x = size_x
+        self.size_y = size_y
+        self.size_z = size_z
+        self.lid_height = lid_height
+        self.container_type = container_type
+        self.volume = volume
+        self.max_volume = max_volume
+        self.last_updated = time.time()
+        self.child_resources = {}  # 存储子资源
+        
+    @property
+    def is_empty(self) -> bool:
+        return self.volume <= 0.0
+        
+    @property
+    def is_full(self) -> bool:
+        return self.volume >= self.max_volume
+        
+    @property
+    def available_volume(self) -> float:
+        return max(0.0, self.max_volume - self.volume)
+        
+    def add_volume(self, volume: float) -> bool:
+        """添加体积"""
+        if self.volume + volume <= self.max_volume:
+            self.volume += volume
+            self.last_updated = time.time()
+            return True
+        return False
+        
+    def remove_volume(self, volume: float) -> bool:
+        """移除体积"""
+        if self.volume >= volume:
+            self.volume -= volume
+            self.last_updated = time.time()
+            return True
+        return False
+    
+    def assign_child_resource(self, resource, location=None):
+        """分配子资源 - 与 PyLabRobot 资源管理系统兼容"""
+        if hasattr(resource, 'name'):
+            self.child_resources[resource.name] = {
+                'resource': resource,
+                'location': location
+            }
+
+
+class LaiYuLiquidTipRack:
+    """LaiYu_Liquid 吸头架类"""
+    
+    def __init__(self, name: str, size_x: float = 0, size_y: float = 0, size_z: float = 0, tip_count: int = 96, tip_volume: float = 1000.0):
+        self.name = name
+        self.size_x = size_x
+        self.size_y = size_y
+        self.size_z = size_z
+        self.tip_count = tip_count
+        self.tip_volume = tip_volume
+        self.tips_available = [True] * tip_count
+        self.child_resources = {}  # 存储子资源
+        
+    @property
+    def available_tips(self) -> int:
+        return sum(self.tips_available)
+        
+    @property
+    def is_empty(self) -> bool:
+        return self.available_tips == 0
+        
+    def pick_tip(self, position: int) -> bool:
+        """拾取吸头"""
+        if 0 <= position < self.tip_count and self.tips_available[position]:
+            self.tips_available[position] = False
+            return True
+        return False
+        
+    def has_tip(self, position: int) -> bool:
+        """检查位置是否有吸头"""
+        if 0 <= position < self.tip_count:
+            return self.tips_available[position]
+        return False
+    
+    def assign_child_resource(self, resource, location=None):
+        """分配子资源到指定位置"""
+        self.child_resources[resource.name] = {
+            'resource': resource,
+            'location': location
+        }
+
+
+def get_module_info():
+    """获取模块信息"""
+    return {
+        "name": "LaiYu_Liquid",
+        "version": "1.0.0",
+        "description": "LaiYu液体处理工作站模块，提供移液器控制、XYZ轴控制和资源管理功能",
+        "author": "UniLabOS Team",
+        "capabilities": [
+            "移液器控制",
+            "XYZ轴运动控制", 
+            "吸头架管理",
+            "板和容器管理",
+            "资源位置管理"
+        ],
+        "dependencies": {
+            "required": ["serial"],
+            "optional": ["pylabrobot"]
+        }
+    }
+
+
+class LaiYuLiquidBackend:
+    """LaiYu_Liquid 硬件通信后端"""
+    
+    def __init__(self, config: LaiYuLiquidConfig, deck: Optional['LaiYuLiquidDeck'] = None):
+        self.config = config
+        self.deck = deck  # 工作台引用，用于获取资源位置信息
+        self.pipette_controller = None
+        self.xyz_controller = None
+        self.is_connected = False
+        self.is_initialized = False
+        
+        # 状态跟踪
+        self.current_position = (0.0, 0.0, 0.0)
+        self.tip_attached = False
+        self.current_volume = 0.0
+        
+    def _validate_position(self, x: float, y: float, z: float) -> bool:
+        """验证位置是否在安全范围内"""
+        try:
+            # 检查X轴范围
+            if not (0 <= x <= self.config.deck_width):
+                logger.error(f"X轴位置 {x:.2f}mm 超出范围 [0, {self.config.deck_width}]")
+                return False
+            
+            # 检查Y轴范围
+            if not (0 <= y <= self.config.deck_height):
+                logger.error(f"Y轴位置 {y:.2f}mm 超出范围 [0, {self.config.deck_height}]")
+                return False
+            
+            # 检查Z轴范围（负值表示向下，0为工作台表面）
+            if not (-self.config.deck_depth <= z <= self.config.safe_height):
+                logger.error(f"Z轴位置 {z:.2f}mm 超出安全范围 [{-self.config.deck_depth}, {self.config.safe_height}]")
+                return False
+            
+            return True
+        except Exception as e:
+            logger.error(f"位置验证失败: {e}")
+            return False
+    
+    def _check_hardware_ready(self) -> bool:
+        """检查硬件是否准备就绪"""
+        if not self.is_connected:
+            logger.error("设备未连接")
+            return False
+        
+        if CONTROLLERS_AVAILABLE:
+            if self.xyz_controller is None:
+                logger.error("XYZ控制器未初始化")
+                return False
+        
+        return True
+    
+    async def emergency_stop(self) -> bool:
+        """紧急停止所有运动"""
+        try:
+            logger.warning("执行紧急停止")
+            
+            if CONTROLLERS_AVAILABLE and self.xyz_controller:
+                # 停止XYZ控制器
+                await self.xyz_controller.stop_all_motion()
+                logger.info("XYZ控制器已停止")
+            
+            if self.pipette_controller:
+                # 停止移液器控制器
+                await self.pipette_controller.stop()
+                logger.info("移液器控制器已停止")
+            
+            return True
+        except Exception as e:
+            logger.error(f"紧急停止失败: {e}")
+            return False
+    
+    async def move_to_safe_position(self) -> bool:
+        """移动到安全位置"""
+        try:
+            if not self._check_hardware_ready():
+                return False
+            
+            safe_position = (
+                self.config.deck_width / 2,  # 工作台中心X
+                self.config.deck_height / 2,  # 工作台中心Y
+                self.config.safe_height  # 安全高度Z
+            )
+            
+            if not self._validate_position(*safe_position):
+                logger.error("安全位置无效")
+                return False
+            
+            if CONTROLLERS_AVAILABLE and self.xyz_controller:
+                await self.xyz_controller.move_to_work_coord(*safe_position)
+                self.current_position = safe_position
+                logger.info(f"已移动到安全位置: {safe_position}")
+                return True
+            else:
+                # 模拟模式
+                self.current_position = safe_position
+                logger.info("模拟移动到安全位置")
+                return True
+                
+        except Exception as e:
+            logger.error(f"移动到安全位置失败: {e}")
+            return False
+        
+    async def setup(self) -> bool:
+        """设置硬件连接"""
+        try:
+            if CONTROLLERS_AVAILABLE:
+                # 初始化移液器控制器
+                self.pipette_controller = PipetteController(
+                    port=self.config.port,
+                    address=self.config.address
+                )
+                
+                # 初始化XYZ控制器
+                machine_config = MachineConfig()
+                self.xyz_controller = XYZController(
+                    port=self.config.port,
+                    baudrate=self.config.baudrate,
+                    machine_config=machine_config
+                )
+                
+                # 连接设备
+                pipette_connected = await asyncio.to_thread(self.pipette_controller.connect)
+                xyz_connected = await asyncio.to_thread(self.xyz_controller.connect_device)
+                
+                if pipette_connected and xyz_connected:
+                    self.is_connected = True
+                    logger.info("LaiYu_Liquid 硬件连接成功")
+                    return True
+                else:
+                    logger.error("LaiYu_Liquid 硬件连接失败")
+                    return False
+            else:
+                # 模拟模式
+                logger.info("LaiYu_Liquid 运行在模拟模式")
+                self.is_connected = True
+                return True
+                
+        except Exception as e:
+            logger.error(f"LaiYu_Liquid 设置失败: {e}")
+            return False
+    
+    async def stop(self):
+        """停止设备"""
+        try:
+            if self.pipette_controller and hasattr(self.pipette_controller, 'disconnect'):
+                await asyncio.to_thread(self.pipette_controller.disconnect)
+            
+            if self.xyz_controller and hasattr(self.xyz_controller, 'disconnect'):
+                await asyncio.to_thread(self.xyz_controller.disconnect)
+                
+            self.is_connected = False
+            self.is_initialized = False
+            logger.info("LaiYu_Liquid 已停止")
+            
+        except Exception as e:
+            logger.error(f"LaiYu_Liquid 停止失败: {e}")
+    
+    async def move_to(self, x: float, y: float, z: float) -> bool:
+        """移动到指定位置"""
+        try:
+            if not self.is_connected:
+                raise LaiYuLiquidError("设备未连接")
+            
+            # 模拟移动
+            await asyncio.sleep(0.1)  # 模拟移动时间
+            self.current_position = (x, y, z)
+            logger.debug(f"移动到位置: ({x}, {y}, {z})")
+            return True
+            
+        except Exception as e:
+            logger.error(f"移动失败: {e}")
+            return False
+    
+    async def pick_up_tip(self, tip_rack: str, position: int) -> bool:
+        """拾取吸头 - 包含真正的Z轴下降控制"""
+        try:
+            # 硬件准备检查
+            if not self._check_hardware_ready():
+                return False
+                
+            if self.tip_attached:
+                logger.warning("已有吸头附着，无法拾取新吸头")
+                return False
+                
+            logger.info(f"开始从 {tip_rack} 位置 {position} 拾取吸头")
+            
+            # 获取枪头架位置信息
+            if self.deck is None:
+                logger.error("工作台未初始化")
+                return False
+                
+            tip_position = self.deck.get_position(tip_rack)
+            if tip_position is None:
+                logger.error(f"未找到枪头架 {tip_rack} 的位置信息")
+                return False
+                
+            # 计算具体枪头位置（这里简化处理，实际应根据position计算偏移）
+            tip_x, tip_y, tip_z = tip_position
+            
+            # 验证所有关键位置的安全性
+            safe_z = tip_z + self.config.tip_approach_height
+            pickup_z = tip_z - self.config.tip_pickup_force_depth
+            retract_z = tip_z + self.config.tip_pickup_retract_height
+            
+            if not (self._validate_position(tip_x, tip_y, safe_z) and 
+                    self._validate_position(tip_x, tip_y, pickup_z) and 
+                    self._validate_position(tip_x, tip_y, retract_z)):
+                logger.error("枪头拾取位置超出安全范围")
+                return False
+            
+            if CONTROLLERS_AVAILABLE and self.xyz_controller:
+                # 真实硬件控制流程
+                logger.info("使用真实XYZ控制器进行枪头拾取")
+                
+                try:
+                    # 1. 移动到枪头上方的安全位置
+                    safe_z = tip_z + self.config.tip_approach_height
+                    logger.info(f"移动到枪头上方安全位置: ({tip_x:.2f}, {tip_y:.2f}, {safe_z:.2f})")
+                    move_success = await asyncio.to_thread(
+                        self.xyz_controller.move_to_work_coord, 
+                        tip_x, tip_y, safe_z
+                    )
+                    if not move_success:
+                        logger.error("移动到枪头上方失败")
+                        return False
+                    
+                    # 2. Z轴下降到枪头位置
+                    pickup_z = tip_z - self.config.tip_pickup_force_depth
+                    logger.info(f"Z轴下降到枪头拾取位置: {pickup_z:.2f}mm")
+                    z_down_success = await asyncio.to_thread(
+                        self.xyz_controller.move_to_work_coord,
+                        tip_x, tip_y, pickup_z
+                    )
+                    if not z_down_success:
+                        logger.error("Z轴下降到枪头位置失败")
+                        return False
+                    
+                    # 3. 等待一小段时间确保枪头牢固附着
+                    await asyncio.sleep(0.2)
+                    
+                    # 4. Z轴上升到回退高度
+                    retract_z = tip_z + self.config.tip_pickup_retract_height
+                    logger.info(f"Z轴上升到回退高度: {retract_z:.2f}mm")
+                    z_up_success = await asyncio.to_thread(
+                        self.xyz_controller.move_to_work_coord,
+                        tip_x, tip_y, retract_z
+                    )
+                    if not z_up_success:
+                        logger.error("Z轴上升失败")
+                        return False
+                    
+                    # 5. 更新当前位置
+                    self.current_position = (tip_x, tip_y, retract_z)
+                    
+                except Exception as move_error:
+                    logger.error(f"枪头拾取过程中发生错误: {move_error}")
+                    # 尝试移动到安全位置
+                    if self.config.emergency_stop_enabled:
+                        await self.emergency_stop()
+                        await self.move_to_safe_position()
+                    return False
+                
+            else:
+                # 模拟模式
+                logger.info("模拟模式：执行枪头拾取动作")
+                await asyncio.sleep(1.0)  # 模拟整个拾取过程的时间
+                self.current_position = (tip_x, tip_y, tip_z + self.config.tip_pickup_retract_height)
+            
+            # 6. 标记枪头已附着
+            self.tip_attached = True
+            logger.info("吸头拾取成功")
+            return True
+            
+        except Exception as e:
+            logger.error(f"拾取吸头失败: {e}")
+            return False
+    
+    async def drop_tip(self, location: str = "trash") -> bool:
+        """丢弃吸头 - 包含真正的Z轴控制"""
+        try:
+            # 硬件准备检查
+            if not self._check_hardware_ready():
+                return False
+            
+            if not self.tip_attached:
+                logger.warning("没有吸头附着，无需丢弃")
+                return True
+            
+            logger.info(f"开始丢弃吸头到 {location}")
+            
+            # 确定丢弃位置
+            if location == "trash":
+                # 使用配置中的垃圾桶位置
+                drop_x, drop_y, drop_z = self.config.trash_position
+            else:
+                # 尝试从deck获取指定位置
+                if self.deck is None:
+                    logger.error("工作台未初始化")
+                    return False
+                    
+                drop_position = self.deck.get_position(location)
+                if drop_position is None:
+                    logger.error(f"未找到丢弃位置 {location} 的信息")
+                    return False
+                drop_x, drop_y, drop_z = drop_position
+            
+            # 验证丢弃位置的安全性
+            safe_z = drop_z + self.config.safe_height
+            drop_height_z = drop_z + self.config.tip_drop_height
+            
+            if not (self._validate_position(drop_x, drop_y, safe_z) and 
+                    self._validate_position(drop_x, drop_y, drop_height_z)):
+                logger.error("枪头丢弃位置超出安全范围")
+                return False
+            
+            if CONTROLLERS_AVAILABLE and self.xyz_controller:
+                # 真实硬件控制流程
+                logger.info("使用真实XYZ控制器进行枪头丢弃")
+                
+                try:
+                    # 1. 移动到丢弃位置上方的安全高度
+                    safe_z = drop_z + self.config.tip_drop_height
+                    logger.info(f"移动到丢弃位置上方: ({drop_x:.2f}, {drop_y:.2f}, {safe_z:.2f})")
+                    move_success = await asyncio.to_thread(
+                        self.xyz_controller.move_to_work_coord,
+                        drop_x, drop_y, safe_z
+                    )
+                    if not move_success:
+                        logger.error("移动到丢弃位置上方失败")
+                        return False
+                    
+                    # 2. Z轴下降到丢弃高度
+                    logger.info(f"Z轴下降到丢弃高度: {drop_z:.2f}mm")
+                    z_down_success = await asyncio.to_thread(
+                        self.xyz_controller.move_to_work_coord,
+                        drop_x, drop_y, drop_z
+                    )
+                    if not z_down_success:
+                        logger.error("Z轴下降到丢弃位置失败")
+                        return False
+                    
+                    # 3. 执行枪头弹出动作（如果有移液器控制器）
+                    if self.pipette_controller:
+                        try:
+                            # 发送弹出枪头命令
+                            await asyncio.to_thread(self.pipette_controller.eject_tip)
+                            logger.info("执行枪头弹出命令")
+                        except Exception as e:
+                            logger.warning(f"枪头弹出命令失败: {e}")
+                    
+                    # 4. 等待一小段时间确保枪头完全脱离
+                    await asyncio.sleep(0.3)
+                    
+                    # 5. Z轴上升到安全高度
+                    logger.info(f"Z轴上升到安全高度: {safe_z:.2f}mm")
+                    z_up_success = await asyncio.to_thread(
+                        self.xyz_controller.move_to_work_coord,
+                        drop_x, drop_y, safe_z
+                    )
+                    if not z_up_success:
+                        logger.error("Z轴上升失败")
+                        return False
+                    
+                    # 6. 更新当前位置
+                    self.current_position = (drop_x, drop_y, safe_z)
+                    
+                except Exception as drop_error:
+                    logger.error(f"枪头丢弃过程中发生错误: {drop_error}")
+                    # 尝试移动到安全位置
+                    if self.config.emergency_stop_enabled:
+                        await self.emergency_stop()
+                        await self.move_to_safe_position()
+                    return False
+                
+            else:
+                # 模拟模式
+                logger.info("模拟模式：执行枪头丢弃动作")
+                await asyncio.sleep(0.8)  # 模拟整个丢弃过程的时间
+                self.current_position = (drop_x, drop_y, drop_z + self.config.tip_drop_height)
+            
+            # 7. 标记枪头已脱离，清空体积
+            self.tip_attached = False
+            self.current_volume = 0.0
+            logger.info("吸头丢弃成功")
+            return True
+            
+        except Exception as e:
+            logger.error(f"丢弃吸头失败: {e}")
+            return False
+    
+    async def aspirate(self, volume: float, location: str) -> bool:
+        """吸取液体"""
+        try:
+            if not self.is_connected:
+                raise LaiYuLiquidError("设备未连接")
+            
+            if not self.tip_attached:
+                raise LaiYuLiquidError("没有吸头附着")
+            
+            if volume <= 0 or volume > self.config.max_volume:
+                raise LaiYuLiquidError(f"体积超出范围: {volume}")
+            
+            # 模拟吸取
+            await asyncio.sleep(0.3)
+            self.current_volume += volume
+            logger.debug(f"从 {location} 吸取 {volume} μL")
+            return True
+            
+        except Exception as e:
+            logger.error(f"吸取失败: {e}")
+            return False
+    
+    async def dispense(self, volume: float, location: str) -> bool:
+        """分配液体"""
+        try:
+            if not self.is_connected:
+                raise LaiYuLiquidError("设备未连接")
+            
+            if not self.tip_attached:
+                raise LaiYuLiquidError("没有吸头附着")
+            
+            if volume <= 0 or volume > self.current_volume:
+                raise LaiYuLiquidError(f"分配体积无效: {volume}")
+            
+            # 模拟分配
+            await asyncio.sleep(0.3)
+            self.current_volume -= volume
+            logger.debug(f"向 {location} 分配 {volume} μL")
+            return True
+            
+        except Exception as e:
+            logger.error(f"分配失败: {e}")
+            return False
+
+
+class LaiYuLiquid:
+    """LaiYu_Liquid 主要接口类"""
+    
+    def __init__(self, config: Optional[LaiYuLiquidConfig] = None, **kwargs):
+        # 如果传入了关键字参数，创建配置对象
+        if kwargs and config is None:
+            # 从kwargs中提取配置参数
+            config_params = {}
+            for key, value in kwargs.items():
+                if hasattr(LaiYuLiquidConfig, key):
+                    config_params[key] = value
+            self.config = LaiYuLiquidConfig(**config_params)
+        else:
+            self.config = config or LaiYuLiquidConfig()
+        
+        # 先创建deck，然后传递给backend
+        self.deck = LaiYuLiquidDeck(self.config)
+        self.backend = LaiYuLiquidBackend(self.config, self.deck)
+        self.is_setup = False
+    
+    @property
+    def current_position(self) -> Tuple[float, float, float]:
+        """获取当前位置"""
+        return self.backend.current_position
+    
+    @property
+    def current_volume(self) -> float:
+        """获取当前体积"""
+        return self.backend.current_volume
+    
+    @property
+    def is_connected(self) -> bool:
+        """获取连接状态"""
+        return self.backend.is_connected
+    
+    @property
+    def is_initialized(self) -> bool:
+        """获取初始化状态"""
+        return self.backend.is_initialized
+    
+    @property
+    def tip_attached(self) -> bool:
+        """获取吸头附着状态"""
+        return self.backend.tip_attached
+        
+    async def setup(self) -> bool:
+        """设置液体处理器"""
+        try:
+            success = await self.backend.setup()
+            if success:
+                self.is_setup = True
+                logger.info("LaiYu_Liquid 设置完成")
+            return success
+        except Exception as e:
+            logger.error(f"LaiYu_Liquid 设置失败: {e}")
+            return False
+    
+    async def stop(self):
+        """停止液体处理器"""
+        await self.backend.stop()
+        self.is_setup = False
+    
+    async def transfer(self, source: str, target: str, volume: float, 
+                      tip_rack: str = "tip_rack_1", tip_position: int = 0) -> bool:
+        """液体转移"""
+        try:
+            if not self.is_setup:
+                raise LaiYuLiquidError("设备未设置")
+            
+            # 获取源和目标位置
+            source_pos = self.deck.get_position(source)
+            target_pos = self.deck.get_position(target)
+            tip_pos = self.deck.get_position(tip_rack)
+            
+            if not all([source_pos, target_pos, tip_pos]):
+                raise LaiYuLiquidError("位置信息不完整")
+            
+            # 执行转移步骤
+            steps = [
+                ("移动到吸头架", self.backend.move_to(*tip_pos)),
+                ("拾取吸头", self.backend.pick_up_tip(tip_rack, tip_position)),
+                ("移动到源位置", self.backend.move_to(*source_pos)),
+                ("吸取液体", self.backend.aspirate(volume, source)),
+                ("移动到目标位置", self.backend.move_to(*target_pos)),
+                ("分配液体", self.backend.dispense(volume, target)),
+                ("丢弃吸头", self.backend.drop_tip())
+            ]
+            
+            for step_name, step_coro in steps:
+                logger.debug(f"执行步骤: {step_name}")
+                success = await step_coro
+                if not success:
+                    raise LaiYuLiquidError(f"步骤失败: {step_name}")
+            
+            logger.info(f"液体转移完成: {source} -> {target}, {volume} μL")
+            return True
+            
+        except Exception as e:
+            logger.error(f"液体转移失败: {e}")
+            return False
+    
+    def add_resource(self, name: str, resource_type: str, position: Tuple[float, float, float]):
+        """添加资源到工作台"""
+        if resource_type == "plate":
+            resource = Plate(name)
+        elif resource_type == "tip_rack":
+            resource = TipRack(name)
+        else:
+            resource = Resource(name)
+        
+        self.deck.add_resource(name, resource, position)
+    
+    def get_status(self) -> Dict[str, Any]:
+        """获取设备状态"""
+        return {
+            "connected": self.backend.is_connected,
+            "setup": self.is_setup,
+            "current_position": self.backend.current_position,
+            "tip_attached": self.backend.tip_attached,
+            "current_volume": self.backend.current_volume,
+            "resources": self.deck.list_resources()
+        }
+
+
+def create_quick_setup() -> LaiYuLiquidDeck:
+    """
+    创建快速设置的LaiYu液体处理工作站
+    
+    Returns:
+        LaiYuLiquidDeck: 配置好的工作台实例
+    """
+    # 创建默认配置
+    config = LaiYuLiquidConfig()
+    
+    # 创建工作台
+    deck = LaiYuLiquidDeck(config)
+    
+    # 导入资源创建函数
+    try:
+        from .laiyu_liquid_res import (
+            create_tip_rack_1000ul,
+            create_tip_rack_200ul,
+            create_96_well_plate,
+            create_waste_container
+        )
+        
+        # 添加基本资源
+        tip_rack_1000 = create_tip_rack_1000ul("tip_rack_1000")
+        tip_rack_200 = create_tip_rack_200ul("tip_rack_200")
+        plate_96 = create_96_well_plate("plate_96")
+        waste = create_waste_container("waste")
+        
+        # 添加到工作台
+        deck.add_resource("tip_rack_1000", tip_rack_1000, (50, 50, 0))
+        deck.add_resource("tip_rack_200", tip_rack_200, (150, 50, 0))
+        deck.add_resource("plate_96", plate_96, (250, 50, 0))
+        deck.add_resource("waste", waste, (50, 150, 0))
+        
+    except ImportError:
+        # 如果资源模块不可用，创建空的工作台
+        logger.warning("资源模块不可用，创建空的工作台")
+    
+    return deck
+
+
+__all__ = [
+    "LaiYuLiquid",
+    "LaiYuLiquidBackend", 
+    "LaiYuLiquidConfig",
+    "LaiYuLiquidDeck",
+    "LaiYuLiquidContainer",
+    "LaiYuLiquidTipRack",
+    "LaiYuLiquidError",
+    "create_quick_setup",
+    "get_module_info"
+]

unilabos/devices/liquid_handling/laiyu/core/__init__.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+LaiYu液体处理设备核心模块
+
+该模块包含LaiYu液体处理设备的核心功能组件：
+- LaiYu_Liquid.py: 主设备类和配置管理
+- abstract_protocol.py: 抽象协议定义
+- laiyu_liquid_res.py: 设备资源管理
+
+作者: UniLab团队
+版本: 2.0.0
+"""
+
+from .LaiYu_Liquid import (
+    LaiYuLiquid,
+    LaiYuLiquidConfig,
+    LaiYuLiquidDeck,
+    LaiYuLiquidContainer,
+    LaiYuLiquidTipRack,
+    create_quick_setup
+)
+
+from .laiyu_liquid_res import (
+    LaiYuLiquidDeck,
+    LaiYuLiquidContainer, 
+    LaiYuLiquidTipRack
+)
+
+__all__ = [
+    # 主设备类
+    'LaiYuLiquid',
+    'LaiYuLiquidConfig',
+    
+    # 设备资源
+    'LaiYuLiquidDeck',
+    'LaiYuLiquidContainer',
+    'LaiYuLiquidTipRack',
+    
+    # 工具函数
+    'create_quick_setup'
+]

unilabos/devices/liquid_handling/laiyu/core/abstract_protocol.py

@@ -0,0 +1,529 @@
+"""
+LaiYu_Liquid 抽象协议实现
+
+该模块提供了液体资源管理和转移的抽象协议，包括：
+- MaterialResource: 液体资源管理类
+- transfer_liquid: 液体转移函数
+- 相关的辅助类和函数
+
+主要功能：
+- 管理多孔位的液体资源
+- 计算和跟踪液体体积
+- 处理液体转移操作
+- 提供资源状态查询
+"""
+
+import logging
+from typing import Dict, List, Optional, Union, Any, Tuple
+from dataclasses import dataclass, field
+from enum import Enum
+import uuid
+import time
+
+# pylabrobot 导入
+from pylabrobot.resources import Resource, Well, Plate
+
+logger = logging.getLogger(__name__)
+
+
+class LiquidType(Enum):
+    """液体类型枚举"""
+    WATER = "water"
+    ETHANOL = "ethanol"
+    DMSO = "dmso"
+    BUFFER = "buffer"
+    SAMPLE = "sample"
+    REAGENT = "reagent"
+    WASTE = "waste"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class LiquidInfo:
+    """液体信息类"""
+    liquid_type: LiquidType = LiquidType.UNKNOWN
+    volume: float = 0.0  # 体积 (μL)
+    concentration: Optional[float] = None  # 浓度 (mg/ml, M等)
+    ph: Optional[float] = None  # pH值
+    temperature: Optional[float] = None  # 温度 (°C)
+    viscosity: Optional[float] = None  # 粘度 (cP)
+    density: Optional[float] = None  # 密度 (g/ml)
+    description: str = ""  # 描述信息
+    
+    def __str__(self) -> str:
+        return f"{self.liquid_type.value}({self.description})"
+
+
+@dataclass
+class WellContent:
+    """孔位内容类"""
+    volume: float = 0.0  # 当前体积 (ul)
+    max_volume: float = 1000.0  # 最大容量 (ul)
+    liquid_info: LiquidInfo = field(default_factory=LiquidInfo)
+    last_updated: float = field(default_factory=time.time)
+    
+    @property
+    def is_empty(self) -> bool:
+        """检查是否为空"""
+        return self.volume <= 0.0
+    
+    @property
+    def is_full(self) -> bool:
+        """检查是否已满"""
+        return self.volume >= self.max_volume
+    
+    @property
+    def available_volume(self) -> float:
+        """可用体积"""
+        return max(0.0, self.max_volume - self.volume)
+    
+    @property
+    def fill_percentage(self) -> float:
+        """填充百分比"""
+        return (self.volume / self.max_volume) * 100.0 if self.max_volume > 0 else 0.0
+    
+    def can_add_volume(self, volume: float) -> bool:
+        """检查是否可以添加指定体积"""
+        return (self.volume + volume) <= self.max_volume
+    
+    def can_remove_volume(self, volume: float) -> bool:
+        """检查是否可以移除指定体积"""
+        return self.volume >= volume
+    
+    def add_volume(self, volume: float, liquid_info: Optional[LiquidInfo] = None) -> bool:
+        """
+        添加液体体积
+        
+        Args:
+            volume: 要添加的体积 (ul)
+            liquid_info: 液体信息
+            
+        Returns:
+            bool: 是否成功添加
+        """
+        if not self.can_add_volume(volume):
+            return False
+        
+        self.volume += volume
+        if liquid_info:
+            self.liquid_info = liquid_info
+        self.last_updated = time.time()
+        return True
+    
+    def remove_volume(self, volume: float) -> bool:
+        """
+        移除液体体积
+        
+        Args:
+            volume: 要移除的体积 (ul)
+            
+        Returns:
+            bool: 是否成功移除
+        """
+        if not self.can_remove_volume(volume):
+            return False
+        
+        self.volume -= volume
+        self.last_updated = time.time()
+        
+        # 如果完全清空，重置液体信息
+        if self.volume <= 0.0:
+            self.volume = 0.0
+            self.liquid_info = LiquidInfo()
+        
+        return True
+
+
+class MaterialResource:
+    """
+    液体资源管理类
+    
+    该类用于管理液体处理过程中的资源状态，包括：
+    - 跟踪多个孔位的液体体积和类型
+    - 计算总体积和可用体积
+    - 处理液体的添加和移除
+    - 提供资源状态查询
+    """
+    
+    def __init__(
+        self,
+        resource: Resource,
+        wells: Optional[List[Well]] = None,
+        default_max_volume: float = 1000.0
+    ):
+        """
+        初始化材料资源
+        
+        Args:
+            resource: pylabrobot 资源对象
+            wells: 孔位列表，如果为None则自动获取
+            default_max_volume: 默认最大体积 (ul)
+        """
+        self.resource = resource
+        self.resource_id = str(uuid.uuid4())
+        self.default_max_volume = default_max_volume
+        
+        # 获取孔位列表
+        if wells is None:
+            if hasattr(resource, 'get_wells'):
+                self.wells = resource.get_wells()
+            elif hasattr(resource, 'wells'):
+                self.wells = resource.wells
+            else:
+                # 如果没有孔位，创建一个虚拟孔位
+                self.wells = [resource]
+        else:
+            self.wells = wells
+        
+        # 初始化孔位内容
+        self.well_contents: Dict[str, WellContent] = {}
+        for well in self.wells:
+            well_id = self._get_well_id(well)
+            self.well_contents[well_id] = WellContent(
+                max_volume=default_max_volume
+            )
+        
+        logger.info(f"初始化材料资源: {resource.name}, 孔位数: {len(self.wells)}")
+    
+    def _get_well_id(self, well: Union[Well, Resource]) -> str:
+        """获取孔位ID"""
+        if hasattr(well, 'name'):
+            return well.name
+        else:
+            return str(id(well))
+    
+    @property
+    def name(self) -> str:
+        """资源名称"""
+        return self.resource.name
+    
+    @property
+    def total_volume(self) -> float:
+        """总液体体积"""
+        return sum(content.volume for content in self.well_contents.values())
+    
+    @property
+    def total_max_volume(self) -> float:
+        """总最大容量"""
+        return sum(content.max_volume for content in self.well_contents.values())
+    
+    @property
+    def available_volume(self) -> float:
+        """总可用体积"""
+        return sum(content.available_volume for content in self.well_contents.values())
+    
+    @property
+    def well_count(self) -> int:
+        """孔位数量"""
+        return len(self.wells)
+    
+    @property
+    def empty_wells(self) -> List[str]:
+        """空孔位列表"""
+        return [well_id for well_id, content in self.well_contents.items() 
+                if content.is_empty]
+    
+    @property
+    def full_wells(self) -> List[str]:
+        """满孔位列表"""
+        return [well_id for well_id, content in self.well_contents.items() 
+                if content.is_full]
+    
+    @property
+    def occupied_wells(self) -> List[str]:
+        """有液体的孔位列表"""
+        return [well_id for well_id, content in self.well_contents.items() 
+                if not content.is_empty]
+    
+    def get_well_content(self, well_id: str) -> Optional[WellContent]:
+        """获取指定孔位的内容"""
+        return self.well_contents.get(well_id)
+    
+    def get_well_volume(self, well_id: str) -> float:
+        """获取指定孔位的体积"""
+        content = self.get_well_content(well_id)
+        return content.volume if content else 0.0
+    
+    def set_well_volume(
+        self,
+        well_id: str,
+        volume: float,
+        liquid_info: Optional[LiquidInfo] = None
+    ) -> bool:
+        """
+        设置指定孔位的体积
+        
+        Args:
+            well_id: 孔位ID
+            volume: 体积 (ul)
+            liquid_info: 液体信息
+            
+        Returns:
+            bool: 是否成功设置
+        """
+        if well_id not in self.well_contents:
+            logger.error(f"孔位 {well_id} 不存在")
+            return False
+        
+        content = self.well_contents[well_id]
+        if volume > content.max_volume:
+            logger.error(f"体积 {volume} 超过最大容量 {content.max_volume}")
+            return False
+        
+        content.volume = max(0.0, volume)
+        if liquid_info:
+            content.liquid_info = liquid_info
+        content.last_updated = time.time()
+        
+        logger.info(f"设置孔位 {well_id} 体积: {volume}ul")
+        return True
+    
+    def add_liquid(
+        self,
+        well_id: str,
+        volume: float,
+        liquid_info: Optional[LiquidInfo] = None
+    ) -> bool:
+        """
+        向指定孔位添加液体
+        
+        Args:
+            well_id: 孔位ID
+            volume: 添加的体积 (ul)
+            liquid_info: 液体信息
+            
+        Returns:
+            bool: 是否成功添加
+        """
+        if well_id not in self.well_contents:
+            logger.error(f"孔位 {well_id} 不存在")
+            return False
+        
+        content = self.well_contents[well_id]
+        success = content.add_volume(volume, liquid_info)
+        
+        if success:
+            logger.info(f"向孔位 {well_id} 添加 {volume}ul 液体")
+        else:
+            logger.error(f"无法向孔位 {well_id} 添加 {volume}ul 液体")
+        
+        return success
+    
+    def remove_liquid(self, well_id: str, volume: float) -> bool:
+        """
+        从指定孔位移除液体
+        
+        Args:
+            well_id: 孔位ID
+            volume: 移除的体积 (ul)
+            
+        Returns:
+            bool: 是否成功移除
+        """
+        if well_id not in self.well_contents:
+            logger.error(f"孔位 {well_id} 不存在")
+            return False
+        
+        content = self.well_contents[well_id]
+        success = content.remove_volume(volume)
+        
+        if success:
+            logger.info(f"从孔位 {well_id} 移除 {volume}ul 液体")
+        else:
+            logger.error(f"无法从孔位 {well_id} 移除 {volume}ul 液体")
+        
+        return success
+    
+    def find_wells_with_volume(self, min_volume: float) -> List[str]:
+        """
+        查找具有指定最小体积的孔位
+        
+        Args:
+            min_volume: 最小体积 (ul)
+            
+        Returns:
+            List[str]: 符合条件的孔位ID列表
+        """
+        return [well_id for well_id, content in self.well_contents.items()
+                if content.volume >= min_volume]
+    
+    def find_wells_with_space(self, min_space: float) -> List[str]:
+        """
+        查找具有指定最小空间的孔位
+        
+        Args:
+            min_space: 最小空间 (ul)
+            
+        Returns:
+            List[str]: 符合条件的孔位ID列表
+        """
+        return [well_id for well_id, content in self.well_contents.items()
+                if content.available_volume >= min_space]
+    
+    def get_status_summary(self) -> Dict[str, Any]:
+        """获取资源状态摘要"""
+        return {
+            "resource_name": self.name,
+            "resource_id": self.resource_id,
+            "well_count": self.well_count,
+            "total_volume": self.total_volume,
+            "total_max_volume": self.total_max_volume,
+            "available_volume": self.available_volume,
+            "fill_percentage": (self.total_volume / self.total_max_volume) * 100.0,
+            "empty_wells": len(self.empty_wells),
+            "full_wells": len(self.full_wells),
+            "occupied_wells": len(self.occupied_wells)
+        }
+    
+    def get_detailed_status(self) -> Dict[str, Any]:
+        """获取详细状态信息"""
+        well_details = {}
+        for well_id, content in self.well_contents.items():
+            well_details[well_id] = {
+                "volume": content.volume,
+                "max_volume": content.max_volume,
+                "available_volume": content.available_volume,
+                "fill_percentage": content.fill_percentage,
+                "liquid_type": content.liquid_info.liquid_type.value,
+                "description": content.liquid_info.description,
+                "last_updated": content.last_updated
+            }
+        
+        return {
+            "summary": self.get_status_summary(),
+            "wells": well_details
+        }
+
+
+def transfer_liquid(
+    source: MaterialResource,
+    target: MaterialResource,
+    volume: float,
+    source_well_id: Optional[str] = None,
+    target_well_id: Optional[str] = None,
+    liquid_info: Optional[LiquidInfo] = None
+) -> bool:
+    """
+    在两个材料资源之间转移液体
+    
+    Args:
+        source: 源资源
+        target: 目标资源
+        volume: 转移体积 (ul)
+        source_well_id: 源孔位ID，如果为None则自动选择
+        target_well_id: 目标孔位ID，如果为None则自动选择
+        liquid_info: 液体信息
+        
+    Returns:
+        bool: 转移是否成功
+    """
+    try:
+        # 自动选择源孔位
+        if source_well_id is None:
+            available_wells = source.find_wells_with_volume(volume)
+            if not available_wells:
+                logger.error(f"源资源 {source.name} 没有足够体积的孔位")
+                return False
+            source_well_id = available_wells[0]
+        
+        # 自动选择目标孔位
+        if target_well_id is None:
+            available_wells = target.find_wells_with_space(volume)
+            if not available_wells:
+                logger.error(f"目标资源 {target.name} 没有足够空间的孔位")
+                return False
+            target_well_id = available_wells[0]
+        
+        # 检查源孔位是否有足够液体
+        if not source.get_well_content(source_well_id).can_remove_volume(volume):
+            logger.error(f"源孔位 {source_well_id} 液体不足")
+            return False
+        
+        # 检查目标孔位是否有足够空间
+        if not target.get_well_content(target_well_id).can_add_volume(volume):
+            logger.error(f"目标孔位 {target_well_id} 空间不足")
+            return False
+        
+        # 获取源液体信息
+        source_content = source.get_well_content(source_well_id)
+        transfer_liquid_info = liquid_info or source_content.liquid_info
+        
+        # 执行转移
+        if source.remove_liquid(source_well_id, volume):
+            if target.add_liquid(target_well_id, volume, transfer_liquid_info):
+                logger.info(f"成功转移 {volume}ul 液体: {source.name}[{source_well_id}] -> {target.name}[{target_well_id}]")
+                return True
+            else:
+                # 如果目标添加失败，回滚源操作
+                source.add_liquid(source_well_id, volume, source_content.liquid_info)
+                logger.error("目标添加失败，已回滚源操作")
+                return False
+        else:
+            logger.error("源移除失败")
+            return False
+    
+    except Exception as e:
+        logger.error(f"液体转移失败: {e}")
+        return False
+
+
+def create_material_resource(
+    name: str,
+    resource: Resource,
+    initial_volumes: Optional[Dict[str, float]] = None,
+    liquid_info: Optional[LiquidInfo] = None,
+    max_volume: float = 1000.0
+) -> MaterialResource:
+    """
+    创建材料资源的便捷函数
+    
+    Args:
+        name: 资源名称
+        resource: pylabrobot 资源对象
+        initial_volumes: 初始体积字典 {well_id: volume}
+        liquid_info: 液体信息
+        max_volume: 最大体积
+        
+    Returns:
+        MaterialResource: 创建的材料资源
+    """
+    material_resource = MaterialResource(
+        resource=resource,
+        default_max_volume=max_volume
+    )
+    
+    # 设置初始体积
+    if initial_volumes:
+        for well_id, volume in initial_volumes.items():
+            material_resource.set_well_volume(well_id, volume, liquid_info)
+    
+    return material_resource
+
+
+def batch_transfer_liquid(
+    transfers: List[Tuple[MaterialResource, MaterialResource, float]],
+    liquid_info: Optional[LiquidInfo] = None
+) -> List[bool]:
+    """
+    批量液体转移
+    
+    Args:
+        transfers: 转移列表 [(source, target, volume), ...]
+        liquid_info: 液体信息
+        
+    Returns:
+        List[bool]: 每个转移操作的结果
+    """
+    results = []
+    
+    for source, target, volume in transfers:
+        result = transfer_liquid(source, target, volume, liquid_info=liquid_info)
+        results.append(result)
+        
+        if not result:
+            logger.warning(f"批量转移中的操作失败: {source.name} -> {target.name}")
+    
+    success_count = sum(results)
+    logger.info(f"批量转移完成: {success_count}/{len(transfers)} 成功")
+    
+    return results

unilabos/devices/liquid_handling/laiyu/core/laiyu_liquid_res.py

@@ -0,0 +1,954 @@
+"""
+LaiYu_Liquid 资源定义模块
+
+该模块提供了 LaiYu_Liquid 工作站专用的资源定义函数，包括：
+- 各种规格的枪头架
+- 不同类型的板和容器
+- 特殊功能位置
+- 资源创建的便捷函数
+
+所有资源都基于 deck.json 中的配置参数创建。
+"""
+
+import json
+import os
+from typing import Dict, List, Optional, Tuple, Any
+from pathlib import Path
+
+# PyLabRobot 资源导入
+try:
+    from pylabrobot.resources import (
+        Resource, Deck, Plate, TipRack, Container, Tip,
+        Coordinate
+    )
+    from pylabrobot.resources.tip_rack import TipSpot
+    from pylabrobot.resources.well import Well as PlateWell
+    PYLABROBOT_AVAILABLE = True
+except ImportError:
+    # 如果 PyLabRobot 不可用，创建模拟类
+    PYLABROBOT_AVAILABLE = False
+    
+    class Resource:
+        def __init__(self, name: str):
+            self.name = name
+    
+    class Deck(Resource):
+        pass
+    
+    class Plate(Resource):
+        pass
+    
+    class TipRack(Resource):
+        pass
+    
+    class Container(Resource):
+        pass
+    
+    class Tip(Resource):
+        pass
+    
+    class TipSpot(Resource):
+        def __init__(self, name: str, **kwargs):
+            super().__init__(name)
+            # 忽略其他参数
+    
+    class PlateWell(Resource):
+        pass
+    
+    class Coordinate:
+        def __init__(self, x: float, y: float, z: float):
+            self.x = x
+            self.y = y
+            self.z = z
+
+# 本地导入
+from .LaiYu_Liquid import LaiYuLiquidDeck, LaiYuLiquidContainer, LaiYuLiquidTipRack
+
+
+def load_deck_config() -> Dict[str, Any]:
+    """
+    加载工作台配置文件
+    
+    Returns:
+        Dict[str, Any]: 配置字典
+    """
+    # 优先使用最新的deckconfig.json文件
+    config_path = Path(__file__).parent / "controllers" / "deckconfig.json"
+    
+    # 如果最新配置文件不存在，回退到旧配置文件
+    if not config_path.exists():
+        config_path = Path(__file__).parent / "config" / "deck.json"
+    
+    try:
+        with open(config_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        # 如果找不到配置文件，返回默认配置
+        return {
+            "name": "LaiYu_Liquid_Deck",
+            "size_x": 340.0,  
+            "size_y": 250.0,
+            "size_z": 160.0
+        }
+
+
+# 加载配置
+DECK_CONFIG = load_deck_config()
+
+
+class LaiYuTipRack1000(LaiYuLiquidTipRack):
+    """1000μL 枪头架"""
+    
+    def __init__(self, name: str):
+        """
+        初始化1000μL枪头架
+        
+        Args:
+            name: 枪头架名称
+        """
+        super().__init__(
+            name=name,
+            size_x=127.76,
+            size_y=85.48,
+            size_z=30.0,
+            tip_count=96,
+            tip_volume=1000.0
+        )
+        
+        # 创建枪头位置
+        self._create_tip_spots(
+            tip_count=96,
+            tip_spacing=9.0,
+            tip_type="1000ul"
+        )
+    
+    def _create_tip_spots(self, tip_count: int, tip_spacing: float, tip_type: str):
+        """
+        创建枪头位置 - 从配置文件中读取绝对坐标
+        
+        Args:
+            tip_count: 枪头数量
+            tip_spacing: 枪头间距
+            tip_type: 枪头类型
+        """
+        # 从配置文件中获取枪头架的孔位信息
+        config = DECK_CONFIG
+        tip_module = None
+        
+        # 查找枪头架模块
+        for module in config.get("children", []):
+            if module.get("type") == "tip_rack":
+                tip_module = module
+                break
+        
+        if not tip_module:
+            # 如果配置文件中没有找到，使用默认的相对坐标计算
+            rows = 8
+            cols = 12
+            
+            for row in range(rows):
+                for col in range(cols):
+                    spot_name = f"{chr(65 + row)}{col + 1:02d}"
+                    x = col * tip_spacing + tip_spacing / 2
+                    y = row * tip_spacing + tip_spacing / 2
+                    
+                    # 创建枪头 - 根据PyLabRobot或模拟类使用不同参数
+                    if PYLABROBOT_AVAILABLE:
+                        # PyLabRobot的Tip需要特定参数
+                        tip = Tip(
+                            has_filter=False,
+                            total_tip_length=95.0,  # 1000ul枪头长度
+                            maximal_volume=1000.0,  # 最大体积
+                            fitting_depth=8.0       # 安装深度
+                        )
+                    else:
+                        # 模拟类只需要name
+                        tip = Tip(name=f"tip_{spot_name}")
+                    
+                    # 创建枪头位置
+                    if PYLABROBOT_AVAILABLE:
+                        # PyLabRobot的TipSpot需要特定参数
+                        tip_spot = TipSpot(
+                            name=spot_name,
+                            size_x=9.0,  # 枪头位置宽度
+                            size_y=9.0,  # 枪头位置深度
+                            size_z=95.0,  # 枪头位置高度
+                            make_tip=lambda: tip  # 创建枪头的函数
+                        )
+                    else:
+                        # 模拟类只需要name
+                        tip_spot = TipSpot(name=spot_name)
+                    
+                    # 将吸头位置分配到吸头架
+                    self.assign_child_resource(
+                        tip_spot,
+                        location=Coordinate(x, y, 0)
+                    )
+            return
+        
+        # 使用配置文件中的绝对坐标
+        module_position = tip_module.get("position", {"x": 0, "y": 0, "z": 0})
+        
+        for well_config in tip_module.get("wells", []):
+            spot_name = well_config["id"]
+            well_pos = well_config["position"]
+            
+            # 计算相对于模块的坐标（绝对坐标减去模块位置）
+            relative_x = well_pos["x"] - module_position["x"]
+            relative_y = well_pos["y"] - module_position["y"]
+            relative_z = well_pos["z"] - module_position["z"]
+            
+            # 创建枪头 - 根据PyLabRobot或模拟类使用不同参数
+            if PYLABROBOT_AVAILABLE:
+                # PyLabRobot的Tip需要特定参数
+                tip = Tip(
+                    has_filter=False,
+                    total_tip_length=95.0,  # 1000ul枪头长度
+                    maximal_volume=1000.0,  # 最大体积
+                    fitting_depth=8.0       # 安装深度
+                )
+            else:
+                # 模拟类只需要name
+                tip = Tip(name=f"tip_{spot_name}")
+            
+            # 创建枪头位置
+            if PYLABROBOT_AVAILABLE:
+                # PyLabRobot的TipSpot需要特定参数
+                tip_spot = TipSpot(
+                    name=spot_name,
+                    size_x=well_config.get("diameter", 9.0),  # 使用配置中的直径
+                    size_y=well_config.get("diameter", 9.0),
+                    size_z=well_config.get("depth", 95.0),    # 使用配置中的深度
+                    make_tip=lambda: tip  # 创建枪头的函数
+                )
+            else:
+                # 模拟类只需要name
+                tip_spot = TipSpot(name=spot_name)
+            
+            # 将吸头位置分配到吸头架
+            self.assign_child_resource(
+                tip_spot,
+                location=Coordinate(relative_x, relative_y, relative_z)
+            )
+            
+            # 注意：在PyLabRobot中，Tip不是Resource，不需要分配给TipSpot
+            # TipSpot的make_tip函数会在需要时创建Tip
+
+
+class LaiYuTipRack200(LaiYuLiquidTipRack):
+    """200μL 枪头架"""
+    
+    def __init__(self, name: str):
+        """
+        初始化200μL枪头架
+        
+        Args:
+            name: 枪头架名称
+        """
+        super().__init__(
+            name=name,
+            size_x=127.76,
+            size_y=85.48,
+            size_z=30.0,
+            tip_count=96,
+            tip_volume=200.0
+        )
+        
+        # 创建枪头位置
+        self._create_tip_spots(
+            tip_count=96,
+            tip_spacing=9.0,
+            tip_type="200ul"
+        )
+    
+    def _create_tip_spots(self, tip_count: int, tip_spacing: float, tip_type: str):
+        """
+        创建枪头位置
+        
+        Args:
+            tip_count: 枪头数量
+            tip_spacing: 枪头间距
+            tip_type: 枪头类型
+        """
+        rows = 8
+        cols = 12
+        
+        for row in range(rows):
+            for col in range(cols):
+                spot_name = f"{chr(65 + row)}{col + 1:02d}"
+                x = col * tip_spacing + tip_spacing / 2
+                y = row * tip_spacing + tip_spacing / 2
+                
+                # 创建枪头 - 根据PyLabRobot或模拟类使用不同参数
+                if PYLABROBOT_AVAILABLE:
+                    # PyLabRobot的Tip需要特定参数
+                    tip = Tip(
+                        has_filter=False,
+                        total_tip_length=72.0,  # 200ul枪头长度
+                        maximal_volume=200.0,   # 最大体积
+                        fitting_depth=8.0       # 安装深度
+                    )
+                else:
+                    # 模拟类只需要name
+                    tip = Tip(name=f"tip_{spot_name}")
+                
+                # 创建枪头位置
+                if PYLABROBOT_AVAILABLE:
+                    # PyLabRobot的TipSpot需要特定参数
+                    tip_spot = TipSpot(
+                        name=spot_name,
+                        size_x=9.0,  # 枪头位置宽度
+                        size_y=9.0,  # 枪头位置深度
+                        size_z=72.0,  # 枪头位置高度
+                        make_tip=lambda: tip  # 创建枪头的函数
+                    )
+                else:
+                    # 模拟类只需要name
+                    tip_spot = TipSpot(name=spot_name)
+                
+                # 将吸头位置分配到吸头架
+                self.assign_child_resource(
+                    tip_spot,
+                    location=Coordinate(x, y, 0)
+                )
+                
+                # 注意：在PyLabRobot中，Tip不是Resource，不需要分配给TipSpot
+                # TipSpot的make_tip函数会在需要时创建Tip
+
+
+class LaiYu96WellPlate(LaiYuLiquidContainer):
+    """96孔板"""
+    
+    def __init__(self, name: str, lid_height: float = 0.0):
+        """
+        初始化96孔板
+        
+        Args:
+            name: 板名称
+            lid_height: 盖子高度
+        """
+        super().__init__(
+            name=name,
+            size_x=127.76,
+            size_y=85.48,
+            size_z=14.22,
+            container_type="96_well_plate",
+            volume=0.0,
+            max_volume=200.0,
+            lid_height=lid_height
+        )
+        
+        # 创建孔位
+        self._create_wells(
+            well_count=96,
+            well_volume=200.0,
+            well_spacing=9.0
+        )
+    
+    def get_size_z(self) -> float:
+        """获取孔位深度"""
+        return 10.0  # 96孔板孔位深度
+    
+    def _create_wells(self, well_count: int, well_volume: float, well_spacing: float):
+        """
+        创建孔位 - 从配置文件中读取绝对坐标
+        
+        Args:
+            well_count: 孔位数量
+            well_volume: 孔位体积
+            well_spacing: 孔位间距
+        """
+        # 从配置文件中获取96孔板的孔位信息
+        config = DECK_CONFIG
+        plate_module = None
+        
+        # 查找96孔板模块
+        for module in config.get("children", []):
+            if module.get("type") == "96_well_plate":
+                plate_module = module
+                break
+        
+        if not plate_module:
+            # 如果配置文件中没有找到，使用默认的相对坐标计算
+            rows = 8
+            cols = 12
+            
+            for row in range(rows):
+                for col in range(cols):
+                    well_name = f"{chr(65 + row)}{col + 1:02d}"
+                    x = col * well_spacing + well_spacing / 2
+                    y = row * well_spacing + well_spacing / 2
+                    
+                    # 创建孔位
+                    well = PlateWell(
+                        name=well_name,
+                        size_x=well_spacing * 0.8,
+                        size_y=well_spacing * 0.8,
+                        size_z=self.get_size_z(),
+                        max_volume=well_volume
+                    )
+                    
+                    # 添加到板
+                    self.assign_child_resource(
+                        well,
+                        location=Coordinate(x, y, 0)
+                    )
+            return
+        
+        # 使用配置文件中的绝对坐标
+        module_position = plate_module.get("position", {"x": 0, "y": 0, "z": 0})
+        
+        for well_config in plate_module.get("wells", []):
+            well_name = well_config["id"]
+            well_pos = well_config["position"]
+            
+            # 计算相对于模块的坐标（绝对坐标减去模块位置）
+            relative_x = well_pos["x"] - module_position["x"]
+            relative_y = well_pos["y"] - module_position["y"]
+            relative_z = well_pos["z"] - module_position["z"]
+            
+            # 创建孔位
+            well = PlateWell(
+                name=well_name,
+                size_x=well_config.get("diameter", 8.2) * 0.8,  # 使用配置中的直径
+                size_y=well_config.get("diameter", 8.2) * 0.8,
+                size_z=well_config.get("depth", self.get_size_z()),
+                max_volume=well_config.get("volume", well_volume)
+            )
+            
+            # 添加到板
+            self.assign_child_resource(
+                well,
+                location=Coordinate(relative_x, relative_y, relative_z)
+            )
+
+
+class LaiYuDeepWellPlate(LaiYuLiquidContainer):
+    """深孔板"""
+    
+    def __init__(self, name: str, lid_height: float = 0.0):
+        """
+        初始化深孔板
+        
+        Args:
+            name: 板名称
+            lid_height: 盖子高度
+        """
+        super().__init__(
+            name=name,
+            size_x=127.76,
+            size_y=85.48,
+            size_z=41.3,
+            container_type="deep_well_plate",
+            volume=0.0,
+            max_volume=2000.0,
+            lid_height=lid_height
+        )
+        
+        # 创建孔位
+        self._create_wells(
+            well_count=96,
+            well_volume=2000.0,
+            well_spacing=9.0
+        )
+    
+    def get_size_z(self) -> float:
+        """获取孔位深度"""
+        return 35.0  # 深孔板孔位深度
+    
+    def _create_wells(self, well_count: int, well_volume: float, well_spacing: float):
+        """
+        创建孔位 - 从配置文件中读取绝对坐标
+        
+        Args:
+            well_count: 孔位数量
+            well_volume: 孔位体积
+            well_spacing: 孔位间距
+        """
+        # 从配置文件中获取深孔板的孔位信息
+        config = DECK_CONFIG
+        plate_module = None
+        
+        # 查找深孔板模块（通常是第二个96孔板模块）
+        plate_modules = []
+        for module in config.get("children", []):
+            if module.get("type") == "96_well_plate":
+                plate_modules.append(module)
+        
+        # 如果有多个96孔板模块，选择第二个作为深孔板
+        if len(plate_modules) > 1:
+            plate_module = plate_modules[1]
+        elif len(plate_modules) == 1:
+            plate_module = plate_modules[0]
+        
+        if not plate_module:
+            # 如果配置文件中没有找到，使用默认的相对坐标计算
+            rows = 8
+            cols = 12
+            
+            for row in range(rows):
+                for col in range(cols):
+                    well_name = f"{chr(65 + row)}{col + 1:02d}"
+                    x = col * well_spacing + well_spacing / 2
+                    y = row * well_spacing + well_spacing / 2
+                    
+                    # 创建孔位
+                    well = PlateWell(
+                        name=well_name,
+                        size_x=well_spacing * 0.8,
+                        size_y=well_spacing * 0.8,
+                        size_z=self.get_size_z(),
+                        max_volume=well_volume
+                    )
+                    
+                    # 添加到板
+                    self.assign_child_resource(
+                        well,
+                        location=Coordinate(x, y, 0)
+                    )
+            return
+        
+        # 使用配置文件中的绝对坐标
+        module_position = plate_module.get("position", {"x": 0, "y": 0, "z": 0})
+        
+        for well_config in plate_module.get("wells", []):
+            well_name = well_config["id"]
+            well_pos = well_config["position"]
+            
+            # 计算相对于模块的坐标（绝对坐标减去模块位置）
+            relative_x = well_pos["x"] - module_position["x"]
+            relative_y = well_pos["y"] - module_position["y"]
+            relative_z = well_pos["z"] - module_position["z"]
+            
+            # 创建孔位
+            well = PlateWell(
+                name=well_name,
+                size_x=well_config.get("diameter", 8.2) * 0.8,  # 使用配置中的直径
+                size_y=well_config.get("diameter", 8.2) * 0.8,
+                size_z=well_config.get("depth", self.get_size_z()),
+                max_volume=well_config.get("volume", well_volume)
+            )
+            
+            # 添加到板
+            self.assign_child_resource(
+                well,
+                location=Coordinate(relative_x, relative_y, relative_z)
+            )
+
+
+class LaiYuWasteContainer(Container):
+    """废液容器"""
+    
+    def __init__(self, name: str):
+        """
+        初始化废液容器
+        
+        Args:
+            name: 容器名称
+        """
+        super().__init__(
+            name=name,
+            size_x=100.0,
+            size_y=100.0,
+            size_z=50.0,
+            max_volume=5000.0
+        )
+
+
+class LaiYuWashContainer(Container):
+    """清洗容器"""
+    
+    def __init__(self, name: str):
+        """
+        初始化清洗容器
+        
+        Args:
+            name: 容器名称
+        """
+        super().__init__(
+            name=name,
+            size_x=100.0,
+            size_y=100.0,
+            size_z=50.0,
+            max_volume=5000.0
+        )
+
+
+class LaiYuReagentContainer(Container):
+    """试剂容器"""
+    
+    def __init__(self, name: str):
+        """
+        初始化试剂容器
+        
+        Args:
+            name: 容器名称
+        """
+        super().__init__(
+            name=name,
+            size_x=50.0,
+            size_y=50.0,
+            size_z=100.0,
+            max_volume=2000.0
+        )
+
+
+class LaiYu8TubeRack(LaiYuLiquidContainer):
+    """8管试管架"""
+    
+    def __init__(self, name: str):
+        """
+        初始化8管试管架
+        
+        Args:
+            name: 试管架名称
+        """
+        super().__init__(
+            name=name,
+            size_x=151.0,
+            size_y=75.0,
+            size_z=75.0,
+            container_type="tube_rack",
+            volume=0.0,
+            max_volume=77000.0
+        )
+        
+        # 创建孔位
+        self._create_wells(
+            well_count=8,
+            well_volume=77000.0,
+            well_spacing=35.0
+        )
+    
+    def get_size_z(self) -> float:
+        """获取孔位深度"""
+        return 117.0  # 试管深度
+    
+    def _create_wells(self, well_count: int, well_volume: float, well_spacing: float):
+        """
+        创建孔位 - 从配置文件中读取绝对坐标
+        
+        Args:
+            well_count: 孔位数量
+            well_volume: 孔位体积
+            well_spacing: 孔位间距
+        """
+        # 从配置文件中获取8管试管架的孔位信息
+        config = DECK_CONFIG
+        tube_module = None
+        
+        # 查找8管试管架模块
+        for module in config.get("children", []):
+            if module.get("type") == "tube_rack":
+                tube_module = module
+                break
+        
+        if not tube_module:
+            # 如果配置文件中没有找到，使用默认的相对坐标计算
+            rows = 2
+            cols = 4
+            
+            for row in range(rows):
+                for col in range(cols):
+                    well_name = f"{chr(65 + row)}{col + 1}"
+                    x = col * well_spacing + well_spacing / 2
+                    y = row * well_spacing + well_spacing / 2
+                    
+                    # 创建孔位
+                    well = PlateWell(
+                        name=well_name,
+                        size_x=29.0,
+                        size_y=29.0,
+                        size_z=self.get_size_z(),
+                        max_volume=well_volume
+                    )
+                    
+                    # 添加到试管架
+                    self.assign_child_resource(
+                        well,
+                        location=Coordinate(x, y, 0)
+                    )
+            return
+        
+        # 使用配置文件中的绝对坐标
+        module_position = tube_module.get("position", {"x": 0, "y": 0, "z": 0})
+        
+        for well_config in tube_module.get("wells", []):
+            well_name = well_config["id"]
+            well_pos = well_config["position"]
+            
+            # 计算相对于模块的坐标（绝对坐标减去模块位置）
+            relative_x = well_pos["x"] - module_position["x"]
+            relative_y = well_pos["y"] - module_position["y"]
+            relative_z = well_pos["z"] - module_position["z"]
+            
+            # 创建孔位
+            well = PlateWell(
+                name=well_name,
+                size_x=well_config.get("diameter", 29.0),
+                size_y=well_config.get("diameter", 29.0),
+                size_z=well_config.get("depth", self.get_size_z()),
+                max_volume=well_config.get("volume", well_volume)
+            )
+            
+            # 添加到试管架
+            self.assign_child_resource(
+                well,
+                location=Coordinate(relative_x, relative_y, relative_z)
+            )
+
+
+class LaiYuTipDisposal(Resource):
+    """枪头废料位置"""
+    
+    def __init__(self, name: str):
+        """
+        初始化枪头废料位置
+        
+        Args:
+            name: 位置名称
+        """
+        super().__init__(
+            name=name,
+            size_x=100.0,
+            size_y=100.0,
+            size_z=50.0
+        )
+
+
+class LaiYuMaintenancePosition(Resource):
+    """维护位置"""
+    
+    def __init__(self, name: str):
+        """
+        初始化维护位置
+        
+        Args:
+            name: 位置名称
+        """
+        super().__init__(
+            name=name,
+            size_x=50.0,
+            size_y=50.0,
+            size_z=100.0
+        )
+
+
+# 资源创建函数
+def create_tip_rack_1000ul(name: str = "tip_rack_1000ul") -> LaiYuTipRack1000:
+    """
+    创建1000μL枪头架
+    
+    Args:
+        name: 枪头架名称
+        
+    Returns:
+        LaiYuTipRack1000: 1000μL枪头架实例
+    """
+    return LaiYuTipRack1000(name)
+
+
+def create_tip_rack_200ul(name: str = "tip_rack_200ul") -> LaiYuTipRack200:
+    """
+    创建200μL枪头架
+    
+    Args:
+        name: 枪头架名称
+        
+    Returns:
+        LaiYuTipRack200: 200μL枪头架实例
+    """
+    return LaiYuTipRack200(name)
+
+
+def create_96_well_plate(name: str = "96_well_plate", lid_height: float = 0.0) -> LaiYu96WellPlate:
+    """
+    创建96孔板
+    
+    Args:
+        name: 板名称
+        lid_height: 盖子高度
+        
+    Returns:
+        LaiYu96WellPlate: 96孔板实例
+    """
+    return LaiYu96WellPlate(name, lid_height)
+
+
+def create_deep_well_plate(name: str = "deep_well_plate", lid_height: float = 0.0) -> LaiYuDeepWellPlate:
+    """
+    创建深孔板
+    
+    Args:
+        name: 板名称
+        lid_height: 盖子高度
+        
+    Returns:
+        LaiYuDeepWellPlate: 深孔板实例
+    """
+    return LaiYuDeepWellPlate(name, lid_height)
+
+
+def create_8_tube_rack(name: str = "8_tube_rack") -> LaiYu8TubeRack:
+    """
+    创建8管试管架
+    
+    Args:
+        name: 试管架名称
+        
+    Returns:
+        LaiYu8TubeRack: 8管试管架实例
+    """
+    return LaiYu8TubeRack(name)
+
+
+def create_waste_container(name: str = "waste_container") -> LaiYuWasteContainer:
+    """
+    创建废液容器
+    
+    Args:
+        name: 容器名称
+        
+    Returns:
+        LaiYuWasteContainer: 废液容器实例
+    """
+    return LaiYuWasteContainer(name)
+
+
+def create_wash_container(name: str = "wash_container") -> LaiYuWashContainer:
+    """
+    创建清洗容器
+    
+    Args:
+        name: 容器名称
+        
+    Returns:
+        LaiYuWashContainer: 清洗容器实例
+    """
+    return LaiYuWashContainer(name)
+
+
+def create_reagent_container(name: str = "reagent_container") -> LaiYuReagentContainer:
+    """
+    创建试剂容器
+    
+    Args:
+        name: 容器名称
+        
+    Returns:
+        LaiYuReagentContainer: 试剂容器实例
+    """
+    return LaiYuReagentContainer(name)
+
+
+def create_tip_disposal(name: str = "tip_disposal") -> LaiYuTipDisposal:
+    """
+    创建枪头废料位置
+    
+    Args:
+        name: 位置名称
+        
+    Returns:
+        LaiYuTipDisposal: 枪头废料位置实例
+    """
+    return LaiYuTipDisposal(name)
+
+
+def create_maintenance_position(name: str = "maintenance_position") -> LaiYuMaintenancePosition:
+    """
+    创建维护位置
+    
+    Args:
+        name: 位置名称
+        
+    Returns:
+        LaiYuMaintenancePosition: 维护位置实例
+    """
+    return LaiYuMaintenancePosition(name)
+
+
+def create_standard_deck() -> LaiYuLiquidDeck:
+    """
+    创建标准工作台配置
+    
+    Returns:
+        LaiYuLiquidDeck: 配置好的工作台实例
+    """
+    # 从配置文件创建工作台
+    deck = LaiYuLiquidDeck(config=DECK_CONFIG)
+    
+    return deck
+
+
+def get_resource_by_name(deck: LaiYuLiquidDeck, name: str) -> Optional[Resource]:
+    """
+    根据名称获取资源
+    
+    Args:
+        deck: 工作台实例
+        name: 资源名称
+        
+    Returns:
+        Optional[Resource]: 找到的资源，如果不存在则返回None
+    """
+    for child in deck.children:
+        if child.name == name:
+            return child
+    return None
+
+
+def get_resources_by_type(deck: LaiYuLiquidDeck, resource_type: type) -> List[Resource]:
+    """
+    根据类型获取资源列表
+    
+    Args:
+        deck: 工作台实例
+        resource_type: 资源类型
+        
+    Returns:
+        List[Resource]: 匹配类型的资源列表
+    """
+    return [child for child in deck.children if isinstance(child, resource_type)]
+
+
+def list_all_resources(deck: LaiYuLiquidDeck) -> Dict[str, List[str]]:
+    """
+    列出所有资源
+    
+    Args:
+        deck: 工作台实例
+        
+    Returns:
+        Dict[str, List[str]]: 按类型分组的资源名称字典
+    """
+    resources = {
+        "tip_racks": [],
+        "plates": [],
+        "containers": [],
+        "positions": []
+    }
+    
+    for child in deck.children:
+        if isinstance(child, (LaiYuTipRack1000, LaiYuTipRack200)):
+            resources["tip_racks"].append(child.name)
+        elif isinstance(child, (LaiYu96WellPlate, LaiYuDeepWellPlate)):
+            resources["plates"].append(child.name)
+        elif isinstance(child, (LaiYuWasteContainer, LaiYuWashContainer, LaiYuReagentContainer)):
+            resources["containers"].append(child.name)
+        elif isinstance(child, (LaiYuTipDisposal, LaiYuMaintenancePosition)):
+            resources["positions"].append(child.name)
+    
+    return resources
+
+
+# 导出的类别名（向后兼容）
+TipRack1000ul = LaiYuTipRack1000
+TipRack200ul = LaiYuTipRack200
+Plate96Well = LaiYu96WellPlate
+Plate96DeepWell = LaiYuDeepWellPlate
+TubeRack8 = LaiYu8TubeRack
+WasteContainer = LaiYuWasteContainer
+WashContainer = LaiYuWashContainer
+ReagentContainer = LaiYuReagentContainer
+TipDisposal = LaiYuTipDisposal
+MaintenancePosition = LaiYuMaintenancePosition

unilabos/devices/liquid_handling/laiyu/docs/CHANGELOG.md

@@ -0,0 +1,69 @@
+# 更新日志
+
+本文档记录了 LaiYu_Liquid 模块的所有重要变更。
+
+## [1.0.0] - 2024-01-XX
+
+### 新增功能
+- ✅ 完整的液体处理工作站集成
+- ✅ RS485 通信协议支持
+- ✅ SOPA 气动式移液器驱动
+- ✅ XYZ 三轴步进电机控制
+- ✅ PyLabRobot 兼容后端
+- ✅ 标准化资源管理系统
+- ✅ 96孔板、离心管架、枪头架支持
+- ✅ RViz 可视化后端
+- ✅ 完整的配置管理系统
+- ✅ 抽象协议实现
+- ✅ 生产级错误处理和日志记录
+
+### 技术特性
+- **硬件支持**: SOPA移液器 + XYZ三轴运动平台
+- **通信协议**: RS485总线，波特率115200
+- **坐标系统**: 机械坐标与工作坐标自动转换
+- **安全机制**: 限位保护、紧急停止、错误恢复
+- **兼容性**: 完全兼容 PyLabRobot 框架
+
+### 文件结构
+```
+LaiYu_Liquid/
+├── core/
+│   └── LaiYu_Liquid.py      # 主模块文件
+├── __init__.py              # 模块初始化
+├── abstract_protocol.py    # 抽象协议
+├── laiyu_liquid_res.py     # 资源管理
+├── rviz_backend.py         # RViz后端
+├── backend/                # 后端驱动
+├── config/                 # 配置文件
+├── controllers/           # 控制器
+├── docs/                  # 技术文档
+└── drivers/               # 底层驱动
+```
+
+### 已知问题
+- 无
+
+### 依赖要求
+- Python 3.8+
+- PyLabRobot
+- pyserial
+- asyncio
+
+---
+
+## 版本说明
+
+### 版本号格式
+采用语义化版本控制 (Semantic Versioning): `MAJOR.MINOR.PATCH`
+
+- **MAJOR**: 不兼容的API变更
+- **MINOR**: 向后兼容的功能新增
+- **PATCH**: 向后兼容的问题修复
+
+### 变更类型
+- **新增功能**: 新的功能特性
+- **变更**: 现有功能的变更
+- **弃用**: 即将移除的功能
+- **移除**: 已移除的功能
+- **修复**: 问题修复
+- **安全**: 安全相关的修复

unilabos/devices/liquid_handling/laiyu/docs/hardware/SOPA气动式移液器RS485控制指令.md

@@ -0,0 +1,267 @@
+# SOPA气动式移液器RS485控制指令合集
+
+## 1. RS485通信基本配置
+
+### 1.1 支持的设备型号
+- **仅SC-STxxx-00-13支持RS485通信**
+- 其他型号主要使用CAN通信
+
+### 1.2 通信参数
+- **波特率**: 9600, 115200（默认值）
+- **地址范围**: 1~254个设备，255为广播地址
+- **通信接口**: RS485差分信号
+
+### 1.3 引脚分配（10位LIF连接器）
+- **引脚7**: RS485+ (RS485通信正极)
+- **引脚8**: RS485- (RS485通信负极)
+
+## 2. RS485通信协议格式
+
+### 2.1 发送数据格式
+```
+头码 | 地址 | 命令/数据 | 尾码 | 校验和
+```
+
+### 2.2 从机回应格式
+```
+头码 | 地址 | 数据（固定9字节） | 尾码 | 校验和
+```
+
+### 2.3 格式详细说明
+- **头码**: 
+  - 终端调试: '/' (0x2F)
+  - OEM通信: '[' (0x5B) 
+- **地址**: 设备节点地址，1~254，多字节ASCII（注意：地址不可为47，69，91）
+- **命令/数据**: ASCII格式的命令字符串
+- **尾码**: 'E' (0x45)
+- **校验和**: 以上数据的累加值，1字节
+
+## 3. 初始化和基本控制指令
+
+### 3.1 初始化指令
+```bash
+# 初始化活塞驱动机构
+HE
+
+# 示例（OEM通信）：
+# 主机发送: 5B 32 48 45 1A
+# 从机回应开始: 2F 02 06 0A 30 00 00 00 00 00 00 45 B6
+# 从机回应完成: 2F 02 06 00 30 00 00 00 00 00 00 45 AC
+```
+
+### 3.2 枪头操作指令
+```bash
+# 顶出枪头
+RE
+
+# 枪头检测状态报告
+Q28  # 返回枪头存在状态（0=不存在，1=存在）
+```
+
+## 4. 移液控制指令
+
+### 4.1 位置控制指令
+```bash
+# 绝对位置移动（微升）
+A[n]E
+# 示例：移动到位置0
+A0E
+
+# 相对抽吸（向上移动）
+P[n]E
+# 示例：抽吸200微升
+P200E
+
+# 相对分配（向下移动）  
+D[n]E
+# 示例：分配200微升
+D200E
+```
+
+### 4.2 速度设置指令
+```bash
+# 设置最高速度（0.1ul/秒为单位）
+s[n]E
+# 示例：设置最高速度为2000（200ul/秒）
+s2000E
+
+# 设置启动速度
+b[n]E
+# 示例：设置启动速度为100（10ul/秒）
+b100E
+
+# 设置断流速度
+c[n]E
+# 示例：设置断流速度为100（10ul/秒）
+c100E
+
+# 设置加速度
+a[n]E
+# 示例：设置加速度为30000
+a30000E
+```
+
+## 5. 液体检测和安全控制指令
+
+### 5.1 吸排液检测控制
+```bash
+# 开启吸排液检测
+f1E  # 开启
+f0E  # 关闭
+
+# 设置空吸门限
+$[n]E
+# 示例：设置空吸门限为4
+$4E
+
+# 设置泡沫门限
+![n]E
+# 示例：设置泡沫门限为20
+!20E
+
+# 设置堵塞门限
+%[n]E
+# 示例：设置堵塞门限为350
+%350E
+```
+
+### 5.2 液位检测指令
+```bash
+# 压力式液位检测
+m0E  # 设置为压力探测模式
+L[n]E  # 执行液位检测，[n]为灵敏度(3~40)
+k[n]E  # 设置检测速度(100~2000)
+
+# 电容式液位检测  
+m1E  # 设置为电容探测模式
+```
+
+## 6. 状态查询和报告指令
+
+### 6.1 基本状态查询
+```bash
+# 查询固件版本
+V
+
+# 查询设备状态
+Q[n]
+# 常用查询参数：
+Q01  # 报告加速度
+Q02  # 报告启动速度  
+Q03  # 报告断流速度
+Q06  # 报告最大速度
+Q08  # 报告节点地址
+Q11  # 报告波特率
+Q18  # 报告当前位置
+Q28  # 报告枪头存在状态
+Q29  # 报告校准系数
+Q30  # 报告空吸门限
+Q31  # 报告堵针门限
+Q32  # 报告泡沫门限
+```
+
+## 7. 配置和校准指令
+
+### 7.1 校准参数设置
+```bash
+# 设置校准系数
+j[n]E
+# 示例：设置校准系数为1.04
+j1.04E
+
+# 设置补偿偏差
+e[n]E  
+# 示例：设置补偿偏差为2.03
+e2.03E
+
+# 设置吸头容量
+C[n]E
+# 示例：设置1000ul吸头
+C1000E
+```
+
+### 7.2 高级控制参数
+```bash
+# 设置回吸粘度
+][n]E
+# 示例：设置回吸粘度为30
+]30E
+
+# 延时控制
+M[n]E
+# 示例：延时1000毫秒
+M1000E
+```
+
+## 8. 复合操作指令示例
+
+### 8.1 标准移液操作
+```bash
+# 完整的200ul移液操作
+a30000b200c200s2000P200E
+# 解析：设置加速度30000 + 启动速度200 + 断流速度200 + 最高速度2000 + 抽吸200ul + 执行
+```
+
+### 8.2 带检测的移液操作
+```bash
+# 带空吸检测的200ul抽吸
+a30000b200c200s2000f1P200f0E
+# 解析：设置参数 + 开启检测 + 抽吸200ul + 关闭检测 + 执行
+```
+
+### 8.3 液面检测操作
+```bash
+# 压力式液面检测
+m0k200L5E
+# 解析：压力模式 + 检测速度200 + 灵敏度5 + 执行检测
+
+# 电容式液面检测  
+m1L3E
+# 解析：电容模式 + 灵敏度3 + 执行检测
+```
+
+## 9. 错误处理
+
+### 9.1 状态字节说明
+- **00h**: 无错误
+- **01h**: 上次动作未完成
+- **02h**: 设备未初始化  
+- **03h**: 设备过载
+- **04h**: 无效指令
+- **05h**: 液位探测故障
+- **0Dh**: 空吸
+- **0Eh**: 堵针
+- **10h**: 泡沫
+- **11h**: 吸液超过吸头容量
+
+### 9.2 错误查询
+```bash
+# 查询当前错误状态
+Q  # 返回状态字节和错误代码
+```
+
+## 10. 通信示例
+
+### 10.1 基本通信流程
+1. **执行命令**: 主机发送命令 → 从机确认 → 从机执行 → 从机回应完成
+2. **读取数据**: 主机发送查询 → 从机确认 → 从机返回数据
+
+### 10.2 快速指令表
+| 操作 | 指令 | 说明 |
+|------|------|------|
+| 初始化 | `HE` | 初始化设备 |
+| 退枪头 | `RE` | 顶出枪头 |
+| 吸液200ul | `a30000b200c200s2000P200E` | 基本吸液 |
+| 带检测吸液 | `a30000b200c200s2000f1P200f0E` | 开启空吸检测 |
+| 吐液200ul | `a300000b500c500s6000D200E` | 基本分配 |
+| 压力液面检测 | `m0k200L5E` | pLLD检测 |
+| 电容液面检测 | `m1L3E` | cLLD检测 |
+
+## 11. 注意事项
+
+1. **地址限制**: RS485地址不可设为47、69、91
+2. **校验和**: 终端调试时不关心校验和，OEM通信需要校验
+3. **ASCII格式**: 所有命令和参数都使用ASCII字符
+4. **执行指令**: 大部分命令需要以'E'结尾才能执行
+5. **设备支持**: 只有SC-STxxx-00-13型号支持RS485通信
+6. **波特率设置**: 默认115200，可设置为9600

unilabos/devices/liquid_handling/laiyu/docs/hardware/步进电机控制指令.md

@@ -0,0 +1,162 @@
+# 步进电机B系列控制指令详解
+
+## 基本通信参数
+- **通信方式**: RS485
+- **协议**: Modbus
+- **波特率**: 115200 (默认)
+- **数据位**: 8位
+- **停止位**: 1位
+- **校验位**: 无
+- **默认站号**: 1 (可设置1-254)
+
+## 支持的功能码
+- **03H**: 读取寄存器
+- **06H**: 写入单个寄存器  
+- **10H**: 写入多个寄存器
+
+## 寄存器地址表
+
+### 状态监控寄存器 (只读)
+| 地址 | 功能码 | 内容 | 说明 |
+|------|--------|------|------|
+| 00H | 03H | 电机状态 | 0000H-待机/到位, 0001H-运行中, 0002H-碰撞停, 0003H-正光电停, 0004H-反光电停 |
+| 01H | 03H | 实际步数高位 | 当前电机位置的高16位 |
+| 02H | 03H | 实际步数低位 | 当前电机位置的低16位 |
+| 03H | 03H | 实际速度 | 当前转速 (rpm) |
+| 05H | 03H | 电流 | 当前工作电流 (mA) |
+
+### 控制寄存器 (读写)
+| 地址 | 功能码 | 内容 | 说明 |
+|------|--------|------|------|
+| 04H | 03H/06H/10H | 急停指令 | 紧急停止控制 |
+| 06H | 03H/06H/10H | 失能控制 | 1-使能, 0-失能 |
+| 07H | 03H/06H/10H | PWM输出 | 0-1000对应0%-100%占空比 |
+| 0EH | 03H/06H/10H | 单圈绝对值归零 | 归零指令 |
+| 0FH | 03H/06H/10H | 归零指令 | 定点模式归零速度设置 |
+
+### 位置模式寄存器
+| 地址 | 功能码 | 内容 | 说明 |
+|------|--------|------|------|
+| 10H | 03H/06H/10H | 目标步数高位 | 目标位置高16位 |
+| 11H | 03H/06H/10H | 目标步数低位 | 目标位置低16位 |
+| 12H | 03H/06H/10H | 保留 | - |
+| 13H | 03H/06H/10H | 速度 | 运行速度 (rpm) |
+| 14H | 03H/06H/10H | 加速度 | 0-60000 rpm/s |
+| 15H | 03H/06H/10H | 精度 | 到位精度设置 |
+
+### 速度模式寄存器
+| 地址 | 功能码 | 内容 | 说明 |
+|------|--------|------|------|
+| 60H | 03H/06H/10H | 保留 | - |
+| 61H | 03H/06H/10H | 速度 | 正值正转，负值反转 |
+| 62H | 03H/06H/10H | 加速度 | 0-60000 rpm/s |
+
+### 设备参数寄存器
+| 地址 | 功能码 | 内容 | 默认值 | 说明 |
+|------|--------|------|--------|------|
+| E0H | 03H/06H/10H | 设备地址 | 0001H | Modbus从站地址 |
+| E1H | 03H/06H/10H | 堵转电流 | 0BB8H | 堵转检测电流阈值 |
+| E2H | 03H/06H/10H | 保留 | 0258H | - |
+| E3H | 03H/06H/10H | 每圈步数 | 0640H | 细分设置 |
+| E4H | 03H/06H/10H | 限位开关使能 | F000H | 1-使能, 0-禁用 |
+| E5H | 03H/06H/10H | 堵转逻辑 | 0000H | 00-断电, 01-对抗 |
+| E6H | 03H/06H/10H | 堵转时间 | 0000H | 堵转检测时间(ms) |
+| E7H | 03H/06H/10H | 默认速度 | 1388H | 上电默认速度 |
+| E8H | 03H/06H/10H | 默认加速度 | EA60H | 上电默认加速度 |
+| E9H | 03H/06H/10H | 默认精度 | 0064H | 上电默认精度 |
+| EAH | 03H/06H/10H | 波特率高位 | 0001H | 通信波特率设置 |
+| EBH | 03H/06H/10H | 波特率低位 | C200H | 115200对应01C200H |
+
+### 版本信息寄存器 (只读)
+| 地址 | 功能码 | 内容 | 说明 |
+|------|--------|------|------|
+| F0H | 03H | 版本号 | 固件版本信息 |
+| F1H-F4H | 03H | 型号 | 产品型号信息 |
+
+## 常用控制指令示例
+
+### 读取电机状态
+```
+发送: 01 03 00 00 00 01 84 0A
+接收: 01 03 02 00 01 79 84
+说明: 电机状态为0001H (正在运行)
+```
+
+### 读取当前位置
+```
+发送: 01 03 00 01 00 02 95 CB  
+接收: 01 03 04 00 19 00 00 2B F4
+说明: 当前位置为1638400步 (100圈)
+```
+
+### 停止电机
+```
+发送: 01 10 00 04 00 01 02 00 00 A7 D4
+接收: 01 10 00 04 00 01 40 08
+说明: 急停指令
+```
+
+### 位置模式运动
+```
+发送: 01 10 00 10 00 06 0C 00 19 00 00 00 00 13 88 00 00 00 00 9F FB
+接收: 01 10 00 10 00 06 41 CE
+说明: 以5000rpm速度运动到1638400步位置
+```
+
+### 速度模式 - 正转
+```
+发送: 01 10 00 60 00 04 08 00 00 13 88 00 FA 00 00 F4 77
+接收: 01 10 00 60 00 04 C1 D4
+说明: 以5000rpm速度正转
+```
+
+### 速度模式 - 反转
+```
+发送: 01 10 00 60 00 04 08 00 00 EC 78 00 FA 00 00 A0 6D
+接收: 01 10 00 60 00 04 C1 D4
+说明: 以5000rpm速度反转 (EC78H = -5000)
+```
+
+### 设置设备地址
+```
+发送: 00 06 00 E0 00 02 C9 F1
+接收: 00 06 00 E0 00 02 C9 F1
+说明: 将设备地址设置为2
+```
+
+## 错误码
+| 状态码 | 含义 |
+|--------|------|
+| 0001H | 功能码错误 |
+| 0002H | 地址错误 |
+| 0003H | 长度错误 |
+
+## CRC校验算法
+```c
+public static byte[] ModBusCRC(byte[] data, int offset, int cnt) {
+    int wCrc = 0x0000FFFF;
+    byte[] CRC = new byte[2];
+    for (int i = 0; i < cnt; i++) {
+        wCrc ^= ((data[i + offset]) & 0xFF);
+        for (int j = 0; j < 8; j++) {
+            if ((wCrc & 0x00000001) == 1) {
+                wCrc >>= 1;
+                wCrc ^= 0x0000A001;
+            } else {
+                wCrc >>= 1;
+            }
+        }
+    }
+    CRC[1] = (byte) ((wCrc & 0x0000FF00) >> 8);
+    CRC[0] = (byte) (wCrc & 0x000000FF);
+    return CRC;
+}
+```
+
+## 注意事项
+1. 所有16位数据采用大端序传输
+2. 步数计算: 实际步数 = 高位<<16 | 低位
+3. 负数使用补码表示
+4. PWM输出K脚: 0%开漏, 100%接地, 其他输出1KHz PWM
+5. 光电开关需使用NPN开漏型
+6. 限位开关: LF正向, LB反向

unilabos/devices/liquid_handling/laiyu/docs/readme.md

@@ -0,0 +1,285 @@
+# LaiYu_Liquid 液体处理工作站 - 生产就绪版本
+
+## 概述
+
+LaiYu_Liquid 是一个完全集成到 UniLabOS 系统的自动化液体处理工作站，基于 RS485 通信协议，专为精确的液体分配和转移操作而设计。本模块已完成生产环境部署准备，提供完整的硬件控制、资源管理和标准化接口。
+
+## 系统组成
+
+### 硬件组件
+- **XYZ三轴运动平台**: 3个RS485步进电机驱动（地址：X轴=0x01, Y轴=0x02, Z轴=0x03）
+- **SOPA气动式移液器**: RS485总线控制，支持精密液体处理操作
+- **通信接口**: RS485转USB模块，默认波特率115200
+- **机械结构**: 稳固工作台面，支持离心管架、96孔板等标准实验耗材
+
+### 软件架构
+- **驱动层**: 底层硬件通信驱动，支持RS485协议
+- **控制层**: 高级控制逻辑和坐标系管理
+- **抽象层**: 完全符合UniLabOS标准的液体处理接口
+- **资源层**: 标准化的实验器具和耗材管理
+
+## 🎯 生产就绪组件
+
+### ✅ 核心驱动程序 (`drivers/`)
+- **`sopa_pipette_driver.py`** - SOPA移液器完整驱动
+  - 支持液体吸取、分配、检测
+  - 完整的错误处理和状态管理
+  - 生产级别的通信协议实现
+  
+- **`xyz_stepper_driver.py`** - XYZ三轴步进电机驱动
+  - 精确的位置控制和运动规划
+  - 安全限位和错误检测
+  - 高性能运动控制算法
+
+### ✅ 高级控制器 (`controllers/`)
+- **`pipette_controller.py`** - 移液控制器
+  - 封装高级液体处理功能
+  - 支持多种液体类型和处理参数
+  - 智能错误恢复机制
+  
+- **`xyz_controller.py`** - XYZ运动控制器
+  - 坐标系管理和转换
+  - 运动路径优化
+  - 安全运动控制
+
+### ✅ UniLabOS集成 (`core/LaiYu_Liquid.py`)
+- **完整的液体处理抽象接口**
+- **标准化的资源管理系统**
+- **与PyLabRobot兼容的后端实现**
+- **生产级别的错误处理和日志记录**
+
+### ✅ 资源管理系统
+- **`laiyu_liquid_res.py`** - 标准化资源定义
+  - 96孔板、离心管架、枪头架等标准器具
+  - 自动化的资源创建和配置函数
+  - 与工作台布局的完美集成
+
+### ✅ 配置管理 (`config/`)
+- **`config/deck.json`** - 工作台布局配置
+  - 精确的空间定义和槽位管理
+  - 支持多种实验器具的标准化放置
+  - 可扩展的配置架构
+
+- **`__init__.py`** - 模块集成和导出
+  - 完整的API导出和版本管理
+  - 依赖检查和安装验证
+  - 专业的模块信息展示
+
+### ✅ 可视化支持
+- **`rviz_backend.py`** - RViz可视化后端
+  - 实时运动状态可视化
+  - 液体处理过程监控
+  - 与ROS系统的无缝集成
+
+## 🚀 核心功能特性
+
+### 液体处理能力
+- **精密体积控制**: 支持1-1000μL精确分配
+- **多种液体类型**: 水性、有机溶剂、粘稠液体等
+- **智能检测**: 液位检测、气泡检测、堵塞检测
+- **自动化流程**: 完整的吸取-转移-分配工作流
+
+### 运动控制系统
+- **三轴精密定位**: 微米级精度控制
+- **路径优化**: 智能运动规划和碰撞避免
+- **安全机制**: 限位保护、紧急停止、错误恢复
+- **坐标系管理**: 工作坐标与机械坐标的自动转换
+
+### 资源管理
+- **标准化器具**: 支持96孔板、离心管架、枪头架等
+- **状态跟踪**: 实时监控液体体积、枪头状态等
+- **自动配置**: 基于JSON的灵活配置系统
+- **扩展性**: 易于添加新的器具类型
+
+## 📁 目录结构
+
+```
+LaiYu_Liquid/
+├── __init__.py              # 模块初始化和API导出
+├── readme.md               # 本文档
+├── rviz_backend.py         # RViz可视化后端
+├── backend/                # 后端驱动模块
+│   ├── __init__.py
+│   └── laiyu_backend.py    # PyLabRobot兼容后端
+├── core/                   # 核心模块
+│   ├── core/
+│   │   └── LaiYu_Liquid.py    # 主设备类
+│   ├── abstract_protocol.py # 抽象协议
+│   └── laiyu_liquid_res.py # 设备资源定义
+├── config/                 # 配置文件目录
+│   └── deck.json          # 工作台布局配置
+├── controllers/           # 高级控制器
+│   ├── __init__.py
+│   ├── pipette_controller.py  # 移液控制器
+│   └── xyz_controller.py      # XYZ运动控制器
+├── docs/                  # 技术文档
+│   ├── SOPA气动式移液器RS485控制指令.md
+│   ├── 步进电机控制指令.md
+│   └── hardware/          # 硬件相关文档
+├── drivers/               # 底层驱动程序
+│   ├── __init__.py
+│   ├── sopa_pipette_driver.py  # SOPA移液器驱动
+│   └── xyz_stepper_driver.py   # XYZ步进电机驱动
+└── tests/                 # 测试文件
+```
+
+## 🔧 快速开始
+
+### 1. 安装和验证
+
+```python
+# 验证模块安装
+from unilabos.devices.laiyu_liquid import (
+    LaiYuLiquid,
+    LaiYuLiquidConfig,
+    create_quick_setup,
+    print_module_info
+)
+
+# 查看模块信息
+print_module_info()
+
+# 快速创建默认资源
+resources = create_quick_setup()
+print(f"已创建 {len(resources)} 个资源")
+```
+
+### 2. 基本使用示例
+
+```python
+from unilabos.devices.LaiYu_Liquid import (
+    create_quick_setup, 
+    create_96_well_plate,
+    create_laiyu_backend
+)
+
+# 快速创建默认资源
+resources = create_quick_setup()
+print(f"创建了以下资源: {list(resources.keys())}")
+
+# 创建96孔板
+plate_96 = create_96_well_plate("test_plate")
+print(f"96孔板包含 {len(plate_96.children)} 个孔位")
+
+# 创建后端实例（用于PyLabRobot集成）
+backend = create_laiyu_backend("LaiYu_Device")
+print(f"后端设备: {backend.name}")
+```
+
+### 3. 后端驱动使用
+
+```python
+from unilabos.devices.laiyu_liquid.backend import create_laiyu_backend
+
+# 创建后端实例
+backend = create_laiyu_backend("LaiYu_Liquid_Station")
+
+# 连接设备
+await backend.connect()
+
+# 设备归位
+await backend.home_device()
+
+# 获取设备状态
+status = await backend.get_status()
+print(f"设备状态: {status}")
+
+# 断开连接
+await backend.disconnect()
+```
+
+### 4. 资源管理示例
+
+```python
+from unilabos.devices.LaiYu_Liquid import (
+    create_centrifuge_tube_rack,
+    create_tip_rack,
+    load_deck_config
+)
+
+# 加载工作台配置
+deck_config = load_deck_config()
+print(f"工作台尺寸: {deck_config['size_x']}x{deck_config['size_y']}mm")
+
+# 创建不同类型的资源
+tube_rack = create_centrifuge_tube_rack("sample_rack")
+tip_rack = create_tip_rack("tip_rack_200ul")
+
+print(f"离心管架: {tube_rack.name}, 容量: {len(tube_rack.children)} 个位置")
+print(f"枪头架: {tip_rack.name}, 容量: {len(tip_rack.children)} 个枪头")
+```
+
+## 🔍 技术架构
+
+### 坐标系统
+- **机械坐标**: 基于步进电机的原始坐标系统
+- **工作坐标**: 用户友好的实验室坐标系统
+- **自动转换**: 透明的坐标系转换和校准
+
+### 通信协议
+- **RS485总线**: 高可靠性工业通信标准
+- **Modbus协议**: 标准化的设备通信协议
+- **错误检测**: 完整的通信错误检测和恢复
+
+### 安全机制
+- **限位保护**: 硬件和软件双重限位保护
+- **紧急停止**: 即时停止所有运动和操作
+- **状态监控**: 实时设备状态监控和报警
+
+## 🧪 验证和测试
+
+### 功能验证
+```python
+# 验证模块安装
+from unilabos.devices.laiyu_liquid import validate_installation
+validate_installation()
+
+# 查看模块信息
+from unilabos.devices.laiyu_liquid import print_module_info
+print_module_info()
+```
+
+### 硬件连接测试
+```python
+# 测试SOPA移液器连接
+from unilabos.devices.laiyu_liquid.drivers import SOPAPipette, SOPAConfig
+
+config = SOPAConfig(port="/dev/cu.usbserial-3130", address=4)
+pipette = SOPAPipette(config)
+success = pipette.connect()
+print(f"SOPA连接状态: {'成功' if success else '失败'}")
+```
+
+## 📚 维护和支持
+
+### 日志记录
+- **结构化日志**: 使用Python logging模块的专业日志记录
+- **错误追踪**: 详细的错误信息和堆栈跟踪
+- **性能监控**: 操作时间和性能指标记录
+
+### 配置管理
+- **JSON配置**: 灵活的JSON格式配置文件
+- **参数验证**: 自动配置参数验证和错误提示
+- **热重载**: 支持配置文件的动态重载
+
+### 扩展性
+- **模块化设计**: 易于扩展和定制的模块化架构
+- **插件接口**: 支持第三方插件和扩展
+- **API兼容**: 向后兼容的API设计
+
+## 📞 技术支持
+
+### 常见问题
+1. **串口权限问题**: 确保用户有串口访问权限
+2. **依赖库安装**: 使用pip安装所需的Python库
+3. **设备连接**: 检查RS485适配器和设备地址配置
+
+### 联系方式
+- **技术文档**: 查看UniLabOS官方文档
+- **问题反馈**: 通过GitHub Issues提交问题
+- **社区支持**: 加入UniLabOS开发者社区
+
+---
+
+**LaiYu_Liquid v1.0.0** - 生产就绪的液体处理工作站集成模块  
+© 2024 UniLabOS Project. All rights reserved.

unilabos/devices/liquid_handling/laiyu/drivers/__init__.py

@@ -0,0 +1,30 @@
+"""
+LaiYu_Liquid 驱动程序模块
+
+该模块包含了LaiYu_Liquid液体处理工作站的硬件驱动程序：
+- SOPA移液器驱动程序
+- XYZ步进电机驱动程序
+"""
+
+# SOPA移液器驱动程序导入
+from .sopa_pipette_driver import SOPAPipette, SOPAConfig, SOPAStatusCode
+
+# XYZ步进电机驱动程序导入  
+from .xyz_stepper_driver import StepperMotorDriver, XYZStepperController, MotorAxis, MotorStatus
+
+__all__ = [
+    # SOPA移液器
+    "SOPAPipette",
+    "SOPAConfig",
+    "SOPAStatusCode",
+    
+    # XYZ步进电机
+    "StepperMotorDriver", 
+    "XYZStepperController",
+    "MotorAxis",
+    "MotorStatus",
+]
+
+__version__ = "1.0.0"
+__author__ = "LaiYu_Liquid Driver Team"
+__description__ = "LaiYu_Liquid 硬件驱动程序集合"

unilabos/devices/liquid_handling/laiyu/drivers/xyz_stepper_driver.py

@@ -0,0 +1,663 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+XYZ三轴步进电机B系列驱动程序
+支持RS485通信，Modbus协议
+"""
+
+import serial
+import struct
+import time
+import logging
+from typing import Optional, Tuple, Dict, Any
+from enum import Enum
+from dataclasses import dataclass
+
+# 配置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class MotorAxis(Enum):
+    """电机轴枚举"""
+    X = 1
+    Y = 2
+    Z = 3
+
+
+class MotorStatus(Enum):
+    """电机状态枚举"""
+    STANDBY = 0x0000  # 待机/到位
+    RUNNING = 0x0001  # 运行中
+    COLLISION_STOP = 0x0002  # 碰撞停
+    FORWARD_LIMIT_STOP = 0x0003  # 正光电停
+    REVERSE_LIMIT_STOP = 0x0004  # 反光电停
+
+
+class ModbusFunction(Enum):
+    """Modbus功能码"""
+    READ_HOLDING_REGISTERS = 0x03
+    WRITE_SINGLE_REGISTER = 0x06
+    WRITE_MULTIPLE_REGISTERS = 0x10
+
+
+@dataclass
+class MotorPosition:
+    """电机位置信息"""
+    steps: int
+    speed: int
+    current: int
+    status: MotorStatus
+
+
+class ModbusException(Exception):
+    """Modbus通信异常"""
+    pass
+
+
+class StepperMotorDriver:
+    """步进电机驱动器基类"""
+    
+    # 寄存器地址常量
+    REG_STATUS = 0x00
+    REG_POSITION_HIGH = 0x01
+    REG_POSITION_LOW = 0x02
+    REG_ACTUAL_SPEED = 0x03
+    REG_EMERGENCY_STOP = 0x04
+    REG_CURRENT = 0x05
+    REG_ENABLE = 0x06
+    REG_PWM_OUTPUT = 0x07
+    REG_ZERO_SINGLE = 0x0E
+    REG_ZERO_COMMAND = 0x0F
+    
+    # 位置模式寄存器
+    REG_TARGET_POSITION_HIGH = 0x10
+    REG_TARGET_POSITION_LOW = 0x11
+    REG_POSITION_SPEED = 0x13
+    REG_POSITION_ACCELERATION = 0x14
+    REG_POSITION_PRECISION = 0x15
+    
+    # 速度模式寄存器
+    REG_SPEED_MODE_SPEED = 0x61
+    REG_SPEED_MODE_ACCELERATION = 0x62
+    
+    # 设备参数寄存器
+    REG_DEVICE_ADDRESS = 0xE0
+    REG_DEFAULT_SPEED = 0xE7
+    REG_DEFAULT_ACCELERATION = 0xE8
+    
+    def __init__(self, port: str, baudrate: int = 115200, timeout: float = 1.0):
+        """
+        初始化步进电机驱动器
+        
+        Args:
+            port: 串口端口名
+            baudrate: 波特率
+            timeout: 通信超时时间
+        """
+        self.port = port
+        self.baudrate = baudrate
+        self.timeout = timeout
+        self.serial_conn: Optional[serial.Serial] = None
+        
+    def connect(self) -> bool:
+        """
+        建立串口连接
+        
+        Returns:
+            连接是否成功
+        """
+        try:
+            self.serial_conn = serial.Serial(
+                port=self.port,
+                baudrate=self.baudrate,
+                bytesize=serial.EIGHTBITS,
+                parity=serial.PARITY_NONE,
+                stopbits=serial.STOPBITS_ONE,
+                timeout=self.timeout
+            )
+            logger.info(f"已连接到串口: {self.port}")
+            return True
+        except Exception as e:
+            logger.error(f"串口连接失败: {e}")
+            return False
+    
+    def disconnect(self) -> None:
+        """关闭串口连接"""
+        if self.serial_conn and self.serial_conn.is_open:
+            self.serial_conn.close()
+            logger.info("串口连接已关闭")
+    
+    def __enter__(self):
+        """上下文管理器入口"""
+        if self.connect():
+            return self
+        raise ModbusException("无法建立串口连接")
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """上下文管理器出口"""
+        self.disconnect()
+    
+    @staticmethod
+    def calculate_crc(data: bytes) -> bytes:
+        """
+        计算Modbus CRC校验码
+        
+        Args:
+            data: 待校验的数据
+            
+        Returns:
+            CRC校验码 (2字节)
+        """
+        crc = 0xFFFF
+        for byte in data:
+            crc ^= byte
+            for _ in range(8):
+                if crc & 0x0001:
+                    crc >>= 1
+                    crc ^= 0xA001
+                else:
+                    crc >>= 1
+        return struct.pack('<H', crc)
+    
+    def _send_command(self, slave_addr: int, data: bytes) -> bytes:
+        """
+        发送Modbus命令并接收响应
+        
+        Args:
+            slave_addr: 从站地址
+            data: 命令数据
+            
+        Returns:
+            响应数据
+            
+        Raises:
+            ModbusException: 通信异常
+        """
+        if not self.serial_conn or not self.serial_conn.is_open:
+            raise ModbusException("串口未连接")
+        
+        # 构建完整命令
+        command = bytes([slave_addr]) + data
+        crc = self.calculate_crc(command)
+        full_command = command + crc
+        
+        # 清空接收缓冲区
+        self.serial_conn.reset_input_buffer()
+        
+        # 发送命令
+        self.serial_conn.write(full_command)
+        logger.debug(f"发送命令: {' '.join(f'{b:02X}' for b in full_command)}")
+        
+        # 等待响应
+        time.sleep(0.01)  # 短暂延时
+        
+        # 读取响应
+        response = self.serial_conn.read(256)  # 最大读取256字节
+        if not response:
+            raise ModbusException("未收到响应")
+        
+        logger.debug(f"接收响应: {' '.join(f'{b:02X}' for b in response)}")
+        
+        # 验证CRC
+        if len(response) < 3:
+            raise ModbusException("响应数据长度不足")
+        
+        data_part = response[:-2]
+        received_crc = response[-2:]
+        calculated_crc = self.calculate_crc(data_part)
+        
+        if received_crc != calculated_crc:
+            raise ModbusException(f"CRC校验失败{response}")
+        
+        return response
+    
+    def read_registers(self, slave_addr: int, start_addr: int, count: int) -> list:
+        """
+        读取保持寄存器
+        
+        Args:
+            slave_addr: 从站地址
+            start_addr: 起始地址
+            count: 寄存器数量
+            
+        Returns:
+            寄存器值列表
+        """
+        data = struct.pack('>BHH', ModbusFunction.READ_HOLDING_REGISTERS.value, start_addr, count)
+        response = self._send_command(slave_addr, data)
+        
+        if len(response) < 5:
+            raise ModbusException("响应长度不足")
+        
+        if response[1] != ModbusFunction.READ_HOLDING_REGISTERS.value:
+            raise ModbusException(f"功能码错误: {response[1]:02X}")
+        
+        byte_count = response[2]
+        values = []
+        for i in range(0, byte_count, 2):
+            value = struct.unpack('>H', response[3+i:5+i])[0]
+            values.append(value)
+        
+        return values
+    
+    def write_single_register(self, slave_addr: int, addr: int, value: int) -> bool:
+        """
+        写入单个寄存器
+        
+        Args:
+            slave_addr: 从站地址
+            addr: 寄存器地址
+            value: 寄存器值
+            
+        Returns:
+            写入是否成功
+        """
+        data = struct.pack('>BHH', ModbusFunction.WRITE_SINGLE_REGISTER.value, addr, value)
+        response = self._send_command(slave_addr, data)
+        
+        return len(response) >= 8 and response[1] == ModbusFunction.WRITE_SINGLE_REGISTER.value
+    
+    def write_multiple_registers(self, slave_addr: int, start_addr: int, values: list) -> bool:
+        """
+        写入多个寄存器
+        
+        Args:
+            slave_addr: 从站地址
+            start_addr: 起始地址
+            values: 寄存器值列表
+            
+        Returns:
+            写入是否成功
+        """
+        byte_count = len(values) * 2
+        data = struct.pack('>BHHB', ModbusFunction.WRITE_MULTIPLE_REGISTERS.value, 
+                          start_addr, len(values), byte_count)
+        
+        for value in values:
+            data += struct.pack('>H', value)
+        
+        response = self._send_command(slave_addr, data)
+        
+        return len(response) >= 8 and response[1] == ModbusFunction.WRITE_MULTIPLE_REGISTERS.value
+
+
+class XYZStepperController(StepperMotorDriver):
+    """XYZ三轴步进电机控制器"""
+    
+    # 电机配置常量
+    STEPS_PER_REVOLUTION = 16384  # 每圈步数
+    
+    def __init__(self, port: str, baudrate: int = 115200, timeout: float = 1.0):
+        """
+        初始化XYZ三轴步进电机控制器
+        
+        Args:
+            port: 串口端口名
+            baudrate: 波特率
+            timeout: 通信超时时间
+        """
+        super().__init__(port, baudrate, timeout)
+        self.axis_addresses = {
+            MotorAxis.X: 1,
+            MotorAxis.Y: 2,
+            MotorAxis.Z: 3
+        }
+    
+    def degrees_to_steps(self, degrees: float) -> int:
+        """
+        将角度转换为步数
+        
+        Args:
+            degrees: 角度值
+            
+        Returns:
+            对应的步数
+        """
+        return int(degrees * self.STEPS_PER_REVOLUTION / 360.0)
+    
+    def steps_to_degrees(self, steps: int) -> float:
+        """
+        将步数转换为角度
+        
+        Args:
+            steps: 步数
+            
+        Returns:
+            对应的角度值
+        """
+        return steps * 360.0 / self.STEPS_PER_REVOLUTION
+    
+    def revolutions_to_steps(self, revolutions: float) -> int:
+        """
+        将圈数转换为步数
+        
+        Args:
+            revolutions: 圈数
+            
+        Returns:
+            对应的步数
+        """
+        return int(revolutions * self.STEPS_PER_REVOLUTION)
+    
+    def steps_to_revolutions(self, steps: int) -> float:
+        """
+        将步数转换为圈数
+        
+        Args:
+            steps: 步数
+            
+        Returns:
+            对应的圈数
+        """
+        return steps / self.STEPS_PER_REVOLUTION
+    
+    def get_motor_status(self, axis: MotorAxis) -> MotorPosition:
+        """
+        获取电机状态信息
+        
+        Args:
+            axis: 电机轴
+            
+        Returns:
+            电机位置信息
+        """
+        addr = self.axis_addresses[axis]
+        
+        # 读取状态、位置、速度、电流
+        values = self.read_registers(addr, self.REG_STATUS, 6)
+        
+        status = MotorStatus(values[0])
+        position_high = values[1]
+        position_low = values[2]
+        speed = values[3]
+        current = values[5]
+        
+        # 合并32位位置
+        position = (position_high << 16) | position_low
+        # 处理有符号数
+        if position > 0x7FFFFFFF:
+            position -= 0x100000000
+        
+        return MotorPosition(position, speed, current, status)
+    
+    def emergency_stop(self, axis: MotorAxis) -> bool:
+        """
+        紧急停止电机
+        
+        Args:
+            axis: 电机轴
+            
+        Returns:
+            操作是否成功
+        """
+        addr = self.axis_addresses[axis]
+        return self.write_single_register(addr, self.REG_EMERGENCY_STOP, 0x0000)
+    
+    def enable_motor(self, axis: MotorAxis, enable: bool = True) -> bool:
+        """
+        使能/失能电机
+        
+        Args:
+            axis: 电机轴
+            enable: True为使能，False为失能
+            
+        Returns:
+            操作是否成功
+        """
+        addr = self.axis_addresses[axis]
+        value = 0x0001 if enable else 0x0000
+        return self.write_single_register(addr, self.REG_ENABLE, value)
+    
+    def move_to_position(self, axis: MotorAxis, position: int, speed: int = 5000, 
+                        acceleration: int = 1000, precision: int = 100) -> bool:
+        """
+        移动到指定位置
+        
+        Args:
+            axis: 电机轴
+            position: 目标位置(步数)
+            speed: 运行速度(rpm)
+            acceleration: 加速度(rpm/s)
+            precision: 到位精度
+            
+        Returns:
+            操作是否成功
+        """
+        addr = self.axis_addresses[axis]
+        
+        # 处理32位位置
+        if position < 0:
+            position += 0x100000000
+        
+        position_high = (position >> 16) & 0xFFFF
+        position_low = position & 0xFFFF
+        
+        values = [
+            position_high,     # 目标位置高位
+            position_low,      # 目标位置低位
+            0x0000,           # 保留
+            speed,            # 速度
+            acceleration,     # 加速度
+            precision         # 精度
+        ]
+        
+        return self.write_multiple_registers(addr, self.REG_TARGET_POSITION_HIGH, values)
+    
+    def set_speed_mode(self, axis: MotorAxis, speed: int, acceleration: int = 1000) -> bool:
+        """
+        设置速度模式运行
+        
+        Args:
+            axis: 电机轴
+            speed: 运行速度(rpm)，正值正转，负值反转
+            acceleration: 加速度(rpm/s)
+            
+        Returns:
+            操作是否成功
+        """
+        addr = self.axis_addresses[axis]
+        
+        # 处理负数
+        if speed < 0:
+            speed = 0x10000 + speed  # 补码表示
+        
+        values = [0x0000, speed, acceleration, 0x0000]
+        
+        return self.write_multiple_registers(addr, 0x60, values)
+    
+    def home_axis(self, axis: MotorAxis) -> bool:
+        """
+        轴归零操作
+        
+        Args:
+            axis: 电机轴
+            
+        Returns:
+            操作是否成功
+        """
+        addr = self.axis_addresses[axis]
+        return self.write_single_register(addr, self.REG_ZERO_SINGLE, 0x0001)
+    
+    def wait_for_completion(self, axis: MotorAxis, timeout: float = 30.0) -> bool:
+        """
+        等待电机运动完成
+        
+        Args:
+            axis: 电机轴
+            timeout: 超时时间(秒)
+            
+        Returns:
+            是否在超时前完成
+        """
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            status = self.get_motor_status(axis)
+            if status.status == MotorStatus.STANDBY:
+                return True
+            time.sleep(0.1)
+        
+        logger.warning(f"{axis.name}轴运动超时")
+        return False
+    
+    def move_xyz(self, x: Optional[int] = None, y: Optional[int] = None, z: Optional[int] = None,
+                speed: int = 5000, acceleration: int = 1000) -> Dict[MotorAxis, bool]:
+        """
+        同时控制XYZ轴移动
+        
+        Args:
+            x: X轴目标位置
+            y: Y轴目标位置
+            z: Z轴目标位置
+            speed: 运行速度
+            acceleration: 加速度
+            
+        Returns:
+            各轴操作结果字典
+        """
+        results = {}
+        
+        if x is not None:
+            results[MotorAxis.X] = self.move_to_position(MotorAxis.X, x, speed, acceleration)
+        
+        if y is not None:
+            results[MotorAxis.Y] = self.move_to_position(MotorAxis.Y, y, speed, acceleration)
+        
+        if z is not None:
+            results[MotorAxis.Z] = self.move_to_position(MotorAxis.Z, z, speed, acceleration)
+        
+        return results
+    
+    def move_xyz_degrees(self, x_deg: Optional[float] = None, y_deg: Optional[float] = None, 
+                        z_deg: Optional[float] = None, speed: int = 5000, 
+                        acceleration: int = 1000) -> Dict[MotorAxis, bool]:
+        """
+        使用角度值同时移动多个轴到指定位置
+        
+        Args:
+            x_deg: X轴目标角度（度）
+            y_deg: Y轴目标角度（度）
+            z_deg: Z轴目标角度（度）
+            speed: 移动速度
+            acceleration: 加速度
+            
+        Returns:
+            各轴移动操作结果
+        """
+        # 将角度转换为步数
+        x_steps = self.degrees_to_steps(x_deg) if x_deg is not None else None
+        y_steps = self.degrees_to_steps(y_deg) if y_deg is not None else None
+        z_steps = self.degrees_to_steps(z_deg) if z_deg is not None else None
+        
+        return self.move_xyz(x_steps, y_steps, z_steps, speed, acceleration)
+    
+    def move_xyz_revolutions(self, x_rev: Optional[float] = None, y_rev: Optional[float] = None, 
+                           z_rev: Optional[float] = None, speed: int = 5000, 
+                           acceleration: int = 1000) -> Dict[MotorAxis, bool]:
+        """
+        使用圈数值同时移动多个轴到指定位置
+        
+        Args:
+            x_rev: X轴目标圈数
+            y_rev: Y轴目标圈数
+            z_rev: Z轴目标圈数
+            speed: 移动速度
+            acceleration: 加速度
+            
+        Returns:
+            各轴移动操作结果
+        """
+        # 将圈数转换为步数
+        x_steps = self.revolutions_to_steps(x_rev) if x_rev is not None else None
+        y_steps = self.revolutions_to_steps(y_rev) if y_rev is not None else None
+        z_steps = self.revolutions_to_steps(z_rev) if z_rev is not None else None
+        
+        return self.move_xyz(x_steps, y_steps, z_steps, speed, acceleration)
+    
+    def move_to_position_degrees(self, axis: MotorAxis, degrees: float, speed: int = 5000, 
+                               acceleration: int = 1000, precision: int = 100) -> bool:
+        """
+        使用角度值移动单个轴到指定位置
+        
+        Args:
+            axis: 电机轴
+            degrees: 目标角度（度）
+            speed: 移动速度
+            acceleration: 加速度
+            precision: 精度
+            
+        Returns:
+            移动操作是否成功
+        """
+        steps = self.degrees_to_steps(degrees)
+        return self.move_to_position(axis, steps, speed, acceleration, precision)
+    
+    def move_to_position_revolutions(self, axis: MotorAxis, revolutions: float, speed: int = 5000, 
+                                   acceleration: int = 1000, precision: int = 100) -> bool:
+        """
+        使用圈数值移动单个轴到指定位置
+        
+        Args:
+            axis: 电机轴
+            revolutions: 目标圈数
+            speed: 移动速度
+            acceleration: 加速度
+            precision: 精度
+            
+        Returns:
+            移动操作是否成功
+        """
+        steps = self.revolutions_to_steps(revolutions)
+        return self.move_to_position(axis, steps, speed, acceleration, precision)
+    
+    def stop_all_axes(self) -> Dict[MotorAxis, bool]:
+        """
+        紧急停止所有轴
+        
+        Returns:
+            各轴停止结果字典
+        """
+        results = {}
+        for axis in MotorAxis:
+            results[axis] = self.emergency_stop(axis)
+        return results
+    
+    def enable_all_axes(self, enable: bool = True) -> Dict[MotorAxis, bool]:
+        """
+        使能/失能所有轴
+        
+        Args:
+            enable: True为使能，False为失能
+            
+        Returns:
+            各轴操作结果字典
+        """
+        results = {}
+        for axis in MotorAxis:
+            results[axis] = self.enable_motor(axis, enable)
+        return results
+    
+    def get_all_positions(self) -> Dict[MotorAxis, MotorPosition]:
+        """
+        获取所有轴的位置信息
+        
+        Returns:
+            各轴位置信息字典
+        """
+        positions = {}
+        for axis in MotorAxis:
+            positions[axis] = self.get_motor_status(axis)
+        return positions
+    
+    def home_all_axes(self) -> Dict[MotorAxis, bool]:
+        """
+        所有轴归零
+        
+        Returns:
+            各轴归零结果字典
+        """
+        results = {}
+        for axis in MotorAxis:
+            results[axis] = self.home_axis(axis)
+        return results

unilabos/devices/liquid_handling/laiyu/laiyu.py

@@ -0,0 +1,218 @@
+import asyncio
+import collections
+import contextlib
+import json
+import time
+from typing import Any, List, Dict, Optional, TypedDict, Union, Sequence, Iterator, Literal
+
+from pylabrobot.liquid_handling import (
+    LiquidHandlerBackend,
+    Pickup,
+    SingleChannelAspiration,
+    Drop,
+    SingleChannelDispense,
+    PickupTipRack,
+    DropTipRack,
+    MultiHeadAspirationPlate, ChatterBoxBackend, LiquidHandlerChatterboxBackend,
+)
+from pylabrobot.liquid_handling.standard import (
+    MultiHeadAspirationContainer,
+    MultiHeadDispenseContainer,
+    MultiHeadDispensePlate,
+    ResourcePickup,
+    ResourceMove,
+    ResourceDrop,
+)
+from pylabrobot.resources import Tip, Deck, Plate, Well, TipRack, Resource, Container, Coordinate, TipSpot, Trash
+
+from unilabos.devices.liquid_handling.liquid_handler_abstract import LiquidHandlerAbstract
+from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
+from unilabos.devices.liquid_handling.laiyu.backend.laiyu_v_backend import UniLiquidHandlerLaiyuBackend
+
+
+
+class TransformXYZDeck(Deck):
+    """Laiyu 的专用 Deck 类，继承自 Deck。
+
+    该类定义了 Laiyu 的工作台布局和槽位信息。
+    """
+
+    def __init__(self, name: str, size_x: float, size_y: float, size_z: float):
+        super().__init__(name, size_x, size_y, size_z)
+        self.name = name
+
+class TransformXYZBackend(LiquidHandlerBackend):
+    def __init__(self, name: str, host: str, port: int, timeout: float):
+        super().__init__()
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+
+class TransformXYZRvizBackend(UniLiquidHandlerRvizBackend):
+    def __init__(self, name: str, channel_num: int):
+        super().__init__(channel_num)
+        self.name = name
+
+
+class TransformXYZContainer(Plate, TipRack):
+    """Laiyu 的专用 Container 类，继承自 Plate和TipRack。
+
+    该类定义了 Laiyu 的工作台布局和槽位信息。
+    """
+
+    def __init__(
+        self,
+        name: str,
+        size_x: float,
+        size_y: float,
+        size_z: float,
+        category: str,
+        ordering: collections.OrderedDict,
+        model: Optional[str] = None,
+    ):
+        super().__init__(name, size_x, size_y, size_z, category=category, ordering=ordering, model=model)
+        self._unilabos_state = {}
+
+    def load_state(self, state: Dict[str, Any]) -> None:
+        """从给定的状态加载工作台信息。"""
+        super().load_state(state)
+        self._unilabos_state = state
+
+    def serialize_state(self) -> Dict[str, Dict[str, Any]]:
+        data = super().serialize_state()
+        data.update(self._unilabos_state)
+        return data
+
+class TransformXYZHandler(LiquidHandlerAbstract):
+    support_touch_tip = False
+
+    def __init__(self, deck: Deck, host: str = "127.0.0.1", port: int = 9999, timeout: float = 10.0, channel_num=1, simulator=True, **backend_kwargs):
+        # Handle case where deck is passed as a dict (from serialization)
+        if isinstance(deck, dict):
+            # Try to create a TransformXYZDeck from the dict
+            if 'name' in deck and 'size_x' in deck and 'size_y' in deck and 'size_z' in deck:
+                deck = TransformXYZDeck(
+                    name=deck['name'],
+                    size_x=deck.get('size_x', 100),
+                    size_y=deck.get('size_y', 100),
+                    size_z=deck.get('size_z', 100)
+                )
+            else:
+                # Fallback: create a basic deck
+                deck = TransformXYZDeck(name='deck', size_x=100, size_y=100, size_z=100)
+
+        if simulator:
+            self._unilabos_backend = TransformXYZRvizBackend(name="laiyu",channel_num=channel_num)
+        else:
+            self._unilabos_backend = TransformXYZBackend(name="laiyu",host=host, port=port, timeout=timeout)
+        super().__init__(backend=self._unilabos_backend, deck=deck, simulator=simulator, channel_num=channel_num)
+
+    async def add_liquid(
+        self,
+        asp_vols: Union[List[float], float],
+        dis_vols: Union[List[float], float],
+        reagent_sources: Sequence[Container],
+        targets: Sequence[Container],
+        *,
+        use_channels: Optional[List[int]] = None,
+        flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Optional[List[Coordinate]] = None,
+        liquid_height: Optional[List[Optional[float]]] = None,
+        blow_out_air_volume: Optional[List[Optional[float]]] = None,
+        spread: Optional[Literal["wide", "tight", "custom"]] = "wide",
+        is_96_well: bool = False,
+        delays: Optional[List[int]] = None,
+        mix_time: Optional[int] = None,
+        mix_vol: Optional[int] = None,
+        mix_rate: Optional[int] = None,
+        mix_liquid_height: Optional[float] = None,
+        none_keys: List[str] = [],
+    ):
+        pass
+
+    async def aspirate(
+        self,
+        resources: Sequence[Container],
+        vols: List[float],
+        use_channels: Optional[List[int]] = None,
+        flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Optional[List[Coordinate]] = None,
+        liquid_height: Optional[List[Optional[float]]] = None,
+        blow_out_air_volume: Optional[List[Optional[float]]] = None,
+        spread: Literal["wide", "tight", "custom"] = "wide",
+        **backend_kwargs,
+    ):
+        pass
+
+    async def dispense(
+        self,
+        resources: Sequence[Container],
+        vols: List[float],
+        use_channels: Optional[List[int]] = None,
+        flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Optional[List[Coordinate]] = None,
+        liquid_height: Optional[List[Optional[float]]] = None,
+        blow_out_air_volume: Optional[List[Optional[float]]] = None,
+        spread: Literal["wide", "tight", "custom"] = "wide",
+        **backend_kwargs,
+    ):
+        pass
+
+    async def drop_tips(
+        self,
+        tip_spots: Sequence[Union[TipSpot, Trash]],
+        use_channels: Optional[List[int]] = None,
+        offsets: Optional[List[Coordinate]] = None,
+        allow_nonzero_volume: bool = False,
+        **backend_kwargs,
+    ):
+        pass
+
+    async def mix(
+        self,
+        targets: Sequence[Container],
+        mix_time: int = None,
+        mix_vol: Optional[int] = None,
+        height_to_bottom: Optional[float] = None,
+        offsets: Optional[Coordinate] = None,
+        mix_rate: Optional[float] = None,
+        none_keys: List[str] = [],
+    ):
+        pass
+
+    async def pick_up_tips(
+        self,
+        tip_spots: List[TipSpot],
+        use_channels: Optional[List[int]] = None,
+        offsets: Optional[List[Coordinate]] = None,
+        **backend_kwargs,
+    ):
+        pass
+
+    async def transfer_liquid(
+        self,
+        sources: Sequence[Container],
+        targets: Sequence[Container],
+        tip_racks: Sequence[TipRack],
+        *,
+        use_channels: Optional[List[int]] = None,
+        asp_vols: Union[List[float], float],
+        dis_vols: Union[List[float], float],
+        asp_flow_rates: Optional[List[Optional[float]]] = None,
+        dis_flow_rates: Optional[List[Optional[float]]] = None,
+        offsets: Optional[List[Coordinate]] = None,
+        touch_tip: bool = False,
+        liquid_height: Optional[List[Optional[float]]] = None,
+        blow_out_air_volume: Optional[List[Optional[float]]] = None,
+        spread: Literal["wide", "tight", "custom"] = "wide",
+        is_96_well: bool = False,
+        mix_stage: Optional[Literal["none", "before", "after", "both"]] = "none",
+        mix_times: Optional[List[int]] = None,
+        mix_vol: Optional[int] = None,
+        mix_rate: Optional[int] = None,
+        mix_liquid_height: Optional[float] = None,
+        delays: Optional[List[int]] = None,
+        none_keys: List[str] = [],
+    ):
+        pass
+    

unilabos/devices/liquid_handling/laiyu/tests/__init__.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+LaiYu液体处理设备测试模块
+
+该模块包含LaiYu液体处理设备的测试用例：
+- test_deck_config.py: 工作台配置测试
+
+作者: UniLab团队
+版本: 2.0.0
+"""
+
+__all__ = []

unilabos/devices/liquid_handling/laiyu/tests/test_deck_config.py

@@ -0,0 +1,315 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+测试脚本：验证更新后的deck配置是否正常工作
+"""
+
+import sys
+import os
+import json
+
+# 添加项目根目录到Python路径
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, project_root)
+
+def test_config_loading():
+    """测试配置文件加载功能"""
+    print("=" * 50)
+    print("测试配置文件加载功能")
+    print("=" * 50)
+    
+    try:
+        # 直接测试配置文件加载
+        config_path = os.path.join(os.path.dirname(__file__), "controllers", "deckconfig.json")
+        fallback_path = os.path.join(os.path.dirname(__file__), "config", "deck.json")
+        
+        config = None
+        config_source = ""
+        
+        if os.path.exists(config_path):
+            with open(config_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+            config_source = "config/deckconfig.json"
+        elif os.path.exists(fallback_path):
+            with open(fallback_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+            config_source = "config/deck.json"
+        else:
+            print("❌ 配置文件不存在")
+            return False
+        
+        print(f"✅ 配置文件加载成功: {config_source}")
+        print(f"   - 甲板尺寸: {config.get('size_x', 'N/A')} x {config.get('size_y', 'N/A')} x {config.get('size_z', 'N/A')}")
+        print(f"   - 子模块数量: {len(config.get('children', []))}")
+        
+        # 检查各个模块是否存在
+        modules = config.get('children', [])
+        module_types = [module.get('type') for module in modules]
+        module_names = [module.get('name') for module in modules]
+        
+        print(f"   - 模块类型: {', '.join(set(filter(None, module_types)))}")
+        print(f"   - 模块名称: {', '.join(filter(None, module_names))}")
+        
+        return config
+    except Exception as e:
+        print(f"❌ 配置文件加载失败: {e}")
+        return None
+
+def test_module_coordinates(config):
+    """测试各模块的坐标信息"""
+    print("\n" + "=" * 50)
+    print("测试模块坐标信息")
+    print("=" * 50)
+    
+    if not config:
+        print("❌ 配置为空，无法测试")
+        return False
+    
+    modules = config.get('children', [])
+    
+    for module in modules:
+        module_name = module.get('name', '未知模块')
+        module_type = module.get('type', '未知类型')
+        position = module.get('position', {})
+        size = module.get('size', {})
+        
+        print(f"\n模块: {module_name} ({module_type})")
+        print(f"   - 位置: ({position.get('x', 0)}, {position.get('y', 0)}, {position.get('z', 0)})")
+        print(f"   - 尺寸: {size.get('x', 0)} x {size.get('y', 0)} x {size.get('z', 0)}")
+        
+        # 检查孔位信息
+        wells = module.get('wells', [])
+        if wells:
+            print(f"   - 孔位数量: {len(wells)}")
+            
+            # 显示前几个和后几个孔位的坐标
+            sample_wells = wells[:3] + wells[-3:] if len(wells) > 6 else wells
+            for well in sample_wells:
+                well_id = well.get('id', '未知')
+                well_pos = well.get('position', {})
+                print(f"     {well_id}: ({well_pos.get('x', 0)}, {well_pos.get('y', 0)}, {well_pos.get('z', 0)})")
+        else:
+            print(f"   - 无孔位信息")
+    
+    return True
+
+def test_coordinate_ranges(config):
+    """测试坐标范围的合理性"""
+    print("\n" + "=" * 50)
+    print("测试坐标范围合理性")
+    print("=" * 50)
+    
+    if not config:
+        print("❌ 配置为空，无法测试")
+        return False
+    
+    deck_size = {
+        'x': config.get('size_x', 340),
+        'y': config.get('size_y', 250),
+        'z': config.get('size_z', 160)
+    }
+    
+    print(f"甲板尺寸: {deck_size['x']} x {deck_size['y']} x {deck_size['z']}")
+    
+    modules = config.get('children', [])
+    all_coordinates = []
+    
+    for module in modules:
+        module_name = module.get('name', '未知模块')
+        wells = module.get('wells', [])
+        
+        for well in wells:
+            well_pos = well.get('position', {})
+            x, y, z = well_pos.get('x', 0), well_pos.get('y', 0), well_pos.get('z', 0)
+            all_coordinates.append((x, y, z, f"{module_name}:{well.get('id', '未知')}"))
+    
+    if not all_coordinates:
+        print("❌ 没有找到任何坐标信息")
+        return False
+    
+    # 计算坐标范围
+    x_coords = [coord[0] for coord in all_coordinates]
+    y_coords = [coord[1] for coord in all_coordinates]
+    z_coords = [coord[2] for coord in all_coordinates]
+    
+    x_range = (min(x_coords), max(x_coords))
+    y_range = (min(y_coords), max(y_coords))
+    z_range = (min(z_coords), max(z_coords))
+    
+    print(f"X坐标范围: {x_range[0]:.2f} ~ {x_range[1]:.2f}")
+    print(f"Y坐标范围: {y_range[0]:.2f} ~ {y_range[1]:.2f}")
+    print(f"Z坐标范围: {z_range[0]:.2f} ~ {z_range[1]:.2f}")
+    
+    # 检查是否超出甲板范围
+    issues = []
+    if x_range[1] > deck_size['x']:
+        issues.append(f"X坐标超出甲板范围: {x_range[1]} > {deck_size['x']}")
+    if y_range[1] > deck_size['y']:
+        issues.append(f"Y坐标超出甲板范围: {y_range[1]} > {deck_size['y']}")
+    if z_range[1] > deck_size['z']:
+        issues.append(f"Z坐标超出甲板范围: {z_range[1]} > {deck_size['z']}")
+    
+    if x_range[0] < 0:
+        issues.append(f"X坐标为负值: {x_range[0]}")
+    if y_range[0] < 0:
+        issues.append(f"Y坐标为负值: {y_range[0]}")
+    if z_range[0] < 0:
+        issues.append(f"Z坐标为负值: {z_range[0]}")
+    
+    if issues:
+        print("⚠️  发现坐标问题:")
+        for issue in issues:
+            print(f"   - {issue}")
+        return False
+    else:
+        print("✅ 所有坐标都在合理范围内")
+        return True
+
+def test_well_spacing(config):
+    """测试孔位间距的一致性"""
+    print("\n" + "=" * 50)
+    print("测试孔位间距一致性")
+    print("=" * 50)
+    
+    if not config:
+        print("❌ 配置为空，无法测试")
+        return False
+    
+    modules = config.get('children', [])
+    
+    for module in modules:
+        module_name = module.get('name', '未知模块')
+        module_type = module.get('type', '未知类型')
+        wells = module.get('wells', [])
+        
+        if len(wells) < 2:
+            continue
+        
+        print(f"\n模块: {module_name} ({module_type})")
+        
+        # 计算相邻孔位的间距
+        spacings_x = []
+        spacings_y = []
+        
+        # 按行列排序孔位
+        wells_by_row = {}
+        for well in wells:
+            well_id = well.get('id', '')
+            if len(well_id) >= 3:  # 如A01格式
+                row = well_id[0]
+                col = int(well_id[1:])
+                if row not in wells_by_row:
+                    wells_by_row[row] = {}
+                wells_by_row[row][col] = well
+        
+        # 计算同行相邻孔位的X间距
+        for row, cols in wells_by_row.items():
+            sorted_cols = sorted(cols.keys())
+            for i in range(len(sorted_cols) - 1):
+                col1, col2 = sorted_cols[i], sorted_cols[i + 1]
+                if col2 == col1 + 1:  # 相邻列
+                    pos1 = cols[col1].get('position', {})
+                    pos2 = cols[col2].get('position', {})
+                    spacing = abs(pos2.get('x', 0) - pos1.get('x', 0))
+                    spacings_x.append(spacing)
+        
+        # 计算同列相邻孔位的Y间距
+        cols_by_row = {}
+        for well in wells:
+            well_id = well.get('id', '')
+            if len(well_id) >= 3:
+                row = ord(well_id[0]) - ord('A')
+                col = int(well_id[1:])
+                if col not in cols_by_row:
+                    cols_by_row[col] = {}
+                cols_by_row[col][row] = well
+        
+        for col, rows in cols_by_row.items():
+            sorted_rows = sorted(rows.keys())
+            for i in range(len(sorted_rows) - 1):
+                row1, row2 = sorted_rows[i], sorted_rows[i + 1]
+                if row2 == row1 + 1:  # 相邻行
+                    pos1 = rows[row1].get('position', {})
+                    pos2 = rows[row2].get('position', {})
+                    spacing = abs(pos2.get('y', 0) - pos1.get('y', 0))
+                    spacings_y.append(spacing)
+        
+        # 检查间距一致性
+        if spacings_x:
+            avg_x = sum(spacings_x) / len(spacings_x)
+            max_diff_x = max(abs(s - avg_x) for s in spacings_x)
+            print(f"   - X方向平均间距: {avg_x:.2f}mm, 最大偏差: {max_diff_x:.2f}mm")
+            
+        if spacings_y:
+            avg_y = sum(spacings_y) / len(spacings_y)
+            max_diff_y = max(abs(s - avg_y) for s in spacings_y)
+            print(f"   - Y方向平均间距: {avg_y:.2f}mm, 最大偏差: {max_diff_y:.2f}mm")
+    
+    return True
+
+def main():
+    """主测试函数"""
+    print("LaiYu液体处理设备配置测试")
+    print("测试时间:", os.popen('date').read().strip())
+    
+    # 运行所有测试
+    tests = [
+        ("配置文件加载", test_config_loading),
+    ]
+    
+    config = None
+    results = []
+    
+    for test_name, test_func in tests:
+        try:
+            if test_name == "配置文件加载":
+                result = test_func()
+                config = result if result else None
+                results.append((test_name, bool(result)))
+            else:
+                result = test_func(config)
+                results.append((test_name, result))
+        except Exception as e:
+            print(f"❌ 测试 {test_name} 执行失败: {e}")
+            results.append((test_name, False))
+    
+    # 如果配置加载成功，运行其他测试
+    if config:
+        additional_tests = [
+            ("模块坐标信息", test_module_coordinates),
+            ("坐标范围合理性", test_coordinate_ranges),
+            ("孔位间距一致性", test_well_spacing)
+        ]
+        
+        for test_name, test_func in additional_tests:
+            try:
+                result = test_func(config)
+                results.append((test_name, result))
+            except Exception as e:
+                print(f"❌ 测试 {test_name} 执行失败: {e}")
+                results.append((test_name, False))
+    
+    # 输出测试总结
+    print("\n" + "=" * 50)
+    print("测试总结")
+    print("=" * 50)
+    
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+    
+    for test_name, result in results:
+        status = "✅ 通过" if result else "❌ 失败"
+        print(f"   {test_name}: {status}")
+    
+    print(f"\n总计: {passed}/{total} 个测试通过")
+    
+    if passed == total:
+        print("🎉 所有测试通过！配置更新成功。")
+        return True
+    else:
+        print("⚠️  部分测试失败，需要进一步检查。")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

unilabos/devices/liquid_handling/liquid_handler_abstract.py

@@ -7,6 +7,8 @@ from collections import Counter
 from typing import List, Sequence, Optional, Literal, Union, Iterator, Dict, Any, Callable, Set, cast
 
 from pylabrobot.liquid_handling import LiquidHandler, LiquidHandlerBackend, LiquidHandlerChatterboxBackend, Strictness
+from unilabos.devices.liquid_handling.rviz_backend import UniLiquidHandlerRvizBackend
+from unilabos.devices.liquid_handling.laiyu.backend.laiyu_v_backend import UniLiquidHandlerLaiyuBackend
 from pylabrobot.liquid_handling.liquid_handler import TipPresenceProbingMethod
 from pylabrobot.liquid_handling.standard import GripDirection
 from pylabrobot.resources import (
@@ -29,12 +31,15 @@ from unilabos.ros.nodes.base_device_node import BaseROS2DeviceNode
 
 
 class LiquidHandlerMiddleware(LiquidHandler):
-    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool = False, channel_num: int = 8):
+    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool = False, channel_num: int = 8, total_height: float = 310, **kwargs):
         self._simulator = simulator
         self.channel_num = channel_num
+        joint_config = kwargs.get("joint_config", None)
         if simulator:
-            self._simulate_backend = LiquidHandlerChatterboxBackend(channel_num)
+            self._simulate_backend = UniLiquidHandlerRvizBackend(channel_num,total_height, joint_config=joint_config, lh_device_id = deck.name)
             self._simulate_handler = LiquidHandlerAbstract(self._simulate_backend, deck, False)
+        if hasattr(backend, "total_height"):
+            backend.total_height = total_height
         super().__init__(backend, deck)
 
     async def setup(self, **backend_kwargs):
@@ -217,7 +222,6 @@ class LiquidHandlerMiddleware(LiquidHandler):
             offsets,
             liquid_height,
             blow_out_air_volume,
-            spread,
             **backend_kwargs,
         )
 
@@ -540,16 +544,51 @@ class LiquidHandlerAbstract(LiquidHandlerMiddleware):
     support_touch_tip = True
     _ros_node: BaseROS2DeviceNode
 
-    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool=False, channel_num:int = 8):
+    def __init__(self, backend: LiquidHandlerBackend, deck: Deck, simulator: bool=False, channel_num:int = 8,total_height: float = 310,**backend_kwargs):
         """Initialize a LiquidHandler.
 
         Args:
           backend: Backend to use.
           deck: Deck to use.
         """
+        backend_type = None
+        if isinstance(backend, dict) and "type" in backend:
+            backend_dict = backend.copy()
+            type_str = backend_dict.pop("type")
+            try:
+                # Try to get class from string using globals (current module), or fallback to pylabrobot or unilabos namespaces
+                backend_cls = None
+                if type_str in globals():
+                    backend_cls = globals()[type_str]
+                else:
+                    # Try resolving dotted notation, e.g. "xxx.yyy.ClassName"
+                    components = type_str.split(".")
+                    mod = None
+                    if len(components) > 1:
+                        module_name = ".".join(components[:-1])
+                        try:
+                            import importlib
+                            mod = importlib.import_module(module_name)
+                        except ImportError:
+                            mod = None
+                        if mod is not None:
+                            backend_cls = getattr(mod, components[-1], None)
+                    if backend_cls is None:
+                        # Try pylabrobot style import (if available)
+                        try:
+                            import pylabrobot
+                            backend_cls = getattr(pylabrobot, type_str, None)
+                        except Exception:
+                            backend_cls = None
+                if backend_cls is not None and isinstance(backend_cls, type):
+                    backend_type = backend_cls(**backend_dict)  # pass the rest of dict as kwargs
+            except Exception as exc:
+                raise RuntimeError(f"Failed to convert backend type '{type_str}' to class: {exc}")
+        else:
+            backend_type = backend
         self._simulator = simulator
         self.group_info = dict()
-        super().__init__(backend, deck, simulator, channel_num)
+        super().__init__(backend_type, deck, simulator, channel_num,total_height,**backend_kwargs)
 
     def post_init(self, ros_node: BaseROS2DeviceNode):
         self._ros_node = ros_node

unilabos/devices/liquid_handling/rviz_backend.py

@@ -1,5 +1,6 @@
-      
+
 import json
+import threading
 from typing import List, Optional, Union
 
 from pylabrobot.liquid_handling.backends.backend import (
@@ -30,7 +31,7 @@ from rclpy.action import ActionClient
 from unilabos_msgs.action import SendCmd
 import re
 
-from unilabos.devices.ros_dev.liquid_handler_joint_publisher import JointStatePublisher
+from unilabos.devices.ros_dev.liquid_handler_joint_publisher_node import LiquidHandlerJointPublisher
 
 
 class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
@@ -48,27 +49,44 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
   _max_volume_length = 16
   _fitting_depth_length = 20
   _tip_length_length = 16
-  # _pickup_method_length = 20
   _filter_length = 10
 
-  def __init__(self, num_channels: int = 8 , tip_length: float = 0 , total_height: float = 310):
+  def __init__(self, num_channels: int = 8 , tip_length: float = 0 , total_height: float = 310, **kwargs):
     """Initialize a chatter box backend."""
     super().__init__()
     self._num_channels = num_channels
     self.tip_length = tip_length
     self.total_height = total_height
-# rclpy.init()
+    self.joint_config = kwargs.get("joint_config", None)
+    self.lh_device_id = kwargs.get("lh_device_id", "lh_joint_publisher")
     if not rclpy.ok():
         rclpy.init()
     self.joint_state_publisher = None
+    self.executor = None
+    self.executor_thread = None
 
   async def setup(self):
-    self.joint_state_publisher = JointStatePublisher()
+    self.joint_state_publisher = LiquidHandlerJointPublisher(
+                                joint_config=self.joint_config,
+                                lh_device_id=self.lh_device_id,
+                                simulate_rviz=True)
+
+    # 启动ROS executor
+    self.executor = rclpy.executors.MultiThreadedExecutor()
+    self.executor.add_node(self.joint_state_publisher)
+    self.executor_thread = threading.Thread(target=self.executor.spin, daemon=True)
+    self.executor_thread.start()
+
     await super().setup()
 
     print("Setting up the liquid handler.")
 
   async def stop(self):
+    # 停止ROS executor
+    if self.executor and self.joint_state_publisher:
+        self.executor.remove_node(self.joint_state_publisher)
+    if self.executor_thread and self.executor_thread.is_alive():
+        self.executor.shutdown()
     print("Stopping the liquid handler.")
 
   def serialize(self) -> dict:
@@ -123,7 +141,7 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
     y = coordinate.y + offset_xyz.y
     z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
     # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "pick",channels=use_channels)
+    self.joint_state_publisher.move_joints(ops[0].resource.name, x, y, z, "pick",channels=use_channels)
     #   goback()
 
 
@@ -166,7 +184,7 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
     z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
     # print(x, y, z)
     # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "drop_trash",channels=use_channels)
+    self.joint_state_publisher.move_joints(ops[0].resource.name, x, y, z, "drop_trash",channels=use_channels)
     #   goback()
 
   async def aspirate(
@@ -216,7 +234,7 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
     z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
     # print(x, y, z)
     # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "",channels=use_channels)
+    self.joint_state_publisher.move_joints(ops[0].resource.name, x, y, z, "",channels=use_channels)
 
 
   async def dispense(
@@ -264,9 +282,8 @@ class UniLiquidHandlerRvizBackend(LiquidHandlerBackend):
     x = coordinate.x + offset_xyz.x
     y = coordinate.y + offset_xyz.y
     z = self.total_height - (coordinate.z + self.tip_length) + offset_xyz.z
-    # print(x, y, z)
-    # print("moving")
-    self.joint_state_publisher.send_resource_action(ops[0].resource.name, x, y, z, "",channels=use_channels)
+
+    self.joint_state_publisher.move_joints(ops[0].resource.name, x, y, z, "",channels=use_channels)
 
   async def pick_up_tips96(self, pickup: PickupTipRack, **backend_kwargs):
     print(f"Picking up tips from {pickup.resource.name}.")