企业官网建设流程全解析

在实际工业机器人开发、教学或仿真项目中，我们有时需要复刻或模拟真实示教器的操作体验。无论是为了离线编程、培训教学，还是为了在没有实体硬件的情况下测试机器人程序，一个功能完备的虚拟示教器都至关重要。本文将以“Peak示教器”为概念原型，结合工业机器人领域的通用实践，讲解如何从零开始构建一个基础的虚拟示教器，并实现与机器人仿真环境（如KUKA Sim、FANUC ROBOGUIDE的虚拟控制器）或真实控制器的连接与程序控制。

本文适合有一定机器人操作系统（ROS）基础、熟悉Python或C++编程，并希望深入理解示教器工作原理的开发者。我们将从概念设计开始，逐步完成环境搭建、界面开发、通信协议实现、关键功能（如点动、程序运行）集成，最后讨论如何排查连接与运行中的常见问题。通过本文，你将能够搭建一个可运行、可扩展的虚拟示教器原型，理解其与机器人控制器交互的核心链路。

1. 理解虚拟示教器的核心架构与通信机制

在动手编码之前，必须厘清虚拟示教器是什么，以及它是如何与机器人控制器“对话”的。这决定了我们后续技术栈的选择和整体设计。

1.1 虚拟示教器的角色与功能

示教器（Teach Pendant）是操作工业机器人的核心手持设备。一个典型的虚拟示教器需要模拟以下核心功能：

• 状态显示：显示机器人当前坐标（关节角、笛卡尔坐标）、运行模式（T1/T2/AUTO）、程序状态、报警信息等。
• 手动操作（点动）：通过虚拟按键或摇杆控制机器人各关节或沿工具/基坐标系方向移动。
• 程序管理：加载、编辑、选择、启动、停止机器人程序。
• I/O控制：查看和设置数字/模拟输入输出信号。
• 系统设置：访问部分系统变量和参数。

虚拟示教器软件运行在PC上，它通过网络或特定总线与机器人控制器通信。控制器可以是：

1. 真实控制器：如KUKA KRC4、FANUC R-30iB等。
2. 虚拟控制器（仿真软件）：如KUKA Sim（运行KUKA.OfficeLite）、FANUC ROBOGUIDE、ABB RobotStudio等软件内部的虚拟控制器。

1.2 核心通信协议分析

虚拟示教器与控制器之间的通信是项目成败的关键。不同品牌机器人使用不同的私有协议，但通常都会提供某种形式的开放接口。

• KUKA机器人：主要通过KUKA.Ethernet KRL (EKI)或KUKA.Robot Sensor Interface (RSI)进行TCP/IP通信。EKI允许在KRL程序中创建Socket服务器/客户端，与外部系统交换数据。更现代的方式是使用KUKA.Connectivity Package提供的标准化接口。对于虚拟示教器，我们通常模拟一个客户端，向控制器的特定端口发送指令数据包并接收状态数据包。
• FANUC机器人：提供FANUC iPendant SDK（用于开发真实示教器应用）和FANUC Robot Interface (FRI)或KAREL编程接口进行Socket通信。也可以通过FANUC PCDK (PC Developer‘s Kit)进行更底层的控制。在仿真环境中，ROBOGUIDE的虚拟控制器也开放了类似的Socket接口用于外部控制。
• 通用仿真环境（如ROS/CoppeliaSim）：如果机器人模型运行在ROS或CoppeliaSim中，通信则基于ROS Topic/Service或CoppeliaSim的远程API（通常也是Socket）。这种方式更标准化，适合快速原型开发。

注意：与真实工业控制器通信需要严格遵守其安全规范，不当的指令可能导致设备损坏或人身伤害。在仿真环境中充分测试是所有操作的前提。

基于以上分析，一个可扩展的虚拟示教器架构应包含以下层次：

1. 用户界面层 (UI)：提供按钮、摇杆、状态显示区域。
2. 业务逻辑层：处理UI事件，将其转换为具体的机器人指令（如“点动J1轴正方向”）。
3. 通信适配层：将指令封装成目标控制器能识别的协议格式，并通过网络发送；同时接收并解析控制器返回的状态数据，更新UI。
4. 机器人控制器：接收指令，执行运动或逻辑，返回状态。

