unity2moveit2/docs/architecture/ARCHITECTURE.md

Unity-MoveIt2 系统架构设计

📋 目录

• 1. 架构概览
• 2. 系统分层
• 3. 核心组件
• 4. 数据流设计
• 5. 通信协议
• 6. 扩展性设计
• 7. 性能考量
• 8. 安全性设计

1. 架构概览

1.1 整体架构

graph TB
    subgraph "Unity 前端层"
        UI[Unity UI系统]
        VIS[可视化引擎]
        INT[交互控制器]
        SIM[物理仿真]
    end
    
    subgraph "通信桥梁层"
        TCP[ROS TCP Bridge]
        MSG[消息转换器]
        QOS[QoS管理器]
    end
    
    subgraph "ROS2 后端层"
        MOVE[MoveIt2规划器]
        CTRL[控制器管理]
        SENS[传感器模拟]
        ANAL[可行性分析]
    end
    
    subgraph "配置管理层"
        ROBOT[机器人配置]
        ENV[环境配置]
        TASK[任务配置]
    end
    
    UI --> TCP
    VIS --> TCP
    INT --> TCP
    SIM --> TCP
    
    TCP --> MOVE
    TCP --> CTRL
    TCP --> SENS
    TCP --> ANAL
    
    ROBOT --> MOVE
    ENV --> ANAL
    TASK --> MOVE

1.2 设计原则

• 分层解耦：各层职责明确，降低耦合度
• 模块化：组件可独立开发、测试、部署
• 可扩展：支持新机器人、新算法的快速集成
• 高性能：优化数据传输和计算效率
• 容错性：具备故障检测和恢复机制

2. 系统分层

2.1 Unity 前端层

职责：用户交互、3D可视化、物理仿真

// Unity前端核心架构
public class UnityFrontendManager : MonoBehaviour
{
    [Header("核心组件")]
    public RobotVisualizer robotVisualizer;
    public InteractionController interactionController;
    public UIManager uiManager;
    public PhysicsSimulator physicsSimulator;
    
    [Header("通信组件")]
    public ROSTCPConnector rosConnector;
    public MessageHandler messageHandler;
    
    private void Start()
    {
        InitializeComponents();
        EstablishROSConnection();
    }
}

核心组件：

• 机器人可视化器：URDF模型加载、关节状态显示
• 交互控制器：6DOF拖拽、末端控制、任务标注
• UI管理器：动态界面、参数配置、状态监控
• 物理仿真器：碰撞检测、重力模拟、约束处理

2.2 通信桥梁层

职责：Unity与ROS2之间的数据传输和协议转换

# ROS2通信桥梁核心架构
class ROSUnityBridge:
    def __init__(self):
        self.tcp_server = TCPServer()
        self.message_converter = MessageConverter()
        self.qos_manager = QoSManager()
        
    def start_bridge(self):
        self.tcp_server.start()
        self.setup_ros_publishers()
        self.setup_ros_subscribers()

核心功能：

• TCP服务器：处理Unity连接请求
• 消息转换：Unity消息 ↔ ROS2消息
• QoS管理：保证消息传输质量
• 连接管理：断线重连、心跳检测

2.3 ROS2 后端层

职责：路径规划、运动控制、可行性分析

// ROS2后端核心架构
class MoveItPlanningNode : public rclcpp::Node
{
public:
    MoveItPlanningNode() : Node("moveit_planning_node")
    {
        planning_interface_ = std::make_shared<moveit::planning_interface::MoveGroupInterface>(this, "manipulator");
        feasibility_analyzer_ = std::make_shared<FeasibilityAnalyzer>();
        collision_detector_ = std::make_shared<CollisionDetector>();
    }
    
private:
    std::shared_ptr<moveit::planning_interface::MoveGroupInterface> planning_interface_;
    std::shared_ptr<FeasibilityAnalyzer> feasibility_analyzer_;
    std::shared_ptr<CollisionDetector> collision_detector_;
};

核心组件：

• MoveIt2规划器：路径规划、轨迹优化
• 控制器管理：关节控制、速度限制
• 可行性分析器：装配任务评估、环境约束检查
• 碰撞检测器：实时碰撞检测、安全监控

2.4 配置管理层

职责：系统配置、参数管理、模型加载

# 配置管理架构
configuration_manager:
  robot_configs:
    - path: "configs/robots/"
    - format: "yaml"
    - validation: "schema_based"
  
  environment_configs:
    - path: "configs/environments/"
    - format: "json"
    - hot_reload: true
  
  task_configs:
    - path: "configs/tasks/"
    - format: "yaml"
    - versioning: true

3. 核心组件

3.1 通用机械臂适配器

public class UniversalRobotAdapter
{
    public class RobotConfiguration
    {
        public string robotName;
        public int degreesOfFreedom;
        public List<JointConfiguration> joints;
        public KinematicsConfiguration kinematics;
    }
    
