目录
  1. 一、FR5 机器人使用方法
  2. 1.1 机器人安装与连接
  3. 1.2 示例程序
  4. 二、FR5 常用 Python 接口
  5. 2.1 机器人基础
  6. 2.2 机器人运动控制
  7. 2.3 机器人参数设置
  8. 2.4 机器人安全设置
  9. 2.5 机器人状态查询
  10. 2.6 机器人运动学
  11. 2.7 夹爪配置
  12. 三、大寰 AG95 夹爪使用
  13. 3.1 RS385 控制接口
  14. 3.2 Ubuntu 控制夹爪

Abstract FR5 是与 UR5 构型相似的 6 自由度机械臂，本文介绍其 Python SDK 的基本运动控制方法。本文内容参考自官方文档。

一、FR5 机器人使用方法

1.1 机器人安装与连接

（1）机器人安装

安装好机器人，并将夹爪安装连接在机械臂末端。

（2）网络配置

机器人默认 IP 地址为 192.168.58.2，需要修改电脑 IP 同一频段例如 192.168.58.10，然后才可连接。

配置好网络后，在浏览器输入 192.168.58.2，进入机械臂网页控制页面说明连接成功，默认用户名 admin，默认密码 123。（必须使用 Chrome 浏览器）

（3）Python 环境

该 SDK 程序基于 Python 3.10 实现，因此需要创建 3.10 的 Python 环境才能正常使用。

（4）设置工具坐标系

首先进入浏览器机器人后台，打开【初始设置-机器人设置-工具坐标】，选择坐标系名称为 toolcoord1（初始默认是 toolcoord0，尽量不修改它），此时成功设置机器人工具坐标系为 toolcoord1。

如果已知参数，例如夹爪坐标系和法兰盘坐标系，方向相同，仅 Z 轴移动了一定距离。可以直接设置为：[0, 0, 185, 0, 0, 0]

或者通过六点法标定，依次选择六个点

  • 第 1 点：在世界中指定一个点，保持工具尖端在该位置处
  • 第 2 点：保持工具尖端在该位置处（与上一点姿态差距尽量大）
  • 第 3 点：保持工具尖端在该位置处（与前两点姿态差距尽量大）
  • 第 4 点：保持工具尖端在该位置处，末端 Z 轴与工具坐标 Z 轴平行
  • 第 5 点：移动工具末端至工具 X 轴正方向上的任一点
  • 第 6 点：移动工具末端至工具 Y 轴正方向上的任一点

1.2 示例程序

（1）机器人连接与基本运动

该程序的功能为，连接机器人，移动机器人至初始位置（本文中机器人安装位置绕 Z 轴有夹角，设置初始位置为夹爪向下），激活夹爪并关闭夹爪。

import Robot
# from libfairino.utils.sdk_error import *
import numpy as np
from scipy.spatial.transform import Rotation as R
import time

###################### 机器人控制器连接测试 ######################

# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')

error = robot.SetRobotInstallAngle(0.0,-20.0) #！！！安装角度设置应与实际一致 (错误安装角度设置会导致拖动模式下机器人失控）
print("设置机器人安装角度错误码",error)

# 查询机器人的SDK版本号
ret,version  = robot.GetSDKVersion()    #查询SDK版本号
if ret ==0:
    print("SDK版本号为", version )
else:
    print("查询失败，错误码为",ret)

###################### 机器本体运动测试 ######################

# 获取机器人的关节位置
error, joint_deg = robot.GetActualJointPosDegree()
if error == 0:
    print("获取当前关节位置 (角度)", joint_deg)
else:
    print("获取当前关节位置(角度)失败，错误码为", error)
error, joint_rad = robot.GetActualJointPosRadian()
if error == 0:
    print("获取当前关节位置 (弧度)", joint_rad)
else:
    print("获取当前关节位置(弧度)失败，错误码为", error)

# # 机器人关节空间运动
# joint_pos1 = [20., -90., 90., -90., -90., 0.]
# tool = 0 #工具坐标系编号
# user = 0 #工件坐标系编号
# error = robot.MoveJ(joint_pos1, tool, user, vel=10)   #关节空间运动
# if error != 0:
#     print("关节空间运动失败，错误码为", error)

# 获取机器人的工具坐标 [-432, -265, 477, 180, 0, 110]
error, tcp_pose = robot.GetActualTCPPose()
if error == 0:
    print("获取当前工具坐标", tcp_pose)
else:
    print("获取当前工具坐标失败，错误码为", error)

# # 机器人直线运动
# pose1 = [-432, -265, 477, 180, 0, 110]
# tool = 0 #工具坐标系编号
# user = 0 #工件坐标系编号
# error = robot.MoveL(pose1, tool, user, vel=10)   #直线运动
# if error != 0:
#     print("直线运动失败，错误码为", error)

# 机器人点到点运动
pose2 = [-432, -265, 477, 180, 0, 110]
tool = 0 #工具坐标系编号
user = 0 #工件坐标系编号
error = robot.MoveCart(pose2, tool, user, vel=10)   #点到点运动
if error != 0:
    print("点到点运动失败，错误码为", error)


# 查询机器人运动状态
error, status = robot.GetRobotMotionDone()
if error == 0:
    if status == 1:
        print("机器人运动已完成")
    else:
        print("机器人正在运动")
else:
    print("查询机器人运动状态失败，错误码为", error)


###################### 机器人夹爪测试 ######################
ret = robot.SetGripperConfig(4,0)  # 配置夹爪，大寰夹爪
time.sleep(1)

error, config = robot.GetGripperConfig()     # 获取夹爪配置

error = robot.ActGripper(1,0)   # 激活夹爪（复位）
time.sleep(1)
# error = robot.ActGripper(1,1)   # 激活夹爪（激活）
# time.sleep(2)

