企业官网建设流程全解析

在工业机器人应用开发与教学过程中，我们常常会遇到一个痛点：真实的工业机器人示教器价格昂贵、体积庞大，且不便于随时随地学习和调试。无论是学生自学、工程师进行离线仿真，还是项目前期的方案验证，都迫切需要一种低成本、高灵活性的替代方案。本文将围绕“Peak示教器”这一概念，为你带来一套完整的复刻与虚拟连接实战教程。我们将从零开始，利用常见的硬件和开源软件，构建一个功能完备的虚拟示教器，并实现与KUKA、发那科等主流机器人仿真环境的连接与控制。无论你是机器人专业的在校学生，还是希望提升离线编程能力的工程师，都能通过本文掌握从硬件选型、软件配置到程序自动运行的全流程实操技能。

1. 背景与核心概念

在深入动手之前，我们首先要厘清几个关键概念，这有助于理解我们正在构建的是什么，以及它能解决什么问题。

1.1 什么是示教器？

示教器（Teach Pendant），是工业机器人的人机交互接口。你可以把它想象成机器人的“遥控器”和“编程器”的结合体。操作人员通过它上面的按键、摇杆（使能开关）和触摸屏，可以手动操纵机器人移动（示教点位），编写和调试机器人程序，设置参数，以及监控机器人状态。它是机器人现场调试、维护和编程不可或缺的设备。

1.2 为什么需要“复刻”或“虚拟”示教器？

真实示教器存在一些局限性：

1. 成本高昂：一台原厂示教器价格动辄数万甚至数十万元。
2. 携带不便：体积大、重量重，不适合移动学习和演示。
3. 资源紧张：在教育培训机构或实验室，机器人本体数量有限，与之配套的示教器更少，学生实操机会不足。
4. 离线开发需求：工程师希望在办公室电脑上就能完成程序的编写和初步仿真，无需占用产线设备。

因此，“复刻”或“虚拟”示教器的核心价值在于：用低廉的通用硬件（如游戏手柄、触摸屏、自制按键板）和软件模拟，实现真实示教器的主要功能，并与机器人仿真软件（如KUKA Sim Pro、RoboDK、发那科 ROBOGUIDE）或真实的机器人控制器（通过网络）进行连接交互。

1.3 “Peak示教器”是什么？

“Peak”在这里并非指某个特定品牌产品。在技术社区语境中，“Peak示教器”更多是指一种追求极致性价比和功能完备性的自制或虚拟示教器方案。它可能指：

• 硬件复刻：使用Arduino、树莓派等开发板，配合按键、摇杆、显示屏，自制一个物理外形和功能类似真实示教器的设备。
• 软件虚拟：在PC上开发一个软件界面，模拟示教器的屏幕和按键逻辑，通过USB或网络与仿真环境通信。
• 混合方案：将上述两者结合，例如用平板电脑作为显示和触摸交互端，用蓝牙手柄作为手动操纵的输入设备。

本文的教程将涵盖一个软硬件结合的混合方案，因为它既能提供接近真实的操作手感，又具有较高的灵活性和较低的成本。

2. 环境准备与版本说明

开始构建前，请确保准备好以下环境和工具。版本号仅供参考，重点是理解工具链的构成。

2.1 硬件准备

1. 主控开发板（可选，用于硬件复刻）：
   • 推荐：Raspberry Pi 4B (4GB RAM 或以上) 或 Arduino Mega 2560。
   • 作用：树莓派适合运行完整的操作系统和复杂逻辑；Arduino更适合简单的按键扫描和摇杆信号读取。
   • 本文示例侧重：我们将以树莓派作为核心，因为它能同时运行服务端程序和提供USB/网络接口。