本文将采用Python + PyQt5开发UI和逻辑，使用socket进行网络通信，并以一个运行在CoppeliaSim中的仿真机器人作为控制目标进行演示。这种方法原理通用，后续可通过替换通信适配层来对接KUKA或FANUC的虚拟控制器。

2. 开发环境准备与项目结构搭建

我们选择Python和CoppeliaSim进行演示，因为它们易于获取和搭建，能快速验证核心流程。

2.1 软件与依赖安装

首先，确保你的开发环境已安装以下软件：

安装完成后，验证PyQt5是否成功安装：

python -c "from PyQt5 import QtWidgets; print('PyQt5 import successful')"

2.2 创建项目目录结构

一个清晰的项目结构有助于管理代码。创建如下目录和文件：

virtual_teach_pendant/ ├── main.py # 程序主入口 ├── ui/ │ ├── __init__.py │ ├── main_window.py # 主窗口UI类 │ └── resources.py # 图标等资源（可选） ├── core/ │ ├── __init__.py │ ├── robot_controller.py # 机器人控制逻辑抽象类 │ └── sim_controller.py # CoppeliaSim控制器具体实现 ├── comm/ │ ├── __init__.py │ └── sim_connector.py # CoppeliaSim远程API连接器 ├── config/ │ └── settings.yaml # 配置文件（IP、端口、速度等） └── utils/ ├── __init__.py └── logger.py # 日志工具

2.3 CoppeliaSim仿真场景准备

在CoppeliaSim中，我们需要一个简单的机器人模型来接收指令。

1. 打开CoppeliaSim。
2. 从模型浏览器中拖入一个现成的机器人模型，例如Components -> robots -> non-mobile -> UR5（Universal Robots的UR5）。
3. 确保机器人有一个可驱动的关节（通常是旋转关节）。在场景层次结构中，找到机器人的基座关节（如UR5_joint1），检查其属性。
4. 关键一步：启用远程API服务器。在CoppeliaSim菜单栏选择Tools -> Child script attached to...，选择场景根对象（通常叫/），在弹出的脚本编辑器中，添加以下Lua代码来启动服务器：

   -- 在sysCall_init函数中或文件末尾添加 simRemoteApi.start(19999) -- 19999是端口号，可自定义

5. 保存场景为ur5_scene.ttt。

现在，CoppeliaSim端的准备工作完成，它会在端口19999上监听来自我们Python程序的连接。

3. 实现通信层与机器人控制抽象

通信层是虚拟示教器与机器人之间的桥梁。我们先实现一个通用的连接器，再定义控制器的抽象接口。

3.1 编写CoppeliaSim连接器

在comm/sim_connector.py中，我们使用CoppeliaSim提供的远程API（基于Socket）进行通信。

# comm/sim_connector.py import sys import os import time # 添加CoppeliaSim的Python API路径 coppelia_path = r'D:\CoppeliaSim\programming\remoteApiBindings\python' # 请修改为你的实际路径 sys.path.append(coppelia_path) try: import sim except Exception as e: print(f"无法导入CoppeliaSim API: {e}") print(f"请检查路径: {coppelia_path}") sys.exit(1) class CoppeliaSimConnector: """负责管理与CoppeliaSim仿真环境的连接和基础通信。""" def __init__(self, ip='127.0.0.1', port=19999): self.client_id = -1 self.ip = ip self.port = port self._connected = False def connect(self): """连接到CoppeliaSim远程API服务器。""" sim.simxFinish(-1) # 关闭所有现有连接 self.client_id = sim.simxStart(self.ip, self.port, True, True, 5000, 5) if self.client_id != -1: print(f"成功连接到CoppeliaSim (Client ID: {self.client_id})") # 启动同步模式，确保数据发送后等待响应 sim.simxSynchronous(self.client_id, True) self._connected = True return True else: print(f"连接CoppeliaSim失败，请检查仿真是否运行且端口{self.port}已开放。") self._connected = False return False def disconnect(self): """断开连接。""" if self._connected: sim.simxFinish(self.client_id) self._connected = False print("已断开与CoppeliaSim的连接。") def is_connected(self): return self._connected def get_object_handle(self, object_name): """获取场景中对象的句柄。""" if not self._connected: return None res, handle = sim.simxGetObjectHandle(self.client_id, object_name, sim.simx_opmode_blocking) if res == sim.simx_return_ok: return handle else: print(f"获取对象 '{object_name}' 句柄失败。错误码: {res}") return None def set_joint_target_position(self, joint_handle, target_angle_rad): """设置关节的目标位置（弧度）。""" if not self._connected: return False res = sim.simxSetJointTargetPosition(self.client_id, joint_handle, target_angle_rad, sim.simx_opmode_oneshot) return res == sim.simx_return_ok def get_joint_position(self, joint_handle): """获取关节的当前位置（弧度）。""" if not self._connected: return None res, pos = sim.simxGetJointPosition(self.client_id, joint_handle, sim.simx_opmode_blocking) if res == sim.simx_return_ok: return pos else: return None def trigger_simulation_step(self): """触发仿真步进（在同步模式下必须调用）。""" if self._connected: sim.simxSynchronousTrigger(self.client_id)