# error = robot.MoveGripper(1,100,48,46,30000,0)  # 控制夹爪（夹爪编号，位置百分比，速度百分比，力矩百分比，最大等待时间，阻塞）
# time.sleep(3)

error = robot.MoveGripper(1,0,50,0,30000,0)     # 控制夹爪
time.sleep(3)

error, state = robot.GetGripperMotionDone() #获取夹爪运动状态

二、FR5 常用 Python 接口

2.1 机器人基础

2.1.1 实例化机器人

RPC(ip)：实例化一个机器人对象

  • 参数：
    • ip：机器人的IP地址，默认出厂IP为“192.168.58.2”
  • 返回
    • 机器人对象
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')

2.1.2 查询 SDK 版本号

GetSDKVersion()：查询 SDK 版本号

  • 参数
  • 返回
    • [SDK_version, Controller_version]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret,version  = robot.GetSDKVersion()    #查询SDK版本号
if ret ==0:
    print("SDK版本号为", version )
else:
    print("查询失败，错误码为",ret)

2.1.3 机器人手动/自动模式切换

Mode(state)：控制机器人手动/自动模式切换

  • 参数
    • state：0-自动模式，1-手动模式
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
#机器人手自动模式切换
ret = robot.Mode(0)   #机器人切入自动运行模式
print("机器人切入自动运行模式", ret)
time.sleep(1)
ret = robot.Mode(1)   #机器人切入手动模式
print("机器人切入手动模式", ret)

2.1.4 控制机器人上使能或下使能

RobotEnable(state)：控制机器人上使能或下使能

  • 参数
    • state：1-上使能，0-下使能
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
#机器人上使能或下使能
ret = robot.RobotEnable(0)   #机器人下使能
print("机器人下使能", ret)
time.sleep(3)
ret = robot.RobotEnable(1)   #机器人上使能，机器人上电后默认自动上使能
print("机器人上使能", ret)

2.2 机器人运动控制

2.2.1 机器人点动

（1）Jog 点动

StartJOG(ref,nb,dir,max_dis,vel=20.0,acc=100.0)：jog 点动

  • 参数
    • ref：0-关节点动,2-基坐标系点动,4-工具坐标系点动,8-工件坐标系点动；
    • nb：1-1关节(x 轴),2-2关节(y 轴),3-3关节(z 轴),4-4关节(rx),5-5关节(ry),6-6关节(rz);
    • dir：0-负方向，1-正方向;
    • max_dis：单次点动最大角度/距离，单位 ° 或 mm;
    • vel：速度百分比，[0~100] 默认20;
    • acc：加速度百分比，[0~100] 默认100;
  • 返回
    • 错误码

（2）Jog 点动减速停止

StopJOG(ref)：jog 点动减速停止

  • 参数
    • ref：1-关节点动停止,3-基坐标系点动停止,5-工具坐标系点动停止,9-工件坐标系点动停止
  • 返回
    • 错误码

（3）Jog 点动立即停止