2. 输入设备：
   • USB游戏手柄/摇杆：推荐使用Xbox 360兼容手柄或罗技F310等，它们能提供高质量的模拟摇杆和多个按键。用于模拟示教器的使能开关和手动操纵杆。
   • 触摸显示屏：7寸HDMI触摸屏，用于树莓派，作为示教器的显示和触摸输入界面。
   • 自定义按键板（可选）：如果需要更接近真实布局，可以使用薄膜按键矩阵或独立按键连接树莓派GPIO。
3. 运行仿真软件的PC：
   • 操作系统：Windows 10/11 64位 或 Linux。
   • 配置：建议具备独立显卡，以确保机器人仿真软件流畅运行。

2.2 软件准备

1. 机器人仿真软件（任选其一）：
   • KUKA：KUKA Sim 或 KUKA.OfficeLite (需授权)。我们将配置其虚拟示教器连接接口。
   • FANUC：FANUC ROBOGUIDE (需授权)。用于模拟发那科机器人及程序自动运行。
   • 跨平台仿真：RoboDK (有免费版)。它支持众多品牌机器人，且提供了丰富的API接口，非常适合与自制示教器集成。
   • 本文示例将使用 RoboDK 进行演示，因为其API开放，易于集成。
2. 开发与通信软件：
   • 树莓派系统：Raspberry Pi OS (Legacy) with desktop。
   • 编程语言：Python 3.8+。Python拥有丰富的库支持串口、网络、GUI开发。
   • Python关键库：

     # 通过pip安装 pip install pygame # 用于读取游戏手柄输入 pip install pyserial # 用于串口通信（如果连接Arduino） pip install websockets # 用于WebSocket通信（推荐） pip install PyQt5 # 或 tkinter，用于构建本地GUI界面（可选）

   • 网络调试工具：Wireshark (用于分析通信协议，高级需求)，Postman (用于测试REST API)。

2.3 项目结构概览

在开始编码前，我们先规划一个清晰的项目目录结构：

peak_teach_pendant/ ├── hardware/ # 硬件相关代码（如Arduino固件） │ ├── arduino_sketch/ │ └── rpi_gpio_driver.py ├── software/ # 软件核心 │ ├── server/ # 运行在树莓派或PC上的服务端 │ │ ├── main_server.py │ │ ├── input_handler.py # 处理手柄/按键输入 │ │ └── comm_protocol.py # 定义通信协议 │ ├── client/ # 可选的PC端测试客户端 │ │ └── test_client.py │ └── gui/ # 示教器GUI界面（PyQt） │ ├── main_window.py │ └── widgets.py ├── sim_interface/ # 与仿真软件交互的接口 │ ├── robodk_client.py │ └── kuka_sim_interface.py (示例) ├── config/ # 配置文件 │ └── settings.yaml ├── requirements.txt # Python依赖列表 └── README.md

3. 核心原理与通信协议拆解

虚拟示教器要工作，核心在于双向通信。它需要将操作者的输入（如摇杆偏移量、按键事件）发送给机器人控制器/仿真软件，并接收来自后者的状态反馈（如当前位置、错误信息）进行显示。

3.1 通信方式选择

1. TCP/IP Socket (最通用)：
   • 原理：在树莓派（服务端）和运行仿真软件的PC（客户端）之间建立TCP连接。
   • 优点：跨平台、稳定、带宽足够。仿真软件通常支持Socket服务器或客户端模式。
   • 应用：RoboDK、KUKA Sim等可以通过Socket接收外部指令。
2. WebSocket：
   • 原理：在TCP之上建立的全双工通信协议。
   • 优点：更适合实时、高频的交互，如持续发送摇杆数据。连接建立后，通信开销小。
   • 应用：现代仿真软件或Web版控制界面常采用。
3. REST API：
   • 原理：基于HTTP的请求-响应模式。
   • 优点：易于理解和测试，适合发送离散指令（如“启动程序”、“急停”）。
   • 缺点：实时性稍差，不适合连续控制。
4. UDP：
   • 原理：无连接协议，速度快，但可能丢包。
   • 优点：延迟极低。
   • 缺点：可靠性需应用层保证。适合对实时性要求极高，且能容忍偶尔数据丢失的场景（如高速遥操作）。