3.2 定义机器人控制器抽象类

为了未来能方便地切换不同的机器人品牌（如KUKA, FANUC），我们定义一个抽象类RobotController。

# core/robot_controller.py from abc import ABC, abstractmethod class RobotController(ABC): """机器人控制器的抽象接口。""" @abstractmethod def connect(self): """连接到机器人控制器。""" pass @abstractmethod def disconnect(self): """断开连接。""" pass @abstractmethod def is_connected(self): """返回连接状态。""" pass @abstractmethod def jog_joint(self, joint_index, direction, speed): """ 点动指定关节。 :param joint_index: 关节索引，从0或1开始。 :param direction: 方向，+1为正方向，-1为负方向。 :param speed: 点动速度（归一化值或具体速度值）。 :return: 是否成功。 """ pass @abstractmethod def get_joint_positions(self): """获取所有关节的当前位置（弧度或度）。""" pass @abstractmethod def start_program(self, program_name): """启动指定名称的程序。""" pass @abstractmethod def stop_program(self): """停止当前运行的程序。""" pass @abstractmethod def get_robot_status(self): """获取机器人状态（运行、停止、报警等）。""" pass

3.3 实现CoppeliaSim控制器

接着，我们实现针对CoppeliaSim的具体控制器。

# core/sim_controller.py from .robot_controller import RobotController from comm.sim_connector import CoppeliaSimConnector import threading import time class SimRobotController(RobotController): """用于控制CoppeliaSim中机器人的具体实现。""" def __init__(self, joint_names, ip='127.0.0.1', port=19999): """ :param joint_names: 机器人关节在CoppeliaSim中的名称列表，如['UR5_joint1', 'UR5_joint2', ...] """ self.connector = CoppeliaSimConnector(ip, port) self.joint_names = joint_names self.joint_handles = [] self._jogging = False self._jog_thread = None self._lock = threading.Lock() def connect(self): if not self.connector.connect(): return False # 获取所有关节的句柄 self.joint_handles = [] for name in self.joint_names: handle = self.connector.get_object_handle(name) if handle is not None: self.joint_handles.append(handle) else: print(f"警告：未能找到关节 '{name}'，连接可能不完整。") # 可以选择断开连接或继续 return len(self.joint_handles) == len(self.joint_names) def disconnect(self): self.stop_jogging() self.connector.disconnect() def is_connected(self): return self.connector.is_connected() def jog_joint(self, joint_index, direction, speed): """点动：设置一个持续的目标位置偏移。""" if not 0 <= joint_index < len(self.joint_handles): return False # 这里采用一个简单的实现：启动一个后台线程持续修改目标位置 # 实际项目中，点动逻辑可能更复杂，需要考虑速度曲线和急停。 def _jog_worker(): step = 0.01 * direction * speed # 计算每一步的偏移量（弧度） while self._jogging: with self._lock: current_pos = self.connector.get_joint_position(self.joint_handles[joint_index]) if current_pos is not None: new_target = current_pos + step self.connector.set_joint_target_position(self.joint_handles[joint_index], new_target) self.connector.trigger_simulation_step() time.sleep(0.05) # 控制点动频率 if not self._jogging: self._jogging = True self._jog_thread = threading.Thread(target=_jog_worker, daemon=True) self._jog_thread.start() return True return False def stop_jogging(self): """停止所有点动。""" self._jogging = False if self._jog_thread: self._jog_thread.join(timeout=1.0) self._jog_thread = None def get_joint_positions(self): """获取所有关节当前位置。""" positions = [] with self._lock: for handle in self.joint_handles: pos = self.connector.get_joint_position(handle) if pos is not None: positions.append(pos) else: positions.append(0.0) return positions def start_program(self, program_name): """在CoppeliaSim中，'程序'可能对应一个特定的脚本或序列。这里简单打印。""" print(f"[Sim Controller] 启动程序: {program_name}") # 实际实现可能需要调用CoppeliaSim的脚本函数或发送特定信号 return True def stop_program(self): print(f"[Sim Controller] 停止程序") return True def get_robot_status(self): """返回一个模拟状态字典。""" return { 'connected': self.is_connected(), 'mode': 'T1', # 仿真模式 'program_running': False, 'error_code': 0, 'error_msg': '' }