    public bool LoadRobotConfiguration(string configPath)
    {
        // 动态加载机器人配置
        // 验证DOF范围（1-9）
        // 初始化运动学参数
    }
}

3.2 交互式末端控制器

public class EndEffectorController : MonoBehaviour
{
    [Header("控制模式")]
    public ControlMode currentMode = ControlMode.CartesianSpace;
    
    [Header("6DOF控制")]
    public Transform targetPose;
    public Vector3 positionConstraints;
    public Vector3 orientationConstraints;
    
    public void OnDrag(Vector3 deltaPosition, Vector3 deltaRotation)
    {
        // 实时逆运动学求解
        // 约束检查
        // 发送目标位姿到ROS2
    }
}

3.3 智能路径规划系统

class IntelligentPathPlanner
{
public:
    struct PlanningRequest
    {
        geometry_msgs::msg::Pose start_pose;
        geometry_msgs::msg::Pose goal_pose;
        std::vector<geometry_msgs::msg::Pose> waypoints;
        PlanningConstraints constraints;
    };
    
    PlanningResult planPath(const PlanningRequest& request)
    {
        // 选择合适的规划算法
        // 执行路径规划
        // 轨迹优化和平滑
        // 碰撞检查
    }
};

3.4 可行性分析模块

class FeasibilityAnalyzer
{
public:
    struct AssemblyTask
    {
        std::vector<geometry_msgs::msg::Pose> target_poses;
        std::vector<CollisionObject> environment_objects;
        AssemblyConstraints constraints;
    };
    
    FeasibilityResult analyzeFeasibility(const AssemblyTask& task)
    {
        // 工作空间分析
        // 碰撞风险评估
        // 可达性检查
        // 装配序列优化
    }
};

4. 数据流设计

4.1 实时控制数据流

sequenceDiagram
    participant Unity as Unity前端
    participant Bridge as TCP桥梁
    participant ROS2 as ROS2后端
    
    Unity->>Bridge: 末端目标位姿
    Bridge->>ROS2: geometry_msgs/Pose
    ROS2->>ROS2: 逆运动学求解
    ROS2->>Bridge: 关节角度
    Bridge->>Unity: JointState消息
    Unity->>Unity: 更新机器人可视化

4.2 路径规划数据流

sequenceDiagram
    participant Unity as Unity前端
    participant Bridge as TCP桥梁
    participant MoveIt as MoveIt2
    
    Unity->>Bridge: 路径规划请求
    Bridge->>MoveIt: MotionPlanRequest
    MoveIt->>MoveIt: 路径规划计算
    MoveIt->>Bridge: RobotTrajectory
    Bridge->>Unity: 轨迹点序列
    Unity->>Unity: 轨迹可视化

4.3 可行性分析数据流

sequenceDiagram
    participant Unity as Unity前端
    participant Bridge as TCP桥梁
    participant Analyzer as 可行性分析器
    
    Unity->>Bridge: 装配任务定义
    Bridge->>Analyzer: AssemblyTaskRequest
    Analyzer->>Analyzer: 可行性计算
    Analyzer->>Bridge: FeasibilityResult
    Bridge->>Unity: 分析结果
    Unity->>Unity: 热图显示

5. 通信协议

5.1 消息定义

# Unity -> ROS2 消息类型
UnityToROS2Messages:
  - EndEffectorPose:
      position: geometry_msgs/Point
      orientation: geometry_msgs/Quaternion
      timestamp: builtin_interfaces/Time
  
  - PlanningRequest:
      start_pose: geometry_msgs/Pose
      goal_pose: geometry_msgs/Pose
      constraints: moveit_msgs/Constraints
  
  - AssemblyTask:
      target_poses: geometry_msgs/Pose[]
      environment: CollisionObject[]
      constraints: AssemblyConstraints

# ROS2 -> Unity 消息类型
ROS2ToUnityMessages:
  - JointStates:
      joint_names: string[]
      positions: float64[]
      velocities: float64[]
  
  - TrajectoryResult:
      trajectory_points: TrajectoryPoint[]
      execution_time: float64
      success: bool
  
  - FeasibilityResult:
      feasible: bool
      collision_risk: float64
      reachability_score: float64
      optimization_suggestions: string[]

5.2 服务接口

# ROS2服务定义
Services:
  - PlanPath:
      request: PlanningRequest
      response: PlanningResponse
  
  - AnalyzeFeasibility:
      request: AssemblyTaskRequest
      response: FeasibilityResponse
  
  - LoadRobotConfiguration:
      request: RobotConfigRequest
      response: ConfigurationResponse

5.3 QoS策略

// QoS配置
class QoSConfiguration
{
public:
    static rclcpp::QoS getRealTimeQoS()
    {
        return rclcpp::QoS(10)
            .reliability(RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT)
            .durability(RMW_QOS_POLICY_DURABILITY_VOLATILE)
            .deadline(std::chrono::milliseconds(50));
    }
    