5. 串口/UART (用于连接硬件微控制器)：
   • 原理：树莓派通过USB或GPIO与Arduino等板卡通信。
   • 应用：当使用Arduino读取按键和摇杆时，树莓派通过串口从Arduino获取数据。

本文推荐方案：在树莓派上运行一个WebSocket服务器，PC上的仿真软件（如RoboDK）作为客户端连接上来。同时，在树莓派上运行一个PyGame程序来读取USB手柄的输入。

3.2 数据协议设计

我们需要定义一套简单的应用层协议来传递信息。这里使用JSON格式，因为它易读、易解析。

从示教器 -> 仿真软件的消息示例：

{ “type”: “control”, “timestamp”: 1646389201.123, “data”: { “joystick_left”: {“x”: 0.15, “y”: -0.08, “z”: 0.0}, “joystick_right”: {“x”: 0.0, “y”: 0.0, “z”: 0.95}, “button_enable”: true, “button_start”: false, “button_stop”: true, “speed_override”: 50 } }

• type: 消息类型，如control（控制）、command（命令）、query（查询）。
• joystick_left/right: 左右摇杆的归一化坐标值（-1.0 到 1.0）。
• button_*: 布尔值，表示按键是否按下。
• speed_override: 速度百分比。

从仿真软件 -> 示教器的消息示例：

