[!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 轴有夹角，设置初始位置为夹爪向下），激活夹爪并关闭夹爪。

fold
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
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”
  • 返回
    • 机器人对象
1
2
3
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')

2.1.2 查询 SDK 版本号

GetSDKVersion()：查询 SDK 版本号

  • 参数
  • 返回
    • [SDK_version, Controller_version]
1
2
3
4
5
6
7
8
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-手动模式
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
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-下使能
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
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 点动立即停止

  • 参数
  • 返回
    • 错误码
fold
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
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];
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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]
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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;
  • 返回
    • 错误码
fold
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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]
  • 返回
    • 错误码
1
2
3
4
5
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：变量值
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
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]：工具坐标系
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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]：工具坐标系
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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-机器人外部
  • 返回
    • 错误码
1
2
3
4
5
6
7
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][°]；
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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][°]；
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
11
12
13
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-继续运行
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
10
11
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]：六个关节位置
  • 返回
    • 错误码
1
2
3
4
5
6
7
8
9
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()：错误状态清除，只能清除可复位的错误

  • 参数
  • 返回
    • 错误码
1
2
3
4
5
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]
1
2
3
4
5
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]
1
2
3
4
5
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]
1
2
3
4
5
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 姿态合速度
1
2
3
4
5
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 姿态合速度
1
2
3
4
5
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]
1
2
3
4
5
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]
1
2
3
4
5
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]
1
2
3
4
5
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]
1
2
3
4
5
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]
1
2
3
4
5
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]
1
2
3
4
5
from fairino import Robot
# 与机器人控制器建立连接，连接成功返回一个机器人对象
robot = Robot.RPC('192.168.58.2')
ret = robot.GetJointSoftLimitDeg()
print("获取关节软限位角度", ret)

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

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

  • 参数
  • 返回
    • 错误码
    • state：0-未完成，1-完成
1
2
3
4
5
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)
1
2
3
4
5
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]
1
2
3
4
5
6
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]
1
2
3
4
5
6
7
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]
1
2
3
4
5
6
7
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”-无解
1
2
3
4
5
6
7
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-运动完成）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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 默认配置

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

3.1.2 命令格式

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

地址码 功能码 寄存器地址 寄存器数据 CRC 校验码
01 06 01 00 00 01 49 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

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

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

1
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：

1
2
service udev reload
service udev restart

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

3.2.2 Python 串口控制

（1）安装依赖

1
pip install pyserial