    static rclcpp::QoS getReliableQoS()
    {
        return rclcpp::QoS(10)
            .reliability(RMW_QOS_POLICY_RELIABILITY_RELIABLE)
            .durability(RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL);
    }
};

6. 扩展性设计

6.1 插件架构

// Unity插件接口
public interface IRobotPlugin
{
    string GetRobotName();
    int GetDegreesOfFreedom();
    bool LoadConfiguration(string configPath);
    Vector3[] GetJointPositions();
    bool SetJointTargets(float[] jointAngles);
}

// 插件管理器
public class PluginManager
{
    private Dictionary<string, IRobotPlugin> loadedPlugins;
    
    public void LoadPlugin(string pluginPath)
    {
        // 动态加载插件
        // 注册到系统
    }
}

6.2 算法扩展

// ROS2算法接口
class IPlanningAlgorithm
{
public:
    virtual ~IPlanningAlgorithm() = default;
    virtual std::string getAlgorithmName() const = 0;
    virtual PlanningResult plan(const PlanningRequest& request) = 0;
    virtual bool supportsConstraints(const PlanningConstraints& constraints) const = 0;
};

// 算法注册器
class AlgorithmRegistry
{
public:
    void registerAlgorithm(std::unique_ptr<IPlanningAlgorithm> algorithm);
    IPlanningAlgorithm* getAlgorithm(const std::string& name);
};

7. 性能考量

7.1 实时性优化

// 性能监控
class PerformanceMonitor
{
public:
    struct Metrics
    {
        double communication_latency;  // 通信延迟
        double planning_time;          // 规划时间
        double visualization_fps;      // 可视化帧率
        double memory_usage;           // 内存使用
    };
    
    void updateMetrics();
    Metrics getCurrentMetrics() const;
};

7.2 内存管理

// Unity内存优化
public class MemoryManager
{
    [Header("对象池")]
    public ObjectPool<TrajectoryPoint> trajectoryPointPool;
    public ObjectPool<CollisionObject> collisionObjectPool;
    
    [Header("缓存管理")]
    public LRUCache<string, Mesh> meshCache;
    public LRUCache<string, Texture2D> textureCache;
    
    public void OptimizeMemoryUsage()
    {
        // 清理未使用的资源
        // 压缩纹理
        // 优化网格
    }
}

8. 安全性设计

8.1 输入验证

// 输入验证器
class InputValidator
{
public:
    static bool validateJointAngles(const std::vector<double>& angles, 
                                   const std::vector<JointLimits>& limits)
    {
        // 检查关节角度范围
        // 验证速度和加速度限制
    }
    
    static bool validatePose(const geometry_msgs::msg::Pose& pose,
                           const WorkspaceConstraints& constraints)
    {
        // 检查位置范围
        // 验证姿态有效性
    }
};

8.2 故障恢复

// 故障恢复管理器
class FaultRecoveryManager
{
public:
    enum class FaultType
    {
        COMMUNICATION_LOST,
        PLANNING_FAILED,
        COLLISION_DETECTED,
        JOINT_LIMIT_EXCEEDED
    };
    
    void handleFault(FaultType fault, const std::string& context)
    {
        // 记录故障信息
        // 执行恢复策略
        // 通知用户
    }
};

9. 部署架构

9.1 Docker容器化

# ROS2后端容器
FROM ros:humble-desktop

# 安装依赖
RUN apt-get update && apt-get install -y \
    ros-humble-moveit \
    ros-humble-ros-tcp-endpoint \
    python3-pip

# 复制源码
COPY ros2-workspace /workspace
WORKDIR /workspace

# 构建
RUN colcon build --symlink-install

# 启动脚本
CMD ["ros2", "launch", "unity_moveit_bridge", "bridge.launch.py"]

9.2 微服务架构

# Docker Compose配置
version: '3.8'
services:
  ros2-bridge:
    build: ./ros2-workspace
    ports:
      - "10000:10000"
    environment:
      - ROS_DOMAIN_ID=42
  
  moveit-planner:
    build: ./moveit-service
    depends_on:
      - ros2-bridge
    environment:
      - ROS_DOMAIN_ID=42
  
  feasibility-analyzer:
    build: ./analysis-service
    depends_on:
      - ros2-bridge
    environment:
      - ROS_DOMAIN_ID=42

---

总结

本架构设计遵循分层解耦、模块化、可扩展的原则，通过Unity前端层、通信桥梁层、ROS2后端层和配置管理层的有机结合，实现了一个高性能、可扩展的机械臂仿真系统。系统支持1-9自由度机械臂的通用适配，具备实时交互控制、智能路径规划和装配可行性分析等核心功能。

通过插件架构和算法扩展接口，系统可以方便地集成新的机器人模型和规划算法。性能优化和安全性设计确保了系统的稳定性和可靠性。Docker容器化部署方案提供了灵活的部署选择。