{ “type”: “status”, “timestamp”: 1646389201.125, “data”: { “robot_status”: “running”, // idle, running, paused, error “current_position”: [100.5, 200.3, 300.1, 0.0, 90.0, 0.0], “current_speed”: 30, “error_code”: 0, “error_msg”: “” } }

4. 完整实战案例：构建Peak虚拟示教器并与RoboDK连接

我们将分步骤实现一个能与RoboDK通信的基本虚拟示教器。

4.1 第一步：搭建树莓派WebSocket服务器和输入处理

首先在树莓派上创建我们的服务端程序。

文件：/home/pi/peak_teach_pendant/software/server/main_server.py

#!/usr/bin/env python3 import asyncio import websockets import json import pygame from datetime import datetime import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # 初始化Pygame读取手柄 pygame.init() pygame.joystick.init() if pygame.joystick.get_count() > 0: joystick = pygame.joystick.Joystick(0) joystick.init() logger.info(f”检测到手柄: {joystick.get_name()}”) else: logger.error(“未检测到手柄！请连接USB手柄。”) joystick = None # 此处可以退出或使用其他输入方式 # 存储连接的客户端 connected_clients = set() def read_joystick_data(): """读取手柄数据并格式化为字典""" if joystick is None: return None pygame.event.pump() # 处理Pygame事件队列 # 假设手柄有两个摇杆（轴0-1为左摇杆，轴2-3为右摇杆） # 注意：不同手柄映射不同，需要根据实际手柄调整 data = { “joystick_left”: { “x”: joystick.get_axis(0), “y”: joystick.get_axis(1), “z”: 0.0 # 有些手柄有Z轴旋转 }, “joystick_right”: { “x”: joystick.get_axis(2), “y”: joystick.get_axis(3), “z”: 0.0 }, “button_enable”: joystick.get_button(4), # LB按键模拟使能开关 “button_start”: joystick.get_button(7), # Start键 “button_stop”: joystick.get_button(6), # Back键模拟急停 “speed_override”: int((joystick.get_axis(5) + 1) * 50) # RT扳机键映射为速度0-100 } # 对摇杆值进行死区处理，防止微小漂移 deadzone = 0.1 for stick in [“joystick_left”, “joystick_right”]: for axis in [“x”, “y”, “z”]: if abs(data[stick][axis]) < deadzone: data[stick][axis] = 0.0 return data async def handler(websocket, path): """处理WebSocket客户端连接""" client_id = f”{websocket.remote_address[0]}:{websocket.remote_address[1]}” logger.info(f”客户端 {client_id} 已连接”) connected_clients.add(websocket) try: # 发送欢迎消息 await websocket.send(json.dumps({“type”: “hello”, “message”: “Peak Teach Pendant Server Connected”})) # 保持连接，并定时发送控制数据 while True: if joystick: control_data = read_joystick_data() if control_data: message = { “type”: “control”, “timestamp”: datetime.now().timestamp(), “data”: control_data } try: await websocket.send(json.dumps(message)) except websockets.exceptions.ConnectionClosed: break # 控制数据发送频率：20Hz (50ms间隔) await asyncio.sleep(0.05) except websockets.exceptions.ConnectionClosed as e: logger.info(f”客户端 {client_id} 连接关闭: {e}”) finally: connected_clients.remove(websocket) logger.info(f”客户端 {client_id} 已移除”) async def main(): # 启动WebSocket服务器，监听所有网络接口的8765端口 server = await websockets.serve(handler, “0.0.0.0”, 8765) logger.info(“Peak示教器服务器已启动，监听 ws://0.0.0.0:8765”) logger.info(“请确保RoboDK客户端连接到树莓派的IP地址和此端口。”) await server.wait_closed() if __name__ == “__main__”: asyncio.run(main())

运行服务器：在树莓派终端中，进入项目目录并运行：

cd ~/peak_teach_pendant/software/server python3 main_server.py

如果一切正常，你将看到日志输出，提示服务器已启动并检测到手柄。

4.2 第二步：在RoboDK中创建客户端接收控制

RoboDK支持Python脚本，我们可以创建一个脚本连接到我们的示教器服务器，并解析控制指令来驱动机器人。

在RoboDK中：

1. 点击“工具” -> “运行脚本” -> “新建Python脚本”。
2. 将以下代码粘贴进去。

文件：RoboDK_Client.py(在RoboDK Python脚本编辑器中)

# 此脚本在RoboDK中运行，作为WebSocket客户端 import websockets import json import asyncio import threading from robodk import robolink, robomath # 连接到RoboDK RDK = robolink.Robolink() robot = RDK.Item(‘’, robolink.ITEM_TYPE_ROBOT) # 获取当前选择的机器人 if not robot.Valid(): raise Exception(“未选择有效机器人！”) # 示教器服务器的IP和端口（替换为你的树莓派IP） TEACH_PENDANT_IP = “192.168.1.100” # 修改！ TEACH_PENDANT_PORT = 8765 SERVER_URI = f”ws://{TEACH_PENDANT_IP}:{TEACH_PENDANT_PORT}” # 机器人运动参数 MAX_LINEAR_SPEED = 100 # mm/s MAX_JOINT_SPEED = 30 # deg/s is_enabled = False current_speed = 50 # 百分比 def robot_move_linear(dx, dy, dz): """根据摇杆输入，控制机器人末端做线性运动""" if not is_enabled: return # 获取当前末端位姿 pose = robot.Pose() # 计算移动向量（根据摇杆值缩放） move_vector = robomath.Mat([[dx], [dy], [dz], [0], [0], [0]]) move_vector = move_vector * (MAX_LINEAR_SPEED * (current_speed / 100.0) * 0.05) # 0.05是增益系数 # 应用移动（相对移动） new_pose = pose * robomath.Transl(move_vector[0,0], move_vector[1,0], move_vector[2,0]) # 在RoboDK中设置目标，并立即移动（模拟手动操纵） robot.MoveL(new_pose, blocking=False) def robot_move_joints(d_axis1, d_axis2, d_axis3): """根据摇杆输入，控制机器人关节运动（示例控制前三个关节）""" if not is_enabled: return joints = robot.Joints().list() # 计算关节增量（根据摇杆值缩放） joint_speeds = [d_axis1, d_axis2, d_axis3, 0, 0, 0] joint_speeds = [js * (MAX_JOINT_SPEED * (current_speed / 100.0) * 0.05) for js in joint_speeds] new_joints = [j + js for j, js in zip(joints, joint_speeds)] robot.MoveJ(new_joints, blocking=False) async def listen_to_teach_pendant(): """连接示教器服务器并处理消息""" global is_enabled, current_speed print(f”正在连接示教器服务器: {SERVER_URI}”) try: async with websockets.connect(SERVER_URI) as websocket: print(“连接成功！”) async for message in websocket: try: data = json.loads(message) msg_type = data.get(‘type’) if msg_type == ‘control’: control_data = data.get(‘data’, {}) # 更新使能状态 is_enabled = control_data.get(‘button_enable’, False) current_speed = control_data.get(‘speed_override’, 50) # 处理摇杆控制 left_stick = control_data.get(‘joystick_left’, {}) right_stick = control_data.get(‘joystick_right’, {}) # 示例映射：左摇杆控制末端XYZ平移 dx, dy, dz = left_stick.get(‘x’, 0), left_stick.get(‘y’, 0), 0 # 右摇杆控制关节1,2,3 d_j1, d_j2, d_j3 = right_stick.get(‘x’, 0), right_stick.get(‘y’, 0), 0 # 触发机器人运动（在实际应用中，可能需要更精细的运动规划） if is_enabled and (abs(dx) > 0 or abs(dy) > 0 or abs(dz) > 0): robot_move_linear(dx, dy, dz) elif is_enabled and (abs(d_j1) > 0 or abs(d_j2) > 0 or abs(d_j3) > 0): robot_move_joints(d_j1, d_j2, d_j3) # 处理按钮命令 if control_data.get(‘button_start’): print(“[命令] 启动程序”) # 这里可以调用 robot.RunProgram() 等 if control_data.get(‘button_stop’): print(“[命令] 急停”) robot.Stop() elif msg_type == ‘hello’: print(f”服务器问候: {data.get(‘message’)}”) except json.JSONDecodeError as e: print(f”JSON解析错误: {e}”) except Exception as e: print(f”处理消息时出错: {e}”) except Exception as e: print(f”连接失败或断开: {e}”) def run_async_in_thread(): """在新线程中运行异步事件循环""" loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop.run_until_complete(listen_to_teach_pendant()) # 在RoboDK中启动监听线程（避免阻塞主UI） thread = threading.Thread(target=run_async_in_thread, daemon=True) thread.start() print(“RoboDK客户端已启动，等待控制指令...”)

配置与运行：

1. 将脚本中的TEACH_PENDANT_IP替换为你树莓派的实际IP地址。
2. 在RoboDK中加载一个机器人模型。
3. 运行此脚本。如果连接成功，控制台会打印信息。
4. 按下手柄上的LB键（模拟使能开关），然后推动左摇杆，你应该能看到机器人末端开始移动。推动右摇杆，机器人关节会运动。

4.3 第三步：实现程序自动运行功能

“发那科机器人示教器程序自动运行”是常见需求。在RoboDK中，我们可以通过API轻松控制程序的启动、停止和选择。

扩展我们的RoboDK_Client.py脚本，添加程序控制逻辑：

# 在之前的脚本中添加以下函数和逻辑 def get_available_programs(): """获取RoboDK站中所有的程序项""" programs = [] all_items = RDK.ItemList(robolink.ITEM_TYPE_PROGRAM, False) for item in all_items: programs.append(item.Name()) return programs async def listen_to_teach_pendant(): global is_enabled, current_speed # ... (之前的连接和消息接收代码不变) ... async for message in websocket: try: data = json.loads(message) msg_type = data.get(‘type’) if msg_type == ‘control’: control_data = data.get(‘data’, {}) # ... (之前的控制逻辑) ... # 新增：处理程序运行相关命令（假设用其他按键映射） if control_data.get(‘button_y’): # 假设Y键用于选择程序 programs = get_available_programs() if programs: # 简单循环选择程序（实际可做成GUI列表） print(f”可选程序: {programs}”) # 这里可以发送程序列表回示教器显示 if control_data.get(‘button_a’): # 假设A键启动程序 selected_program = RDK.Item(‘MainProgram’, robolink.ITEM_TYPE_PROGRAM) # 指定程序名 if selected_program.Valid(): print(f”启动程序: {selected_program.Name()}”) selected_program.RunProgram() else: print(“未找到指定程序”) if control_data.get(‘button_b’): # 假设B键停止程序 print(“停止所有程序”) robot.Stop() elif msg_type == ‘command’: # 可以定义新的命令类型 cmd = data.get(‘command’) if cmd == ‘list_programs’: programs = get_available_programs() # 将程序列表发送回示教器（需要双向通信支持） await websocket.send(json.dumps({ “type”: “program_list”, “data”: programs })) elif cmd == ‘run_program’: prog_name = data.get(‘program_name’) program_item = RDK.Item(prog_name, robolink.ITEM_TYPE_PROGRAM) if program_item.Valid(): program_item.RunProgram() except Exception as e: print(f”处理消息时出错: {e}”)

4.4 第四步：为树莓派添加简易GUI界面（可选）

为了让示教器更独立，我们可以在树莓派的触摸屏上运行一个PyQt5 GUI，显示机器人状态和提供触摸按钮。

文件：~/peak_teach_pendant/software/gui/main_window.py

import sys import json from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QLabel, QPushButton, QTextEdit, QHBoxLayout) from PyQt5.QtCore import QTimer, Qt import websockets import asyncio import threading class TeachPendantGUI(QMainWindow): def __init__(self): super().__init__() self.robot_status = “Disconnected” self.current_position = “[0, 0, 0, 0, 0, 0]” self.init_ui() self.init_websocket_client() def init_ui(self): self.setWindowTitle(“Peak Virtual Teach Pendant”) self.setGeometry(100, 100, 800, 480) # 适配7寸屏 central_widget = QWidget() self.setCentralWidget(central_widget) layout = QVBoxLayout() # 状态显示区域 status_layout = QHBoxLayout() self.status_label = QLabel(“状态: ” + self.robot_status) self.status_label.setStyleSheet(“font-size: 20px; padding: 10px;”) status_layout.addWidget(self.status_label) self.pos_label = QLabel(“位置: ” + self.current_position) self.pos_label.setStyleSheet(“font-size: 16px;”) status_layout.addWidget(self.pos_label) layout.addLayout(status_layout) # 控制按钮区域 button_layout = QHBoxLayout() self.btn_enable = QPushButton(“Enable (LB)”) self.btn_enable.setCheckable(True) self.btn_enable.setStyleSheet(“”” QPushButton { font-size: 18px; padding: 15px; background-color: lightgray; } QPushButton:checked { background-color: lightgreen; } “””) button_layout.addWidget(self.btn_enable) self.btn_start_prog = QPushButton(“Start Prog (A)”) self.btn_start_prog.clicked.connect(self.on_start_program) button_layout.addWidget(self.btn_start_prog) self.btn_stop = QPushButton(“STOP (Back)”) self.btn_stop.setStyleSheet(“font-size: 18px; padding: 15px; background-color: red; color: white;”) button_layout.addWidget(self.btn_stop) layout.addLayout(button_layout) # 日志显示 self.log_text = QTextEdit() self.log_text.setReadOnly(True) layout.addWidget(self.log_text) central_widget.setLayout(layout) # 定时器更新UI self.timer = QTimer() self.timer.timeout.connect(self.update_display) self.timer.start(100) # 10Hz更新 def init_websocket_client(self): # 连接到本地服务器（树莓派上server.py提供的WebSocket） self.ws_uri = “ws://localhost:8765” threading.Thread(target=self.run_websocket_client, daemon=True).start() def run_websocket_client(self): async def listen(): try: async with websockets.connect(self.ws_uri) as websocket: async for message in websocket: data = json.loads(message) if data.get(‘type’) == ‘status’: # 假设服务器也会发状态回来 self.robot_status = data[‘data’].get(‘robot_status’, ‘Unknown’) pos = data[‘data’].get(‘current_position’, []) self.current_position = f”[{pos[0]:.1f}, {pos[1]:.1f}, {pos[2]:.1f}]” except Exception as e: self.log(f”WS Client Error: {e}”) asyncio.run(listen()) def on_start_program(self): self.log(“[GUI] Start Program button clicked.”) # 这里可以发送命令到服务器 def update_display(self): self.status_label.setText(f”状态: {self.robot_status}”) self.pos_label.setText(f”位置: {self.current_position}”) def log(self, message): self.log_text.append(message) def closeEvent(self, event): self.timer.stop() event.accept() if __name__ == ‘__main__’: app = QApplication(sys.argv) window = TeachPendantGUI() window.show() sys.exit(app.exec_())

在树莓派桌面运行此GUI程序，即可看到一个简单的示教器状态面板。

5. 常见问题与排查思路

在搭建和调试过程中，你可能会遇到以下问题：

6. 最佳实践与工程建议

将一个小Demo变成稳定可用的工具，还需要考虑以下方面：

1. 通信可靠性增强：

   • 心跳机制：在WebSocket协议中定期发送ping/pong帧，或自定义心跳包，用于检测连接是否存活，并实现断线重连。
   • 数据校验：在JSON消息中加入序列号或CRC校验，防止数据错乱。
   • 指令确认：对于重要的命令（如急停、启动程序），设计“请求-确认”机制，确保指令送达。

2. 安全性与错误处理：

   • 使能开关双重确认：真实示教器的使能开关是多位置的（轻按、深按、松开），软件中最好也模拟这种状态，避免误触发。可以设置为必须持续按住某个特定键才允许手动操纵。
   • 软急停与硬急停：除了软件急停按钮，建议在硬件上连接一个独立的急停按钮（连接树莓派GPIO），并具有最高中断优先级。
   • 运动边界限制：在RoboDK客户端中，应检查目标位置是否在机器人的工作空间和关节限位内，防止仿真碰撞。
   • 异常日志：将服务器和客户端的运行日志写入文件，便于后期排查问题。

3. 配置化与可扩展性：

   • 手柄映射配置：将手柄按键、摇杆与功能的映射关系写入YAML或JSON配置文件，方便适配不同型号的手柄，无需修改代码。
   • 机器人品牌适配层：抽象出一个机器人控制接口，针对KUKA、发那科、ABB等不同品牌，实现不同的底层驱动模块。主程序通过配置选择驱动。
   • 插件化架构：将输入设备驱动（手柄、自定义按键板）、通信协议（WebSocket, TCP）、机器人接口定义为插件，通过配置文件加载。

4. 性能优化：

   • 数据压缩：对于高频的摇杆数据，如果网络带宽紧张，可以考虑使用二进制协议（如MessagePack）代替JSON。
   • 本地预测：在GUI端，可以根据摇杆输入和上一次的机器人状态，预测并显示一个“影子机器人”的位置，提高操作跟手性，实际位置再由服务器确认更新。
   • 资源管理：树莓派资源有限，确保Python脚本不会内存泄漏。使用htop监控资源使用情况。

5. 生产环境部署：

   • 开机自启动：将服务器和GUI程序配置为树莓派的systemd服务，实现开机自动运行。
   • 只读文件系统：为防止SD卡因意外断电损坏，可以将树莓派系统配置为只读模式。
   • 版本管理：使用Git管理项目代码，便于回滚和协作。

通过以上步骤，你不仅成功复刻了一个功能可用的“Peak示教器”，更掌握了一套将通用硬件、开源软件与工业机器人仿真环境集成的完整方法论。这套方案的核心思路——“输入采集 -> 协议封装 -> 网络通信 -> 仿真软件API调用”——可以灵活应用到其他工业自动化设备的虚拟调试中。