ImmStopJOG()：jog 点动立即停止

  • 参数
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
# 机器人单轴点动
robot.StartJOG(0,1,0,20.0,20.0,30.0)    # 单关节运动,StartJOG为非阻塞指令，运动状态下接收其他运动指令（包含StartJOG）会被丢弃
time.sleep(1)
#机器人单轴点动减速停止
ret = robot.StopJOG(1)
print(ret)
#机器人单轴点动立即停止
robot.ImmStopJOG()
robot.StartJOG(0,2,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(0,3,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(0,4,1,20.0,vel=40)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(0,5,1,20.0,acc=50)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(0,6,1,20.0,20.0,30.0)
time.sleep(1)
robot.ImmStopJOG()
# 基坐标
robot.StartJOG(2,1,0,20.0)  #基坐标系下点动
time.sleep(1)
# #机器人单轴点动立即停止
robot.ImmStopJOG()
robot.StartJOG(2,1,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(2,2,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(2,3,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(2,4,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(2,5,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(2,6,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
# 工具坐标
robot.StartJOG(4,1,0,20.0,20.0,100.0)  #工具坐标系下点动
time.sleep(1)
# #机器人单轴点动立即停止
robot.ImmStopJOG()
robot.StartJOG(4,1,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(4,2,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(4,3,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(4,4,1,20.0,20.0,100.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(4,5,1,20.0,vel=10.0,acc=20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(4,6,1,20.0,acc=40.0)
time.sleep(1)
robot.ImmStopJOG()
# 工件坐标
robot.StartJOG(8,1,0,20.0,20.0,100.0)  #工件坐标系下点动
time.sleep(1)
# #机器人单轴点动立即停止
robot.ImmStopJOG()
robot.StartJOG(8,1,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(8,2,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(8,3,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(8,4,1,20.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(8,5,1,20.0,vel=30.0)
time.sleep(1)
robot.ImmStopJOG()
robot.StartJOG(8,6,1,20.0,20.0,acc=90.0)
time.sleep(1)
robot.ImmStopJOG()

2.2.2 关节空间运动

MoveJ(joint_pos, tool, user, desc_pos = [0.0,0.0,0.0,0.0,0.0,0.0], vel = 20.0, acc = 0.0, ovl = 100.0, exaxis_pos = [0.0,0.0,0.0,0.0], blendT = -1.0, offset_flag = 0, offset_pos = [0.0,0.0,0.0,0.0,0.0,0.0])：关节空间运动

  • 参数
    • joint_pos:目标关节位置，单位[°]；
    • tool:工具号，[0~14]；
    • user:工件号，[0~14]；
    • desc_pos:目标笛卡尔位姿，单位 [mm][°] 默认初值为[0.0,0.0,0.0,0.0,0.0,0.0]，默认值调用正运动学求解返回值;
    • vel:速度百分比，[0~100] 默认20.0;
    • acc:加速度百分比，[0~100]，暂不开放；
    • ovl:速度缩放因子，[0~100] 默认100.0;
    • exaxis_pos:外部轴 1 位置 ~ 外部轴 4 位置 默认[0.0,0.0,0.0,0.0];
    • blendT:[-1.0]-运动到位 (阻塞)，[0~500.0]-平滑时间 (非阻塞)，单位 [ms] 默认-1.0;
    • offset_flag:[0]-不偏移，[1]-工件/基坐标系下偏移，[2]-工具坐标系下偏移 默认 0;
    • offset_pos:位姿偏移量，单位 [mm][°] 默认[0.0,0.0,0.0,0.0,0.0,0.0];
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
joint_pos4 = [-83.24, -96.476, 93.688, -114.079, -62, -100]
joint_pos5 = [-43.24, -70.476, 93.688, -114.079, -62, -80]
joint_pos6 = [-83.24, -96.416, 43.188, -74.079, -80, -10]
tool = 0 #工具坐标系编号
user = 0 #工件坐标系编号
ret = robot.MoveJ(joint_pos4, tool, user, vel=30)   #关节空间运动
print("关节空间运动点4:错误码", ret)
ret = robot.MoveJ(joint_pos5, tool, user)
print("关节空间运动点5:错误码", ret)
robot.MoveJ(joint_pos6, tool, user, offset_flag=1, offset_pos=[10,10,10,0,0,0])
print("关节空间运动点6:错误码", ret)

2.2.3 笛卡尔空间直线运动

MoveL(desc_pos, tool, user, joint_pos = [0.0,0.0,0.0,0.0,0.0,0.0], vel = 20.0, acc = 0.0 , ovl = 100.0, blendR = -1.0, exaxis_pos = [0.0,0.0,0.0,0.0], search = 0, offset_flag = 0, offset_pos = [0.0,0.0,0.0,0.0,0.0,0.0] )：笛卡尔空间直线运动

  • 参数
    • desc_pos:目标笛卡尔位姿，单位[mm][°]；
    • tool:工具号，[0~14]；
    • user:工件号，[0~14]；
    • joint_pos:目标关节位置，单位 [°] 默认初值为[0.0,0.0,0.0,0.0,0.0,0.0]，默认值调用逆运动学求解返回值;
    • vel:速度百分比，[0~100] 默认20.0；
    • acc:加速度百分比，[0~100]，暂不开放 默认0.0；
    • ovl:速度缩放因子，[0~100] 默认100.0；
    • blendR:blendR:[-1.0]-运动到位 (阻塞)，[0~1000]-平滑半径 (非阻塞)，单位 [mm] 默认-1.0;
    • exaxis_pos:外部轴 1 位置 ~ 外部轴 4 位置 默认[0.0,0.0,0.0,0.0];
    • search:[0]-不焊丝寻位，[1]-焊丝寻位；
    • offset_flag:offset_flag:[0]-不偏移，[1]-工件/基坐标系下偏移，[2]-工具坐标系下偏移 默认 0;
    • offset_pos:位姿偏移量，单位 [mm][°] 默认[0.0,0.0,0.0,0.0,0.0,0.0]
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
desc_pos1 = [36.794,-475.119, 65.379, -176.938, 2.535, -179.829]
desc_pos2 = [136.794,-475.119, 65.379, -176.938, 2.535, -179.829]
desc_pos3 = [236.794,-475.119, 65.379, -176.938, 2.535, -179.829]
tool = 0 #工具坐标系编号
user = 0 #工件坐标系编号
ret = robot.MoveL(desc_pos1, tool, user)   #笛卡尔空间直线运动
print("笛卡尔空间直线运动点1:错误码", ret)
robot.MoveL(desc_pos2, tool, user, vel=20, acc=100)
print("笛卡尔空间直线运动点2:错误码", ret)
robot.MoveL(desc_pos3, tool, user, offset_flag=1, offset_pos=[10,10,10,0,0,0])
print("笛卡尔空间直线运动点3:错误码", ret)

2.2.4 笛卡尔空间点到点运动

MoveCart(desc_pos, tool, user, vel = 20.0, acc = 0.0, ovl = 100.0, blendT = -1.0, config = -1)：笛卡尔空间点到点运动

  • 参数
    • desc_pos:目标笛卡尔位置；
    • tool:工具号，[0~14]；
    • user:工件号，[0~14]；
    • vel:速度，范围 [0~100]，默认为 20.0;
    • acc:加速度，范围 [0~100]，暂不开放,默认为 0.0;
    • ovl:速度缩放因子，[0~100]，默认为 100.0;
    • blendT:[-1.0]-运动到位 (阻塞)，[0~500]-平滑时间 (非阻塞)，单位 [ms] 默认为 -1.0;
    • config:关节配置，[-1]-参考当前关节位置求解，[0~7]-依据关节配置求解 默认为 -1
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
desc_pos7 = [236.794,-475.119, 65.379, -176.938, 2.535, -179.829]
desc_pos8 = [236.794,-575.119, 165.379, -176.938, 2.535, -179.829]
desc_pos9 = [236.794,-475.119, 265.379, -176.938, 2.535, -179.829]
tool = 0 #工具坐标系编号
user = 0 #工件坐标系编号
robot.MoveCart(desc_pos7, tool, user)
print("笛卡尔空间点到点运动点7:错误码", ret)
robot.MoveCart(desc_pos8, tool, user, vel=30)
print("笛卡尔空间点到点运动点8:错误码", ret)
robot.MoveCart(desc_pos9, tool, user,)
print("笛卡尔空间点到点运动点9:错误码", ret)

2.2.5 伺服运动

（1）伺服运动开始

ServoMoveStart()：伺服运动开始，配合 ServoJ、ServoCart 指令使用

  • 参数
  • 返回
    • 错误码

（2）伺服运动结束

ServoMoveEnd()：伺服运动开始，配合 ServoJ、ServoCart 指令使用

  • 参数
  • 返回
    • 错误码

（3）关节空间伺服模式运动

ServoJ(joint_pos, acc = 0.0, vel = 0.0, cmdT = 0.008, filterT = 0.0, gain = 0.0)：关节空间伺服模式运动

  • 参数
    • joint_pos:目标关节位置，单位[°]；
    • acc:加速度，范围 [0~100]，暂不开放，默认为 0.0;
    • vel:速度，范围 [0~100]，暂不开放，默认为 0.0;
    • cmdT:指令下发周期，单位s，建议范围[0.001~0.0016], 默认为0.008;
    • filterT:滤波时间，单位 [s]，暂不开放， 默认为0.0;
    • gain:目标位置的比例放大器，暂不开放， 默认为0.0;
  • 返回
    • 错误码

（4）笛卡尔空间伺服模式运动

ServoCart(mode, desc_pos, pos_gain = [1.0, 1.0, 1.0, 1.0, 1.0, 1.0] , acc = 0.0, vel = 0.0, cmdT = 0.008, filterT = 0.0, gain = 0.0)：笛卡尔空间伺服模式运动

  • 参数
    • mode:[0]-绝对运动(基坐标系)，[1]-增量运动(基坐标系)，[2]-增量运动(工具坐标系)；
    • desc_pos:目标笛卡尔位置/目标笛卡尔位置增量；
    • pos_gain:位姿增量比例系数，仅在增量运动下生效，范围 [0~1], 默认为 [1.0, 1.0, 1.0, 1.0, 1.0, 1.0];
    • acc:加速度，范围 [0~100]，暂不开放，默认为 0.0;
    • vel:速度，范围 [0~100]，暂不开放，默认为 0.0;
    • cmdT:指令下发周期，单位s，建议范围[0.001~0.0016], 默认为0.008;
    • filterT:滤波时间，单位 [s]，暂不开放， 默认为0.0;
    • gain:目标位置的比例放大器，暂不开放， 默认为0.0;
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
error,joint_pos = robot.GetActualJointPosDegree()
print("机器人当前关节位置",joint_pos)
joint_pos = [joint_pos[0],joint_pos[1],joint_pos[2],joint_pos[3],joint_pos[4],joint_pos[5]]
error_joint = 0
count =100
error = robot.ServoMoveStart()  #伺服运动开始
print("伺服运动开始错误码",error)
while(count):
    error = robot.ServoJ(joint_pos)   #关节空间伺服模式运动
    if error!=0:
        error_joint =error
    joint_pos[0] = joint_pos[0] + 0.1  #每次1轴运动0.1度，运动100次
    count = count - 1
    time.sleep(0.008)
print("关节空间伺服模式运动错误码",error_joint)
error = robot.ServoMoveEnd()  #伺服运动结束
print("伺服运动结束错误码",error)
mode = 2  #[0]-绝对运动(基坐标系)，[1]-增量运动(基坐标系)，[2]-增量运动(工具坐标系)
n_pos = [0.0,0.0,0.5,0.0,0.0,0.0]   #笛卡尔空间位姿增量
error,desc_pos = robot.GetActualTCPPose()
print("机器人当前笛卡尔位置",desc_pos)
count = 100
error_cart =0
error = robot.ServoMoveStart()  #伺服运动开始
print("伺服运动开始错误码",error)
while(count):
    error = robot.ServoCart(mode, n_pos, vel=40)   #笛卡尔空间伺服模式运动
    if error!=0:
        error_cart =error
    count = count - 1
    time.sleep(0.008)
print("笛卡尔空间伺服模式运动错误码", error_cart)
error = robot.ServoMoveEnd()  #伺服运动开始
print("伺服运动结束错误码",error)

2.3 机器人参数设置

2.3.1 设置全局速度

SetSpeed(vel)：设置全局速度

  • 参数
    • vel:速度百分比，范围[0~100]
  • 返回
    • 错误码
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
error = robot.SetSpeed(20)
print("设置全局速度错误码:",error)

2.3.2 设置系统变量值

SetSysVarValue(id,value)：设置系统变量

  • 参数
    • id：变量编号，范围[1~20];
    • value：变量值
  • 返回
    • 错误码
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
for i in range(1,21):
    error = robot.SetSysVarValue(i,10)
robot.WaitMs(1000)
for i in range(1,21):
    sys_var = robot.GetSysVarValue(i)
    print("系统变量编号:",i,"值",sys_var)

2.3.3 设置工具坐标系

（1）计算工具坐标系 - 六点法

SetToolPoint(point_num)：设置工具参考点-六点法

  • 参数
    • point_num：点编号,范围[1~6]
  • 返回错误码

ComputeTool()：计算工具坐标系-六点法（设置完六个工具参考点后再进行计算）

  • 参数
  • 返回
    • 错误码
    • tcp_pose [x,y,z,rx,ry,rz]：工具坐标系
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
t_coord = [1.0,2.0,3.0,4.0,5.0,6.0]
for i in range(1,7):
    robot.DragTeachSwitch(1)#切入拖动示教模式
    time.sleep(5)
    error = robot.SetToolPoint(i) #实际应当控制机器人按照要求移动到合适位置后再发送指令
    print("六点法设置工具坐标系，记录点",i,"错误码",error)
    robot.DragTeachSwitch(0)
    time.sleep(1)
error = robot.ComputeTool()
print("六点法设置工具坐标系错误码",error)

（2）计算工具坐标系 - 四点法

SetTcp4RefPoint(point_num)：设置工具参考点-四点法

  • 参数
    • point_num：点编号,范围[1~4]
  • 返回值
    • 错误码

ComputeTcp4()：计算工具坐标系-四点法（设置完四个工具参考点后再进行计算）

  • 参数
  • 返回
    • 错误码
    • tcp_pose [x,y,z,rx,ry,rz]：工具坐标系
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
t_coord = [1.0,2.0,3.0,4.0,5.0,6.0]
for i in range(1,5):
    robot.DragTeachSwitch(1)#切入拖动示教模式
    time.sleep(5)
    error = robot.SetTcp4RefPoint(i) #应当控制机器人按照要求移动到合适位置后再发送指令
    print("四点法设置工具坐标系，记录点",i,"错误码",error)
    robot.DragTeachSwitch(0)
    time.sleep(1)
error,t_coord= robot.ComputeTcp4()
print("四点法设置工具坐标系错误码",error,"工具TCP",t_coord)

（3）设置工具坐标系

SetToolCoord(id,t_coord,type,install)：设置工具坐标系

  • 参数
    • id:坐标系编号，范围[0~14]；
    • t_coord:[x,y,z,rx,ry,rz] 工具中心点相对末端法兰中心位姿，单位[mm][°]；
    • type:0-工具坐标系，1-传感器坐标系；
    • install:安装位置，0-机器人末端，1-机器人外部
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
t_coord = [1.0,2.0,3.0,4.0,5.0,6.0]
error = robot.SetToolCoord(10,t_coord,0,0)
print("设置工具坐标系错误码",error)

2.3.4 设置外部工具坐标系

（1）设置外部工具参考点

SetExTCPPoint(point_num)：设置外部工具参考点-三点法

  • 参数
    • point_num：点编号,范围[1~3]
  • 返回
    • 错误码

（2）计算外部工具坐标系

ComputeExTCF(point_num)：计算外部工具坐标系-三点法（设置完三个参考点后再进行计算）

  • 参数
    • point_num：点编号,范围[1~3]
  • 返回
    • 错误码
    • etcp [x,y,z,rx,ry,rz]：外部工具坐标系

（3）设置外部工具坐标系

SetExToolCoord(id,etcp ,etool)：设置外部工具坐标系

  • 参数
    • id:坐标系编号，范围[0~14]；
    • etcp:外部工具坐标系，单位[mm][°]；
    • etool:末端工具坐标系，单位[mm][°]；
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
etcp = [1.0,2.0,3.0,4.0,5.0,6.0]
etool = [21.0,22.0,23.0,24.0,25.0,26.0]
for i in range(1,4):
    error = robot.SetExTCPPoint(i) #应当控制机器人按照要求移动到合适位置后再发送指令
    print("三点法设置外部工具坐标系，记录点",i,"错误码",error)
    time.sleep(1)
error,etcp = robot.ComputeExTCF()
print("三点法设置外部工具坐标系错误码",error,"外部工具TCP",etcp)
error = robot.SetExToolCoord(10,etcp,etool)
print("设置外部工具坐标系错误码",error)
error = robot.SetExToolList(10,etcp,etool)
print("设置外部工具坐标系列表错误码",error)

2.3.5 设置工件坐标系

（1）设置工件参考点

SetWObjCoordPoint(point_num)：设置工件参考点-三点法

  • 参数
    • point_num:点编号,范围[1~3]
  • 返回
    • 错误码

（2）计算工件坐标系

ComputeWObjCoord()：计算工件坐标系-三点法（三个参考点设置完后再进行计算;

  • 参数
    • method：计算方式：0（原点-x轴-z轴），1（原点-x轴-xy平面）
  • 返回
    • 错误码
    • wobj_pose [x,y,z,rx,ry,rz]：工件坐标系

（3）设置工件坐标系

SetWObjCoord(id,w_coord)：设置工件坐标系

  • 参数
    • id:坐标系编号，范围[0~14]；
    • w_coord:坐标系相对位姿，单位[mm][°]；
  • 返回
    • 错误码
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
w_coord = [11.0,12.0,13.0,14.0,15.0,16.0]
robot.SetToolList(0,[0,0,0,0,0,0],0,0)#设置参考点前应当将工具和工件号坐标系切换至0
robot.SetWObjList(0,[0,0,0,0,0,0])
for i in range(1,4):
    error = robot.SetWObjCoordPoint(i) #实际应当控制机器人按照要求移动到合适位置后再发送指令
    print("三点法设置工件坐标系，记录点",i,"错误码",error)
    time.sleep(1)
error, w_coord = robot.ComputeWObjCoord(0)
print("三点法计算工件坐标系错误码",error,"工件坐标系", w_coord)

2.4 机器人安全设置

2.4.1 碰撞设置

（1）设置碰撞等级

SetAnticollision (mode,level,config)：设置碰撞等级

  • 参数
    • mode:0-等级，1-百分比；
    • level=[j1,j2,j3,j4,j5,j6]:碰撞阈值；
    • config:0-不更新配置文件，1-更新配置文件
  • 返回
    • 错误码

（2）设置碰撞后策略

SetCollisionStrategy (strategy)：设置碰撞后策略

  • 参数
    • strategy：0-报错暂停，1-继续运行
  • 返回
    • 错误码
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
level = [1.0,2.0,3.0,4.0,5.0,6.0]
error = robot.SetAnticollision(0,level,1)
print("设置碰撞等级错误码:",error)
level = [50.0,20.0,30.0,40.0,50.0,60.0]
error = robot.SetAnticollision(1,level,1)
print("设置碰撞等级错误码:",error)
error = robot.SetCollisionStrategy(1)
print("设置碰撞后策略错误码:",error)

2.4.2 设置关节限位

（1）正限位

SetLimitPositive(p_limit)：设置正限位

  • 参数
    • p_limit=[j1,j2,j3,j4,j5,j6]：六个关节位置
  • 返回
    • 错误码

（2）负限位

SetLimitNegative(p_limit)：设置负限位

  • 参数
    • n_limit=[j1,j2,j3,j4,j5,j6]：六个关节位置
  • 返回
    • 错误码
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
p_limit = [170.0,80.0,150.0,80.0,170.0,160.0]
error = robot.SetLimitPositive(p_limit)
print("设置正限位错误码:",error)
n_limit = [-170.0,-260.0,-150.0,-260.0,-170.0,-160.0]
5error = robot.SetLimitNegative(n_limit)
6print("设置负限位错误码:",error)

2.4.3 错误状态清除

ResetAllError()：错误状态清除，只能清除可复位的错误

  • 参数
  • 返回
    • 错误码
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
error = robot.ResetAllError()
print("错误状态清除错误码:",error)

2.5 机器人状态查询

2.5.1 获取关节位置

（1）获取当前关节位置(角度)

GetActualJointPosDegree(flag = 1)：获取关节当前位置(角度)

  • 参数
    • flag：0-阻塞，1-非阻塞
  • 返回
    • 错误码
    • joint_pos=[j1,j2,j3,j4,j5,j6]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
error, joint_deg = robot.GetActualJointPosDegree()
print("获取当前关节位置 (角度)", joint_deg)

（2）获取当前关节位置(弧度)

GetActualJointPosRadian(flag = 1)：获取关节当前位置(弧度)

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • joint_pos =[j1,j2,j3,j4,j5,j6]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
error, joint_rad = robot.GetActualJointPosRadian()
print("获取当前关节位置 (角度)", joint_rad)

2.5.2 获取关节反馈速度

GetActualJointSpeedsDegree(flag = 1 )：获取关节反馈速度（deg/s）（实际速度）

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • speed=[j1,j2,j3,j4,j5,j6]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetActualJointSpeedsDegree()
print("获取关节反馈速度-deg/s", ret)

2.5.3 获取工具坐标系速度

（1）TCP 指令合速度

GetTargetTCPCompositeSpeed(flag = 1)：获取 TCP 指令合速度（期望速度）

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • [tcp_speed,ori_speed]：tcp_speed 线性合速度，ori_speed 姿态合速度
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetTargetTCPCompositeSpeed()
print("获取TCP指令合速度", ret)

（2）TCP 反馈合速度

GetActualTCPCompositeSpeed(flag = 1)：获取TCP反馈合速度（实际速度）

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • [tcp_speed,ori_speed]：tcp_speed 线性合速度，ori_speed 姿态合速度
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetActualTCPCompositeSpeed()
print("获取TCP反馈合速度", ret)

（3）TCP 指令速度

GetTargetTCPSpeed(flag = 1)：获取 TCP 指令速度（期望速度）

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • speed：[x,y,z,rx,ry,rz]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetTargetTCPSpeed()
print("获取TCP指令速度", ret)

（4）TCP 反馈速度

GetActualTCPSpeed(flag = 1)：获取 TCP 反馈速度

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • speed：[x,y,z,rx,ry,rz]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetActualTCPSpeed()
print("获取TCP反馈速度", ret)

2.5.4 获取工具位姿

GetActualTCPPose(flag = 1)：获取当前工具位姿

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • tcp_pose=[x,y,z,rx,ry,rz]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetActualTCPPose()
print("获取当前工具位姿", ret)

2.5.5 获取末端法兰位姿

GetActualToolFlangePose(flag = 1)：获取当前末端法兰位姿

  • 参数
    • flag：0-阻塞，1-非阻塞 默认1
  • 返回
    • 错误码
    • flange_pose=[x,y,z,rx,ry,rz]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetActualToolFlangePose()
print("获取当前末端法兰位姿", ret)

2.5.6 获取关节转矩

GetJointTorques(flag = 1)：获取当前关节转矩

  • 参数
    • flag：0-阻塞，1-非阻塞 默认 1
  • 返回
    • 错误码
    • torques=[j1,j2,j3,j4,j5,j6]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetJointTorques()
print("获取当前关节转矩", ret)

2.5.7 获取关节软限位

GetJointSoftLimitDeg(flag = 1)：获取关节软限位角度

  • 参数
    • flag：0-阻塞，1-非阻塞 默认 1
  • 返回
    • 错误码
    • [j1min,j1max,j2min,j2max,j3min,j3max, j4min,j4max,j5min, j5max, j6min,j6max]: 轴 1~ 轴 6 关节负限位与正限位，单位 [mm]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetJointSoftLimitDeg()
print("获取关节软限位角度", ret)

2.5.8 查询机器人运动是否完成

GetRobotMotionDone()：查询机器人运动是否完成

  • 参数
  • 返回
    • 错误码
    • state：0-未完成，1-完成
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetRobotMotionDone()
print("查询机器人运动是否完成", ret)

2.5.9 获取 DH 参数

GetDHCompensation()：获取 DH 补偿参数

  • 参数
  • 返回
    • 错误码
    • [cmpstD1,cmpstA2,cmpstA3,cmpstD4,cmpstD5,cmpstD6]：dhCompensation 机器人 DH 参数补偿值(mm)
import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
error = robot.GetDHCompensation()
print(error)

2.6 机器人运动学

2.6.1 正运动学求解

GetForwardKin(joint_pos)：正运动学，关节位置求解工具位姿

  • 参数
    • joint_pos:[j1,j2,j3,j4,j5,j6]:关节位置，单位[°]
  • 返回
    • 错误码
    • desc_pos=[x,y,z,rx,ry,rz]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
J1=[95.442,-101.149,-98.699,-68.347,90.580,-47.174]
ret = robot.GetForwardKin(J1)
print("正运动学，关节位置求解工具位姿", ret)

2.6.2 逆运动学

（1）逆运动学求解

GetInverseKin(type,desc_pos,config)：逆运动学，笛卡尔位姿求解关节位置

  • 参数
    • type:0-绝对位姿(基坐标系)，1-相对位姿（基坐标系），2-相对位姿（工具坐标系）
    • desc_pose:[x,y,z,rx,ry,rz],工具位姿，单位[mm][°]
  • 返回
    • 错误码
    • joint_pos=[j1,j2,j3,j4,j5,j6]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
J1=[95.442,-101.149,-98.699,-68.347,90.580,-47.174]
P1=[75.414,568.526,338.135,-178.348,-0.930,52.611]
ret = robot.GetInverseKin(0,P1,config=-1)
print("逆运动学，笛卡尔位姿求解关节位置", ret)

（2）逆运动学求解（指定参考位置）

GetInverseKinRef(type,desc_pos,joint_pos_ref)：逆运动学，工具位姿求解关节位置，参考指定关节位置求解

  • 参数
    • type:0-绝对位姿(基坐标系)，1-相对位姿（基坐标系），2-相对位姿（工具坐标系）
    • desc_pos：[x,y,z,rx,ry,rz]工具位姿，单位[mm][°]
    • joint_pos_ref：[j1,j2,j3,j4,j5,j6]，关节参考位置，单位[°]
  • 返回
    • 错误码
    • joint_pos =[j1,j2,j3,j4,j5,j6]
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
J1=[95.442,-101.149,-98.699,-68.347,90.580,-47.174]
P1=[75.414,568.526,338.135,-178.348,-0.930,52.611]
ret = robot.GetInverseKinRef(0,P1,J1)
print("逆运动学，工具位姿求解关节位置，参考指定关节位置求解", ret)

（3）逆运动学求解（判断是否有解）

GetInverseKinHasSolution(type,desc_pos,joint_pos_ref)：逆运动学，工具位姿求解关节位置 是否有解

  • 参数
    • type:0-绝对位姿(基坐标系)，1-相对位姿（基坐标系），2-相对位姿（工具坐标系）
    • desc_pos：[x,y,z,rx,ry,rz]工具位姿，单位[mm][°]
    • joint_pos_ref：[j1,j2,j3,j4,j5,j6]，关节参考位置，单位[°]
  • 返回
    • 错误码
    • result：“True”-有解，“False”-无解
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
J1=[95.442,-101.149,-98.699,-68.347,90.580,-47.174]
P1=[75.414,568.526,338.135,-178.348,-0.930,52.611]
ret = robot.GetInverseKinHasSolution(0,P1,J1)
print("逆运动学，工具位姿求解关节位置是否有解", ret)

2.7 夹爪配置

2.7.1 夹爪配置

（1）获取夹爪配置

GetGripperConfig()：获取夹爪配置

  • 参数
  • 返回
    • 错误码
    • [number,company,device,softversion]：number（夹爪编号，范围[1]）；company（夹爪厂商，1-Robotiq，2-慧灵，3-天机，4-大寰，5-知行）；device（设备号，Robotiq(0-2F-85系列)，慧灵(0-NK系列,1-Z-EFG-100)， 天机(0-TEG-110)，大寰(0-PGI-140)，知行(0-CTPM2F20)）; softvesion（软件版本号，暂不使用，默认为0）;

（2）配置夹爪

SetGripperConfig(company,device,softversion,bus)：配置夹爪

  • 参数
    • company：夹爪厂商，1-Robotiq，2-慧灵，3-天机，4-大寰，5-知行；
    • device：设备号，Robotiq(0-2F-85系列)，慧灵(0-NK系列,1-Z-EFG-100)，天机(0-TEG-110)，大寰(0-PGI-140)，知行(0-CTPM2F20)
    • softversion：软件版本号，暂不使用，默认为0；
    • bus：设备挂载末端总线位置，暂不使用，默认为0；
  • 返回
    • 错误码

2.7.2 夹爪控制

测试发现若夹爪连接在机械臂上，控制盒集成的夹爪控制与机械臂本体伺服控制会存在程序阻塞，无法同时使用 考虑夹爪直接连接电脑，通过 RS485 控制机械臂。

（1）激活夹爪

ActGripper(index,action)：激活夹爪

  • 参数
    • index:夹爪编号；
    • action:0-复位，1-激活
  • 返回
    • 错误码

（2）控制夹爪

MoveGripper(index,pos,speed,force,maxtime,block)：控制夹爪

  • 参数
    • index:夹爪编号；
    • pos:位置百分比，范围[0~100]；
    • speed:速度百分比，范围[0~100];
    • force:力矩百分比，范围[0~100]；
    • maxtime:最大等待时间，范围[0~30000]，单位[ms]；
    • block:0-阻塞，1-非阻塞。
  • 返回
    • 错误码

（3）获取夹爪运动状态

GetGripperMotionDone()：获取夹爪运动状态

  • 参数
  • 返回
    • 错误码
    • [fault,status]：fault（0-无错误，1-有错误），status（0-运动未完成，1-运动完成）
from fairino import Robot
import time
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
desc_pos1=[-333.683,-228.968,404.329,-179.138,-0.781,91.261]
desc_pos2=[-333.683,-100.8,404.329,-179.138,-0.781,91.261]
zlength1 =10
zlength2 =15
zangle1 =10
zangle2 =15
#测试外设指令
ret = robot.SetGripperConfig(4,0)  #配置夹爪
print("配置夹爪错误码", ret)
time.sleep(1)
config = robot.GetGripperConfig()     #获取夹爪配置
print("获取夹爪配置",config)
error = robot.ActGripper(1,0)  #激活夹爪
print("激活夹爪错误码",error)
time.sleep(1)
error = robot.ActGripper(1,1)#激活夹爪
print("激活夹爪错误码",error)
time.sleep(2)
error = robot.MoveGripper(1,100,48,46,30000,0) #控制夹爪
print("控制夹爪错误码",error)
time.sleep(3)
error = robot.MoveGripper(1,0,50,0,30000,0) #控制夹爪
print("控制夹爪错误码",error)
error = robot.GetGripperMotionDone() #获取夹爪运动状态
print("获取夹爪运动状态错误码",error)

三、大寰 AG95 夹爪使用

3.1 RS385 控制接口

3.1.1 RS485 默认配置

参数默认
夹爪ID1
波特率115200
数据位8
停止位1
校验位无

3.1.2 命令格式

以初始化指令 01 06 01 00 00 01 49 F6 为例：

地址码功能码寄存器地址寄存器数据CRC 校验码
010601 0000 0149 F6
  • 地址码：表示夹爪的ID 号，默认是 1；
  • 功能码：描述读写操作，03（读取寄存器），06（写入寄存器）；
  • 寄存器地址：夹爪功能对应地址；
  • 寄存器数据：写入数据到具体的寄存器地址；
  • CRC 校验码：根据前面的数据进行转换，参考 http://www.ip33.com/crc.html

3.1.3 初始化夹爪

初始化：

01 06 01 00 00 01 49 F6：回零位（运行到张开极限位置） 01 06 01 00 00 A5 48 4D：重新标定+回零点（先关闭夹爪，再打开夹爪，记录总行程标定）

含义：

  • 01：夹爪编号
  • 06：写入寄存器
  • 01 00：夹爪初始化寄存器
  • 00 01 / 00 A5：初始化指令
  • 49 F6 / 48 4D：校验码

初始化状态反馈：获取是否进行了初始化

发送：01 03 02 00 00 01 85 B2

  • 01：夹爪编号
  • 03：读取寄存器
  • 02 00：初始化状态反馈寄存器
  • 00 01：初始化状态反馈指令
  • 85 B2：校验码

返回：01 03 02 00 00 B8 44

  • 00 00：未初始化，如果是 1 则初始化成功，如果是 2 则初始化中。

3.1.3 夹爪位置控制

设置位置：设置夹爪位置，可以写入 0-1000，代表开合程度百分比，对应 16 进制为 00 00 - 03 E8

01 06 01 03 01 F4 78 21：设置夹爪位置 500。

  • 01：夹爪编号
  • 06：写入寄存器
  • 01 03：夹爪位置寄存器
  • 01 F4：设置夹爪位置为 500
  • 78 21：校验码

读取设定位置：读取设置的位置

发送：01 03 01 03 00 01 75 F6

  • 01：夹爪编号
  • 03：读取寄存器
  • 01 03：夹爪位置寄存器
  • 00 01：读取设定位置指令
  • 75 F6：校验码

返回：01 03 02 xx xx crc1 crc2

  • xx xx：16 进制夹爪位置，对应 0-1000 夹爪开合程度百分比

读取实时位置：读取夹爪实时位置

发送：01 03 02 02 00 01 24 72

  • 01：夹爪编号
  • 03：读取寄存器
  • 02 02：夹爪实时位置寄存器
  • 00 01：读取实时位置指令
  • 24 72：校验码

返回：01 03 02 xx xx crc1 crc2

  • xx xx：16 进制夹爪位置，对应 0-1000 夹爪开合程度百分比

3.1.4 夹爪状态反馈

获取夹爪运动状态：读取目前夹爪的状态

发送：01 03 02 01 00 01 D4 72

  • 01：夹爪编号
  • 03：读取寄存器
  • 02 01：夹爪状态寄存器
  • 00 01：读取夹爪状态指令
  • 24 72：校验码

返回：01 03 02 00 02 39 85

  • 00 02：代表夹住物体

00：夹爪处于正在运动状态。 01：夹爪停止运动，且夹爪未检测到夹到物体。 02：夹爪停止运动，且夹爪检测到夹到物体。 03：夹爪检测到夹住物体后，发现物体掉落。

3.2 Ubuntu 控制夹爪

3.2.1 连接夹爪

（1）查看夹爪串口

命令行输入 ls -l /dev/ttyUSB*，此时如果没有插入其它 usb 设备，则看不到输出

将 RS485 转 USB 连接至电脑，重新执行 ls -l /dev/ttyUSB* 命令，可以看到多出了一个 /dev/ttyUSB0，该设备即为夹爪的串口。

（2）固定 ttyUSB 编号

首先命令行输入 lsusb 查看设备 ID，可以拔插一次观察多出来的那一行就是夹爪设备，例如我的设备 ID 是 0403:6001，分别代表 idVendor:idProduct

Bus 001 Device 005: ID 0403:6001 Future Technology Devices International, Ltd FT232 Serial (UART) IC

然后创建并编辑配置文件：sudo vim /etc/udev/rules.d/usb.rules，输入以下内容：

KERNEL=="ttyUSB*", ATTRS{idVendor}=="0403", ATTRS{idProduct}=="6001", MODE:="0777", SYMLINK+="dh_gripper"

其中

  • KERNEL：不修改
  • ATTRS{idVendor}：填写 ID 冒号前的部分
  • ATTRS{idProduct}：填写 ID 冒号后的部分
  • MODE：默认设置为 0777 即可，可读可写可执行
  • SYMLINK：自定义，也就是想要将 ttyUSB0 改成什么一个固定的名字

重启 udev：

service udev reload
service udev restart

重新插拔设备，然后 ls /dev/，就可以看到自己设置的端口名出现。

3.2.2 Python 串口控制

（1）安装依赖

pip install pyserial