4. 构建虚拟示教器用户界面

UI是用户与虚拟示教器交互的窗口。我们将使用PyQt5创建一个包含状态显示、点动按钮和程序控制区域的主窗口。

4.1 设计主窗口UI

在ui/main_window.py中，我们通过代码构建UI（也可以使用Qt Designer生成.ui文件再加载）。

# ui/main_window.py from PyQt5.QtWidgets import (QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLabel, QGroupBox, QGridLayout, QComboBox, QTextEdit, QApplication) from PyQt5.QtCore import Qt, QTimer import sys class TeachPendantWindow(QMainWindow): def __init__(self, robot_controller): super().__init__() self.controller = robot_controller self.init_ui() self.init_timer() def init_ui(self): self.setWindowTitle('Virtual Teach Pendant - Peak Replica') self.setGeometry(300, 300, 800, 600) central_widget = QWidget() self.setCentralWidget(central_widget) main_layout = QVBoxLayout(central_widget) # 1. 状态显示区域 status_group = QGroupBox("机器人状态") status_layout = QGridLayout() self.lbl_connection = QLabel('未连接') self.lbl_connection.setStyleSheet('color: red; font-weight: bold;') self.lbl_mode = QLabel('模式: --') self.lbl_program = QLabel('程序: --') self.lbl_error = QLabel('报警: 无') self.lbl_joint_positions = [] for i in range(6): # 假设是6轴机器人 lbl = QLabel(f'J{i+1}: 0.000 rad') self.lbl_joint_positions.append(lbl) status_layout.addWidget(QLabel(f'关节{i+1}:'), i, 0) status_layout.addWidget(lbl, i, 1) status_layout.addWidget(QLabel('连接状态:'), 6, 0) status_layout.addWidget(self.lbl_connection, 6, 1) status_layout.addWidget(self.lbl_mode, 7, 0) status_layout.addWidget(self.lbl_program, 7, 1) status_layout.addWidget(self.lbl_error, 8, 0, 1, 2) status_group.setLayout(status_layout) main_layout.addWidget(status_group) # 2. 点动控制区域 jog_group = QGroupBox("关节点动 (JOG)") jog_layout = QGridLayout() self.jog_buttons = [] # 创建每个关节的正负方向按钮 for i in range(6): btn_neg = QPushButton(f'J{i+1}-') btn_pos = QPushButton(f'J{i+1}+') # 连接按钮的按下和释放事件 btn_neg.pressed.connect(lambda checked, idx=i, dir=-1: self.on_jog_pressed(idx, dir)) btn_neg.released.connect(self.on_jog_released) btn_pos.pressed.connect(lambda checked, idx=i, dir=1: self.on_jog_pressed(idx, dir)) btn_pos.released.connect(self.on_jog_released) jog_layout.addWidget(QLabel(f'关节{i+1}'), i, 0) jog_layout.addWidget(btn_neg, i, 1) jog_layout.addWidget(btn_pos, i, 2) self.jog_buttons.append((btn_neg, btn_pos)) # 点动速度选择 self.cmb_speed = QComboBox() self.cmb_speed.addItems(['低速 (10%)', '中速 (30%)', '高速 (70%)', '全速 (100%)']) self.cmb_speed.setCurrentIndex(1) jog_layout.addWidget(QLabel('点动速度:'), 6, 0) jog_layout.addWidget(self.cmb_speed, 6, 1, 1, 2) jog_group.setLayout(jog_layout) main_layout.addWidget(jog_group) # 3. 程序控制区域 prog_group = QGroupBox("程序控制") prog_layout = QHBoxLayout() self.cmb_program = QComboBox() self.cmb_program.addItems(['程序1', '程序2', '测试程序']) btn_load = QPushButton('加载') btn_start = QPushButton('启动') btn_stop = QPushButton('停止') btn_pause = QPushButton('暂停') # 暂停功能在仿真中可能需额外实现 btn_load.clicked.connect(self.on_load_program) btn_start.clicked.connect(self.on_start_program) btn_stop.clicked.connect(self.on_stop_program) btn_pause.clicked.connect(self.on_pause_program) prog_layout.addWidget(QLabel('选择程序:')) prog_layout.addWidget(self.cmb_program) prog_layout.addWidget(btn_load) prog_layout.addWidget(btn_start) prog_layout.addWidget(btn_stop) prog_layout.addWidget(btn_pause) prog_layout.addStretch() prog_group.setLayout(prog_layout) main_layout.addWidget(prog_group) # 4. 连接控制与日志 ctrl_layout = QHBoxLayout() self.btn_connect = QPushButton('连接机器人') self.btn_disconnect = QPushButton('断开连接') self.btn_connect.clicked.connect(self.on_connect) self.btn_disconnect.clicked.connect(self.on_disconnect) self.btn_disconnect.setEnabled(False) ctrl_layout.addWidget(self.btn_connect) ctrl_layout.addWidget(self.btn_disconnect) ctrl_layout.addStretch() main_layout.addLayout(ctrl_layout) self.txt_log = QTextEdit() self.txt_log.setReadOnly(True) self.txt_log.setMaximumHeight(100) main_layout.addWidget(QLabel('日志:')) main_layout.addWidget(self.txt_log) def init_timer(self): """定时器用于定期更新机器人状态显示。""" self.timer = QTimer() self.timer.timeout.connect(self.update_status) self.timer.start(200) # 每200ms更新一次 def log_message(self, msg): """在日志框中添加消息。""" self.txt_log.append(f"[{QDateTime.currentDateTime().toString('hh:mm:ss')}] {msg}") def update_status(self): """更新所有状态显示。""" if self.controller and self.controller.is_connected(): self.lbl_connection.setText('已连接') self.lbl_connection.setStyleSheet('color: green; font-weight: bold;') # 获取并显示关节位置 positions = self.controller.get_joint_positions() for i, pos in enumerate(positions): if i < len(self.lbl_joint_positions): self.lbl_joint_positions[i].setText(f'J{i+1}: {pos:.3f} rad') # 获取机器人状态 status = self.controller.get_robot_status() self.lbl_mode.setText(f"模式: {status.get('mode', '--')}") self.lbl_program.setText(f"程序: {'运行中' if status.get('program_running') else '停止'}") if status.get('error_code', 0) != 0: self.lbl_error.setText(f"报警: {status.get('error_msg', '未知错误')}") self.lbl_error.setStyleSheet('color: red;') else: self.lbl_error.setText('报警: 无') self.lbl_error.setStyleSheet('') else: self.lbl_connection.setText('未连接') self.lbl_connection.setStyleSheet('color: red; font-weight: bold;') for lbl in self.lbl_joint_positions: lbl.setText('--') self.lbl_mode.setText('模式: --') self.lbl_program.setText('程序: --') self.lbl_error.setText('报警: --') # ---------- 槽函数 ---------- def on_connect(self): if self.controller.connect(): self.log_message("成功连接到机器人控制器。") self.btn_connect.setEnabled(False) self.btn_disconnect.setEnabled(True) else: self.log_message("连接失败，请检查网络和控制器状态。") def on_disconnect(self): self.controller.disconnect() self.log_message("已断开连接。") self.btn_connect.setEnabled(True) self.btn_disconnect.setEnabled(False) def on_jog_pressed(self, joint_index, direction): speed_map = [0.1, 0.3, 0.7, 1.0] speed = speed_map[self.cmb_speed.currentIndex()] if self.controller.is_connected(): self.controller.jog_joint(joint_index, direction, speed) self.log_message(f"点动 J{joint_index+1} {'+' if direction>0 else '-'}") def on_jog_released(self): # 停止点动 if self.controller.is_connected(): self.controller.stop_jogging() def on_load_program(self): prog_name = self.cmb_program.currentText() self.log_message(f"加载程序: {prog_name}") # 此处可添加实际加载程序的逻辑 def on_start_program(self): prog_name = self.cmb_program.currentText() if self.controller.is_connected(): if self.controller.start_program(prog_name): self.log_message(f"程序 '{prog_name}' 已启动。") else: self.log_message(f"启动程序 '{prog_name}' 失败。") def on_stop_program(self): if self.controller.is_connected(): if self.controller.stop_program(): self.log_message("程序已停止。") def on_pause_program(self): self.log_message("暂停功能待实现。")

