ElectronBot-SIM七层架构：从CAD到MuJoCo仿真的机器人开发全流程

在机器人开发领域从CAD设计到真实机器人控制往往存在巨大的鸿沟。传统的开发流程需要经历机械设计、电子调试、软件编程等多个独立环节每个环节都可能出现兼容性问题。ElectronBot-SIM项目正是为了解决这一痛点而生它构建了一个完整的七层架构实现了从CAD模型到真实机器人控制的无缝衔接。本文将详细解析ElectronBot-SIM项目的完整技术栈特别关注其七层架构设计。无论你是机器人领域的初学者还是有一定经验的开发者都能通过本文掌握从CAD设计到MuJoCo仿真再到真实机器人控制的完整流程。我们将从环境搭建开始逐步深入到每一层的实现细节并提供可运行的代码示例。1. 项目背景与核心概念1.1 ElectronBot-SIM 项目概述ElectronBot-SIM是一个开源的机器人仿真与控制框架其核心目标是将CAD设计、物理仿真和真实机器人控制整合到一个统一的开发环境中。项目名称中的SIM表明其仿真特性而ElectronBot则体现了对电子控制层面的支持。该项目的独特之处在于采用了七层架构设计每一层都承担特定的职责从最底层的CAD模型处理到最上层的实际控制指令执行形成了完整的开发闭环。这种分层设计使得开发者可以专注于特定层面的开发而不需要关心整个系统的复杂性。1.2 七层架构的整体设计七层架构是ElectronBot-SIM项目的核心创新它借鉴了网络OSI七层模型的思想将机器人开发流程进行了合理的分层第一层CAD模型层- 处理原始的三维模型数据第二层几何转换层- 将CAD模型转换为仿真可用的格式第三层物理引擎层- 基于MuJoCo的物理仿真第四层控制算法层- 机器人运动规划和控制系统第五层通信协议层- 基于MCP协议的设备通信第六层硬件抽象层- 统一硬件接口第七层设备驱动层- 具体硬件设备的驱动程序这种分层架构确保了各层之间的松耦合使得替换某一层的实现不会影响其他层的功能。1.3 相关技术栈介绍ElectronBot-SIM项目涉及多个重要的技术组件MuJoCo作为物理仿真引擎MuJoCoMulti-Joint dynamics with Contact提供了高效的机器人动力学仿真能力。相比Gazebo等其他仿真工具MuJoCo在计算效率和精度方面具有明显优势。MCP协议Model Control Protocol是一种新兴的机器人控制协议专门为模型驱动的机器人控制设计提供了统一的设备通信标准。CAD处理工具项目支持多种CAD格式的导入包括STL、STEP等常见格式并提供了相应的转换工具。2. 环境准备与工具安装2.1 系统环境要求ElectronBot-SIM支持在多种操作系统上运行但推荐使用Ubuntu 20.04或更高版本因为MuJoCo在Linux环境下的支持最为完善。以下是详细的环境要求操作系统Ubuntu 20.04/22.04/24.04 LTS推荐Windows 10/11macOS 12Python版本Python 3.8-3.11内存要求至少8GB RAM推荐16GB显卡要求支持OpenGL 3.3以上的显卡2.2 MuJoCo安装与配置MuJoCo的安装是项目环境搭建的关键步骤。以下是详细的安装流程# 创建项目目录 mkdir electronbot-sim cd electronbot-sim # 安装系统依赖 sudo apt update sudo apt install build-essential libgl1-mesa-dev libglu1-mesa-dev \ libosmesa6-dev libxi-dev libxrandr-dev libxcursor-dev # 下载MuJoCo 2.3.0最新稳定版本 wget https://github.com/deepmind/mujoco/releases/download/2.3.0/mujoco-2.3.0-linux-x86_64.tar.gz # 解压到用户目录 tar -xzf mujoco-2.3.0-linux-x86_64.tar.gz mkdir -p ~/.mujoco mv mujoco-2.3.0 ~/.mujoco/ # 设置环境变量 echo export LD_LIBRARY_PATH$LD_LIBRARY_PATH:~/.mujoco/mujoco-2.3.0/bin ~/.bashrc echo export MUJOCO_PY_MUJOCO_PATH~/.mujoco/mujoco-2.3.0 ~/.bashrc source ~/.bashrc # 安装mujoco-py Python绑定 pip install mujoco-py安装完成后可以通过以下代码验证MuJoCo是否正常工作import mujoco_py import os # 简单的MuJoCo模型XML定义 xml mujoco worldbody light nametop pos0 0 1/ geom namefloor typeplane size1 1 0.1 rgba0.8 0.9 0.8 1/ body namebox pos0 0 0.1 joint typefree/ geom namebox_geom typebox size0.05 0.05 0.05 rgba1 0 0 1/ /body /worldbody /mujoco # 加载模型并创建仿真环境 model mujoco_py.load_model_from_xml(xml) sim mujoco_py.MjSim(model) viewer mujoco_py.MjViewer(sim) print(MuJoCo安装成功仿真环境已创建。)2.3 CAD工具准备对于CAD模型的处理推荐使用以下工具FreeCAD开源的CAD建模工具支持多种格式的导入导出。Blender强大的三维建模和渲染工具适合模型优化和格式转换。安装命令# 安装FreeCAD sudo apt install freecad # 安装Blender sudo snap install blender --classic2.4 Python依赖安装创建项目的Python虚拟环境并安装所需依赖# 创建虚拟环境 python -m venv electronbot-env source electronbot-env/bin/activate # 安装核心依赖 pip install numpy matplotlib scipy pip install trimesh pyassimp # 3D模型处理 pip install pyserial # 串口通信 pip install websockets # WebSocket支持3. 七层架构详细实现3.1 第一层CAD模型处理CAD模型层负责处理原始的三维模型数据。这一层的主要任务是将商业CAD软件如AutoCAD、SolidWorks导出的模型文件转换为仿真可用的格式。import trimesh import numpy as np class CADProcessor: def __init__(self): self.supported_formats [.stl, .step, .iges, .obj] def load_cad_model(self, file_path): 加载CAD模型文件 try: mesh trimesh.load_mesh(file_path) print(f模型加载成功: {file_path}) print(f顶点数: {len(mesh.vertices)}) print(f面数: {len(mesh.faces)}) return mesh except Exception as e: print(f模型加载失败: {e}) return None def optimize_mesh(self, mesh, decimation_ratio0.5): 优化网格模型减少面数以提高仿真效率 if hasattr(mesh, simplify_quadric_decimation): simplified mesh.simplify_quadric_decimation( int(len(mesh.faces) * decimation_ratio) ) print(f网格优化完成: {len(mesh.faces)} - {len(simplified.faces)} 面) return simplified return mesh def export_for_simulation(self, mesh, output_path): 导出为仿真可用格式 # 导出为STL格式这是MuJoCo支持的格式 mesh.export(output_path) print(f模型已导出: {output_path}) # 使用示例 processor CADProcessor() model processor.load_cad_model(robot_arm.step) if model: optimized_model processor.optimize_mesh(model) processor.export_for_simulation(optimized_model, robot_arm_simplified.stl)3.2 第二层几何转换与URDF生成几何转换层将优化后的CAD模型转换为机器人描述格式URDF这是物理仿真中的标准格式。import xml.etree.ElementTree as ET from xml.dom import minidom class URDFGenerator: def __init__(self, robot_nameElectronBot): self.robot_name robot_name self.links [] self.joints [] def add_link(self, link_name, mesh_path, mass1.0, inertiaNone): 添加机器人链接 if inertia is None: inertia [0.1, 0.0, 0.0, 0.1, 0.0, 0.1] link_info { name: link_name, mesh_path: mesh_path, mass: mass, inertia: inertia } self.links.append(link_info) def add_joint(self, joint_name, parent, child, joint_type, axis[0, 0, 1], limitsNone): 添加关节连接 if limits is None: limits {lower: -3.14, upper: 3.14, effort: 100, velocity: 10} joint_info { name: joint_name, parent: parent, child: child, type: joint_type, axis: axis, limits: limits } self.joints.append(joint_info) def generate_urdf(self, output_path): 生成URDF文件 robot ET.Element(robot, nameself.robot_name) # 添加链接 for link in self.links: link_elem ET.SubElement(robot, link, namelink[name]) # 视觉属性 visual ET.SubElement(link_elem, visual) geometry ET.SubElement(visual, geometry) mesh ET.SubElement(geometry, mesh, filenamelink[mesh_path], scale1 1 1) # 碰撞属性 collision ET.SubElement(link_elem, collision) geometry ET.SubElement(collision, geometry) mesh ET.SubElement(geometry, mesh, filenamelink[mesh_path], scale1 1 1) # 惯性属性 inertial ET.SubElement(link_elem, inertial) mass ET.SubElement(inertial, mass, valuestr(link[mass])) inertia_elem ET.SubElement(inertial, inertia, ixxstr(link[inertia][0]), ixystr(link[inertia][1]), ixzstr(link[inertia][2]), iyystr(link[inertia][3]), iyzstr(link[inertia][4]), izzstr(link[inertia][5])) # 添加关节 for joint in self.joints: joint_elem ET.SubElement(robot, joint, namejoint[name], typejoint[type]) ET.SubElement(joint_elem, parent, linkjoint[parent]) ET.SubElement(joint_elem, child, linkjoint[child]) axis_elem ET.SubElement(joint_elem, axis, xyzf{joint[axis][0]} {joint[axis][1]} {joint[axis][2]}) if joint[type] in [revolute, prismatic]: limit_elem ET.SubElement(joint_elem, limit, lowerstr(joint[limits][lower]), upperstr(joint[limits][upper]), effortstr(joint[limits][effort]), velocitystr(joint[limits][velocity])) # 美化XML输出 rough_string ET.tostring(robot, utf-8) reparsed minidom.parseString(rough_string) pretty_xml reparsed.toprettyxml(indent ) with open(output_path, w) as f: f.write(pretty_xml) print(fURDF文件已生成: {output_path}) # 使用示例 generator URDFGenerator(SixAxisRobot) generator.add_link(base, meshes/base.stl, mass2.0) generator.add_link(link1, meshes/link1.stl, mass0.5) generator.add_joint(joint1, base, link1, revolute, [0, 0, 1]) generator.generate_urdf(six_axis_robot.urdf)3.3 第三层MuJoCo物理仿真集成物理引擎层将URDF模型加载到MuJoCo中进行物理仿真。import mujoco_py import numpy as np import time class MuJoCoSimulator: def __init__(self, urdf_path, model_xmlNone): if model_xml is None: # 从URDF生成MuJoCo XML self.model_xml self.urdf_to_mujoco_xml(urdf_path) else: self.model_xml model_xml self.model mujoco_py.load_model_from_xml(self.model_xml) self.sim mujoco_py.MjSim(self.model) self.viewer None def urdf_to_mujoco_xml(self, urdf_path): 简化版的URDF到MuJoCo XML转换 # 这里应该实现完整的转换逻辑 # 为简化示例返回一个基本模型 return mujoco option timestep0.01/ worldbody light nametop pos0 0 1/ geom namefloor typeplane size1 1 0.1 rgba0.8 0.9 0.8 1/ body namerobot pos0 0 0.2 joint nameroot_joint typefree/ geom namebody typebox size0.1 0.05 0.05 rgba1 0 0 1/ body namearm pos0.1 0 0 joint namearm_joint typehinge axis0 0 1 range-90 90/ geom namearm_geom typebox size0.1 0.03 0.03 rgba0 1 0 1/ /body /body /worldbody actuator motor namearm_motor jointarm_joint gear100/ /actuator /mujoco def setup_control(self, control_frequency100): 设置控制系统 self.control_dt 1.0 / control_frequency self.pid_controllers {} def add_pid_controller(self, joint_name, kp100, ki10, kd1): 为指定关节添加PID控制器 self.pid_controllers[joint_name] { kp: kp, ki: ki, kd: kd, integral: 0, previous_error: 0 } def run_simulation(self, duration10, target_positionsNone): 运行仿真 if self.viewer is None: self.viewer mujoco_py.MjViewer(self.sim) if target_positions is None: target_positions {arm_joint: 0.5} start_time time.time() sim_time 0 while sim_time duration: # 计算控制信号 control_signals self.compute_control_signals(target_positions) # 应用控制信号 self.sim.data.ctrl[:] list(control_signals.values()) # 步进仿真 self.sim.step() self.viewer.render() # 更新状态 sim_time time.time() - start_time time.sleep(max(0, self.control_dt - (time.time() % self.control_dt))) def compute_control_signals(self, target_positions): 计算PID控制信号 signals {} for joint_name, target in target_positions.items(): if joint_name in self.pid_controllers: # 获取当前关节位置 joint_id self.model.joint_name2id(joint_name) current_pos self.sim.data.qpos[joint_id] # 计算误差 error target - current_pos # PID计算 pid self.pid_controllers[joint_name] pid[integral] error * self.control_dt derivative (error - pid[previous_error]) / self.control_dt control_signal (pid[kp] * error pid[ki] * pid[integral] pid[kd] * derivative) signals[joint_name] control_signal pid[previous_error] error return signals # 使用示例 simulator MuJoCoSimulator(six_axis_robot.urdf) simulator.setup_control() simulator.add_pid_controller(arm_joint, kp150, ki20, kd5) simulator.run_simulation(duration5, target_positions{arm_joint: 0.8})4. 控制算法与通信协议实现4.1 第四层运动规划算法控制算法层负责机器人的运动规划和轨迹生成。import numpy as np from scipy.interpolate import CubicSpline import matplotlib.pyplot as plt class MotionPlanner: def __init__(self, joint_limits): self.joint_limits joint_limits def generate_trajectory(self, start_pos, end_pos, duration, dt0.01): 生成平滑的关节空间轨迹 num_points int(duration / dt) 1 time_points np.linspace(0, duration, num_points) # 使用三次样条插值生成平滑轨迹 trajectories {} for joint in start_pos.keys(): if joint in end_pos: # 创建样条曲线 spline CubicSpline([0, duration], [start_pos[joint], end_pos[joint]], bc_type((1, 0), (1, 0))) # 起点和终点速度为零 trajectories[joint] spline(time_points) return time_points, trajectories def check_collision(self, joint_positions, obstacles): 简单的碰撞检测 # 这里应该实现基于机器人运动学的碰撞检测 # 为简化示例返回无碰撞 return False def optimize_trajectory(self, trajectory, optimization_typetime): 轨迹优化 if optimization_type time: # 时间最优轨迹优化 return self.time_optimal_optimization(trajectory) elif optimization_type energy: # 能量最优轨迹优化 return self.energy_optimal_optimization(trajectory) else: return trajectory def time_optimal_optimization(self, trajectory): 时间最优优化 # 简化实现压缩轨迹时间 optimized {} for joint, values in trajectory.items(): # 根据关节限速进行时间缩放 max_velocity self.joint_limits[joint][velocity] # 这里应该实现完整的时间最优算法 optimized[joint] values # 实际项目中需要完整实现 return optimized # 使用示例 joint_limits { joint1: {lower: -3.14, upper: 3.14, velocity: 2.0}, joint2: {lower: -1.57, upper: 1.57, velocity: 1.5} } planner MotionPlanner(joint_limits) start {joint1: 0.0, joint2: 0.0} end {joint1: 1.0, joint2: 0.5} times, trajectory planner.generate_trajectory(start, end, duration2.0) # 绘制轨迹 plt.figure(figsize(10, 6)) for joint, values in trajectory.items(): plt.plot(times, values, labeljoint) plt.xlabel(Time (s)) plt.ylabel(Joint Position (rad)) plt.legend() plt.title(Joint Trajectory Planning) plt.grid(True) plt.show()4.2 第五层MCP协议通信实现通信协议层基于MCPModel Control Protocol实现仿真环境与真实硬件的通信。import asyncio import websockets import json import threading from typing import Dict, Any class MCPServer: def __init__(self, hostlocalhost, port8765): self.host host self.port port self.clients set() self.robot_state {} self.command_handlers {} def register_command_handler(self, command_type, handler): 注册命令处理器 self.command_handlers[command_type] handler async def handle_client(self, websocket, path): 处理客户端连接 self.clients.add(websocket) try: async for message in websocket: await self.process_message(message, websocket) except websockets.exceptions.ConnectionClosed: pass finally: self.clients.remove(websocket) async def process_message(self, message, websocket): 处理接收到的消息 try: data json.loads(message) command_type data.get(type) if command_type in self.command_handlers: response await self.command_handlers[command_type](data) await websocket.send(json.dumps(response)) else: await websocket.send(json.dumps({ status: error, message: fUnknown command type: {command_type} })) except json.JSONDecodeError: await websocket.send(json.dumps({ status: error, message: Invalid JSON format })) async def broadcast_state(self, state_update): 广播状态更新给所有客户端 if self.clients: message json.dumps({ type: state_update, data: state_update }) await asyncio.gather( *[client.send(message) for client in self.clients] ) def start_server(self): 启动MCP服务器 async def main(): async with websockets.serve(self.handle_client, self.host, self.port): print(fMCP Server started on {self.host}:{self.port}) await asyncio.Future() # 永久运行 asyncio.run(main()) class MCPClient: def __init__(self, server_urlws://localhost:8765): self.server_url server_url self.websocket None async def connect(self): 连接到MCP服务器 self.websocket await websockets.connect(self.server_url) print(fConnected to MCP server at {self.server_url}) async def send_command(self, command_type, dataNone): 发送命令到服务器 if data is None: data {} message { type: command_type, data: data, timestamp: time.time() } await self.websocket.send(json.dumps(message)) response await self.websocket.recv() return json.loads(response) async def receive_updates(self, callback): 接收状态更新 async for message in self.websocket: data json.loads(message) if data.get(type) state_update: callback(data[data]) # 使用示例 async def demo_mcp_communication(): # 服务器端 server MCPServer() # 注册命令处理器 async def handle_move_command(data): print(fReceived move command: {data}) # 这里应该执行实际的运动控制 return {status: success, message: Move command executed} server.register_command_handler(move_joints, handle_move_command) # 在后台启动服务器 server_thread threading.Thread(targetserver.start_server) server_thread.daemon True server_thread.start() # 客户端 client MCPClient() await client.connect() # 发送运动命令 response await client.send_command(move_joints, { joints: {joint1: 0.5, joint2: 0.3}, speed: 0.1 }) print(fServer response: {response}) # 运行演示 # asyncio.run(demo_mcp_communication())5. 硬件集成与实战应用5.1 第六层硬件抽象层实现硬件抽象层为不同的硬件设备提供统一的接口。import serial import threading import time from abc import ABC, abstractmethod class HardwareInterface(ABC): 硬件接口抽象基类 abstractmethod def connect(self): 连接硬件设备 pass abstractmethod def disconnect(self): 断开硬件连接 pass abstractmethod def send_command(self, command): 发送命令到硬件 pass abstractmethod def read_data(self): 从硬件读取数据 pass class SerialRobotInterface(HardwareInterface): 串口机器人接口 def __init__(self, port/dev/ttyUSB0, baudrate115200): self.port port self.baudrate baudrate self.serial_conn None self.is_connected False self.read_thread None self.data_buffer [] def connect(self): 连接串口设备 try: self.serial_conn serial.Serial( portself.port, baudrateself.baudrate, timeout1 ) self.is_connected True print(fConnected to {self.port} at {self.baudrate} baud) # 启动数据读取线程 self.read_thread threading.Thread(targetself._read_loop) self.read_thread.daemon True self.read_thread.start() return True except serial.SerialException as e: print(fConnection failed: {e}) return False def disconnect(self): 断开连接 self.is_connected False if self.serial_conn and self.serial_conn.is_open: self.serial_conn.close() print(Disconnected from hardware) def send_command(self, command): 发送命令到机器人 if not self.is_connected: print(Not connected to hardware) return False try: # 将命令转换为硬件协议格式 formatted_command self._format_command(command) self.serial_conn.write(formatted_command.encode()) return True except Exception as e: print(fCommand send failed: {e}) return False def read_data(self): 读取最新数据 if self.data_buffer: return self.data_buffer.pop(0) return None def _read_loop(self): 数据读取循环 while self.is_connected: try: if self.serial_conn.in_waiting 0: data self.serial_conn.readline().decode().strip() if data: self.data_buffer.append(self._parse_data(data)) except Exception as e: print(fRead error: {e}) time.sleep(0.01) def _format_command(self, command): 格式化命令为硬件协议 # 这里应该实现具体的硬件协议 if joints in command: joints command[joints] cmd_str MOVE for joint, position in joints.items(): cmd_str f {joint}:{position:.3f} return cmd_str \n return def _parse_data(self, data): 解析硬件返回的数据 # 这里应该实现具体的数据解析逻辑 return {raw_data: data, timestamp: time.time()} class HardwareManager: 硬件管理器 def __init__(self): self.interfaces {} self.robot_state {} def register_interface(self, name, interface): 注册硬件接口 self.interfaces[name] interface def connect_all(self): 连接所有硬件接口 results {} for name, interface in self.interfaces.items(): results[name] interface.connect() return results def execute_trajectory(self, trajectory, interface_namerobot): 执行轨迹 if interface_name not in self.interfaces: print(fInterface {interface_name} not found) return False interface self.interfaces[interface_name] for time_point, positions in trajectory.items(): command { type: move_joints, joints: positions, timestamp: time_point } if not interface.send_command(command): print(fCommand failed at time {time_point}) return False # 等待执行完成简化实现 time.sleep(0.01) return True # 使用示例 def demo_hardware_integration(): # 创建硬件接口 robot_interface SerialRobotInterface(/dev/ttyUSB0, 115200) # 创建硬件管理器 hw_manager HardwareManager() hw_manager.register_interface(robot, robot_interface) # 连接硬件 if hw_manager.connect_all()[robot]: print(Hardware connected successfully) # 创建简单轨迹 trajectory { 0.0: {joint1: 0.0, joint2: 0.0}, 1.0: {joint1: 0.5, joint2: 0.3}, 2.0: {joint1: 1.0, joint2: 0.6} } # 执行轨迹 hw_manager.execute_trajectory(trajectory) else: print(Hardware connection failed) # demo_hardware_integration()5.2 第七层设备驱动与实时控制设备驱动层实现具体的硬件设备控制。import struct import ctypes import time from enum import Enum class MotorType(Enum): STEPPER 1 SERVO 2 BRUSHLESS 3 class MotorDriver: 电机驱动器基类 def __init__(self, motor_type: MotorType): self.motor_type motor_type self.current_position 0.0 self.target_position 0.0 self.is_enabled False def enable(self): 使能电机 self.is_enabled True print(fMotor enabled: {self.motor_type.name}) def disable(self): 禁用电机 self.is_enabled False print(fMotor disabled: {self.motor_type.name}) def set_position(self, position): 设置目标位置 if self.is_enabled: self.target_position position return True return False def get_position(self): 获取当前位置 return self.current_position class StepperDriver(MotorDriver): 步进电机驱动器 def __init__(self, steps_per_revolution200, microstepping16): super().__init__(MotorType.STEPPER) self.steps_per_rev steps_per_revolution * microstepping self.current_step 0 def move_to_angle(self, angle_degrees): 移动到指定角度 target_steps int((angle_degrees / 360) * self.steps_per_rev) steps_to_move target_steps - self.current_step if self.is_enabled: # 这里应该实现具体的步进电机控制逻辑 self.current_step target_steps self.current_position angle_degrees print(fStepper moved to {angle_degrees}°) return True return False class RobotController: 机器人总控制器 def __init__(self): self.motors {} self.safety_monitor SafetyMonitor() self.emergency_stop False def add_motor(self, name, motor_driver): 添加电机 self.motors[name] motor_driver def initialize(self): 初始化所有电机 for name, motor in self.motors.items(): motor.enable() print(All motors initialized and enabled) def execute_trajectory_point(self, joint_positions): 执行轨迹点 if self.emergency_stop: print(Emergency stop active - movement blocked) return False # 检查安全性 if not self.safety_monitor.check_safety(joint_positions): print(Safety check failed) return False # 执行运动 for joint, position in joint_positions.items(): if joint in self.motors: success self.motors[joint].set_position(position) if not success: print(fMovement failed for {joint}) return False print(fTrajectory point executed: {joint_positions}) return True def emergency_stop_handler(self): 紧急停止处理 self.emergency_stop True for motor in self.motors.values(): motor.disable() print(EMERGENCY STOP ACTIVATED) class SafetyMonitor: 安全监控器 def __init__(self, joint_limitsNone): self.joint_limits joint_limits or {} self.last_positions {} def check_safety(self, target_positions): 检查目标位置是否安全 for joint, position in target_positions.items(): if joint in self.joint_limits: limits self.joint_limits[joint] if position limits[lower] or position limits[upper]: print(fJoint {joint} position {position} out of limits) return False # 检查运动速度简化实现 if joint in self.last_positions: # 这里应该实现完整的速度检查 pass self.last_positions[joint] position return True # 完整的使用示例 def complete_robot_control_demo(): # 创建控制器 controller RobotController()