4.2 编写程序主入口

最后，在main.py中整合所有部分，启动应用。

# main.py import sys from PyQt5.QtWidgets import QApplication from ui.main_window import TeachPendantWindow from core.sim_controller import SimRobotController def main(): # 1. 定义CoppeliaSim中机器人关节的名称（根据你的场景修改） joint_names = [ 'UR5_joint1', 'UR5_joint2', 'UR5_joint3', 'UR5_joint4', 'UR5_joint5', 'UR5_joint6' ] # 2. 创建机器人控制器实例 robot_ip = '127.0.0.1' robot_port = 19999 controller = SimRobotController(joint_names, ip=robot_ip, port=robot_port) # 3. 创建Qt应用和主窗口 app = QApplication(sys.argv) window = TeachPendantWindow(controller) window.show() # 4. 运行应用 sys.exit(app.exec_()) if __name__ == '__main__': main()

5. 运行验证与功能测试

现在，让我们将虚拟示教器与CoppeliaSim仿真环境连接起来，测试核心功能。

5.1 启动与连接测试

1. 启动CoppeliaSim并加载场景：打开CoppeliaSim，加载之前保存的ur5_scene.ttt场景。确保场景已运行（点击播放按钮）。
2. 启动虚拟示教器：在命令行中，进入项目目录，运行python main.py。虚拟示教器窗口应弹出。
3. 建立连接：点击示教器上的“连接机器人”按钮。观察日志区域，应显示“成功连接到机器人控制器”。同时，“连接状态”应变为绿色“已连接”。关节位置应开始显示实时数据（可能都是0，因为机器人尚未运动）。

如果连接失败，请检查：

• CoppeliaSim是否正在运行且场景已开始仿真。
• CoppeliaSim中的远程API服务器端口（默认为19999）是否与代码中的robot_port一致。
• 防火墙是否阻止了本地回环地址（127.0.0.1）的通信。
• CoppeliaSim Python API路径是否正确。

5.2 点动功能测试

1. 选择点动速度：在“关节点动”区域，从下拉框中选择一个速度，例如“中速 (30%)”。
2. 执行点动：按下J1+按钮（不要松开）。你应该能在CoppeliaSim的3D视图中看到UR5机器人的第一个关节（基座旋转关节）开始缓慢旋转。同时，虚拟示教器上“关节1”的数值会持续变化。
3. 停止点动：松开J1+按钮。机器人应立即停止运动。
4. 测试其他关节：重复步骤2-3，测试其他关节（J2+, J3-, 等）的点动功能。确保每个关节都能按预期方向运动。

5.3 程序控制功能测试

1. 加载程序：在“程序控制”区域，从下拉框中选择一个程序（如“测试程序”），点击“加载”。日志区会显示相应消息。
2. 启动程序：点击“启动”。由于我们的SimRobotController.start_program方法目前只是打印日志，所以CoppeliaSim中的机器人不会执行复杂动作。但这验证了UI到控制器的指令通路是通的。
3. 停止程序：点击“停止”。同样会看到日志。

至此，一个具备基础连接、状态显示、点动和程序控制功能的虚拟示教器原型已经可以运行。

6. 常见问题排查与进阶调试

在实际开发中，你可能会遇到各种问题。以下是针对此类虚拟示教器项目的常见问题排查清单。

6.1 连接类问题

6.2 点动与运动控制问题

6.3 程序与逻辑问题

7. 扩展方向与生产环境建议

目前我们实现的是一个基础原型。要将其发展为可用于更严肃场景的工具，需要考虑以下扩展和优化。

7.1 功能扩展

1. 笛卡尔坐标系点动：实现基于工具坐标系或基坐标系的线性运动和旋转运动。这需要机器人正逆运动学知识，可以集成pytransform3d或roboticstoolbox等库进行计算，或将计算任务交给控制器。
2. 程序编辑与存储：集成一个简单的代码编辑器，允许用户编写、保存和加载机器人指令序列（如简单的moveL, moveJ命令）。
3. I/O信号监控：添加面板显示和设置CoppeliaSim或真实控制器中的数字/模拟输入输出信号。
4. 坐标系管理：管理工具坐标系（TCP）和用户坐标系（Work Object）的创建、选择和切换。
5. 报警历史与复位：更完善地解析和显示控制器报警信息，并提供报警复位功能。

7.2 对接真实工业控制器

要连接KUKA或FANUC的真实或虚拟控制器，需要替换RobotController的实现：

• 对接KUKA：

  • 研究协议：深入学习KUKA.Ethernet KRL (EKI)。你需要编写KRL端（机器人控制器）的服务器程序，以及Python端的客户端程序。数据格式通常是二进制或特定字符串。
  • 使用现有库：搜索并评估开源库如pykuka（如果存在且维护），但通常需要自己实现协议解析。
  • 安全第一：真实机器人点动必须启用“安全运行模式”（如KUKA的T1模式），并考虑使能开关、安全停等安全信号。

• 对接FANUC：

  • 使用PCDK：FANUC PCDK提供了.NET库，可以通过Python的pythonnet调用，但配置复杂。
  • Socket通信：在FANUC控制器上编写KAREL程序或设置后台逻辑，通过Socket与外部PC通信。这是更通用的方法。
  • ROBOGUIDE：FANUC的仿真软件ROBOGUIDE也支持通过Socket与外部应用交互，可以将其作为测试目标。

7.3 生产环境注意事项

如果计划在接近生产的环境中使用（即使是连接仿真器），需考虑：

1. 错误处理与日志：当前示例的错误处理较为简单。应增加更全面的异常捕获、重试机制和详细的文件日志，便于离线排查。
2. 线程安全：多个线程（如UI线程、点动线程、状态查询线程）访问共享资源（如连接对象、关节数据）时，必须使用锁（如示例中的_lock）确保数据一致性。
3. 配置外置：将机器人IP、端口、关节名称、速度映射等全部移至外部配置文件（如YAML），避免硬编码。
4. 心跳与超时：实现心跳机制，定期检查连接是否存活。设置合理的Socket读写超时，防止界面因网络问题而卡死。
5. UI响应性：将所有可能耗时的网络操作放入工作线程（QThread），使用PyQt的信号/槽与主UI线程通信，保持界面流畅。
6. 启动检查：程序启动时，检查必要的依赖（如网络、配置文件、许可）和环境，给出明确的提示。

虚拟示教器的开发是一个系统工程，涉及机器人学、网络通信、软件工程和用户体验。本文提供的原型是一个坚实的起点，通过理解其每一层的设计意图和通信原理，你可以根据具体的机器人品牌和项目需求，对其进行定制和强化，最终构建出满足特定场景需求的强大工具。