Python语言

JAKA大约 81 分钟

Python语言

本文档将介绍JAKA SDK（Python）中定义的数据类型和API，主要适用于使用Python创建与虚拟或真实控制器通信的机器人应用程序的软件开发人员。对于需要了解JAKA机器人控制器应用程序的用户也会有一定帮助。

文档须知

运行环境：Linux Python3.5以上 32位、windows Python3.7以上 64位。
使用到参数的单位：毫米(mm)，角度(rad)。
非特别说明的代码示例中都默认机器人已经开机，并且上电上使能。
文档中的所有代码示例都默认在机器人的工作空间内没有任何干涉。
文档中的示例都已经默认用户的Python解释器能够找到jkrc模块。

Linux下的使用

Linux需要将libjakaAPI.so和jkrc.so 放在同一个文件夹下，并添加当前文件夹路径到环境变量，export LD_LIBRARY_PATH=/xx/xx/

Windows下的使用

Windows需要将jkrc以及jakaAPI.dll 放在同一个文件夹下，常见问题可以查询FAQ。

接口列表

机械臂基础

实例化机器人

实例化一个机器人对象。

RC(ip)

参数说明
- ip: 机器人的IP地址，只有正确的IP地址实例化出的对象才能控制机器人。
返回值
- 成功：返回一个机器人对象
- 失败：创建的对象会被销毁
代码示例

import jkrc
robot = jkrc.RC("192.168.2.64") #返回一个机器人对象

机器人登录

连接机器人控制器

login()

返回值
- 成功：(0,)
- 失败：其它

机器人注销

断开控制器连接

logout()

返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc
robot = jkrc.RC("192.168.2.64") #返回一个机器人对象
robot.login()  #登录
robot.logout() #登出

打开机器人电源

打开机器人电源，给真实的机器人上电大概会有8秒钟左右的延迟。

power_on()

返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc
robot = jkrc.RC("192.168.2.64") #返回一个机器人对象
robot.login()       #登录
robot.power_on()    #上电
robot.logout()      #登出

关闭机器人电源

power_off()

返回值
- 成功：(0,)
- 失败：其它

机器人控制柜关机

shut_down()

返回值
- 成功：(0,)
- 失败：其它

控制机器人上使能

enable_robot()

返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc
robot = jkrc.RC("192.168.2.64")#返回一个机器人对象
robot.login()  #登录
robot.enable_robot()#
robot.logout() #登出

控制机器人下使能

disable_robot()

返回值
- 成功：(0,)
- 失败：其它

查询SDK版本号

获取SDK版本号

get_sdk_version()

返回值
- 成功：(0,version)
- 失败：其它
代码示例

import jkrc
robot = jkrc.RC("192.168.2.64")
robot.login()
ret = robot.get_sdk_version()
print("SDK version  is:",ret[1])
robot.logout()  #登出

获取控制器IP

get_controller_ip ()

返回值
- 成功：(0, ip_list), ip_list: 控制器ip列表，控制器名字为具体值时返回该名字所对应的控制器IP地址，控制器名字为空时，返回网段类内的所有控制器IP地址
- 失败：其它

控制机器人进入或退出拖拽模式

drag_mode_enable(enable)

返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc    
import time    

robot = jkrc.RC("192.168.220.155")    
robot.login()    
robot.power_on()    
robot.enable_robot()
robot.drag_mode_enable(True)
time.sleep(1)
ret = robot.is_in_drag_mode()    
print(ret)    
robot.drag_mode_enable(False)
time.sleep(1)
ret = robot.is_in_drag_mode()    
print(ret)    
robot.logout()

查询机器人是否处于拖拽模式

is_in_drag_mode()

返回值
- 成功：(0,state) state 为1代表机器人处于拖拽模式，0则相反
- 失败：其它

设置关节摩擦力补偿系数

只适配控制器版本1.7.2 设置机械臂各轴摩擦力补偿系数

参数说明
- joint 关节编号 0~5
- gain 摩擦力补偿系数，系数值范围0-200，,200就是补偿200%的摩擦力
返回值
- 成功：(0,)
- 失败：其它

set_drag_friction_compensation_gain(joint, gain)

获取关节摩擦力补偿系数

get_drag_friction_compensation_gain()

返回值
- 成功：(0,list), list是六维列表，分别代表六个轴
- 失败：其它

设置SDK是否开启调试模式

该接口已废弃

设置SDK是否开启调试模式

set_debug_mode(mode)

参数说明
- mode 选择TRUE时，开始调试模式，此时会在标准输出流中输出调试信息；选择FALSE，不开启
返回值
- 成功：(0,)
- 失败：其它

设置SDK日志路径

set_SDK_filepath(filepath)

参数说明
- filepath：文件路径
返回值
- 成功：(0,)
- 失败：其它

机械臂运动

设置机械臂运动规划器类型

设置机械臂运动使用的规划器类型

set_motion_planner(type)

参数说明
- type：运动规划器类型, -1代表禁用规划器（默认采用T规划），0代表T规划（即速度优先），1代表S规划（即柔顺优先）
返回值
- 成功：(0,)
- 失败：其它

控制机器人在手动模式下运动

jog(aj_num , move_mode, coord_type, jog_vel, pos_cmd)

参数说明
- aj_num：axis_joint_based标识值，在关节空间下代表轴号，1 轴到六轴的轴号分别对应数字 0 到 5，笛卡尔空间下依次为x，y，z，rx，ry，rz分别对应数字0到5
- move_mode：0 代表绝对运动，1代表增量运动，2代表连续运动
- coord_type：机器人运动坐标系，工具坐标系，基坐标系（当前的世界/用户坐标系）或关节空间
- jog_vel：指令速度，旋转轴或关节运动单位为rad/s，移动轴单位为mm/s，速度的正负决定运动方向的正负。
- pos_cmd：指令位置，旋转轴或关节运动单位为rad，移动轴单位为mm，当move_mdoe是绝对运动时参数说明可忽略
返回值
- 成功：(0,)
- 失败：其它
代码示例在关节空间内JOG运动

# -*- coding: utf-8 -*-
import time
import jkrc

# 坐标系
COORD_BASE  = 0
COORD_JOINT = 1
COORD_TOOL  = 2

# 运动模式
ABS  = 0
INCR = 1

# 关节1~6依次对应0~5
robot = jkrc.RC("192.168.220.155")  # 返回机器人对象
robot.login()                        # 登录
robot.power_on()                      # 上电
robot.enable_robot()

print("move1")
robot.jog(0, INCR, COORD_JOINT, 0.1, 0.2)
time.sleep(5)  # jog为非阻塞指令，运动状态下接收jog指令会被丢弃

print("move2")
robot.jog(0, INCR, COORD_JOINT, 0.1, -0.2)
time.sleep(3)

robot.jog_stop(-1)
robot.logout()

在笛卡尔空间内JOG运动

# -*- coding: utf-8 -*-
import jkrc  
import time  
COORD_BASE = 0    # 基坐标系  
COORD_JOINT = 1   # 关节空间  
COORD_TOOL = 2    #工具坐标系  
ABS = 0             # 绝对运动  
INCR = 1            # 增量运动  
cart_x = 0          #x方向  
cart_y = 1          #y方向  
cart_z = 2          #z方向  
cart_rx = 3         #rx方向  
cart_ry = 4         #ry方向  
cart_rz = 5         #rz方向  
robot = jkrc.RC("192.168.220.155")#返回一个机器人对象  
robot.login()     #登录  
robot.jog(aj_num = cart_z,move_mode = INCR,coord_type = COORD_BASE,jog_vel = 5,pos_cmd = 10)   # z正方向运动10mm  
robot.jog_stop(-1)  
robot.logout()     #登出

提示：

若机器人已经接近奇异姿态或达到关节限位的话，使用上述代码示例将无法JOG机器人。

控制机器人手动模式下运动停止

控制机器人手动模式下运动停止，用于停止JOG

jog_stop(joint_num)

参数说明
- joint_num: num代表要停止运动的关节轴号，轴号0到5，分别代表关节1到关节6。-1代表停止所有轴的运动。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import time        
import jkrc  

#坐标系  
COORD_BASE  = 0  
COORD_JOINT = 1  
COORD_TOOL  = 2  
#运动模式  
ABS = 0  
INCR= 1  
#关节1~6依次对应0~5,  
  
robot = jkrc.RC("192.168.220.155")#返回机器人对象  
robot.login()#登录  
robot.power_on() #上电  
robot.enable_robot()  
print("move1")  
robot.jog(0,INCR,COORD_JOINT,0.1,1)  
time.sleep(5)#jog为非阻塞指令，运动状态下接收jog指令会被丢弃  
print("move2")  
robot.jog(0,INCR,COORD_JOINT,0.1,-1)  
time.sleep(0.5)  
robot.jog_stop(-1)  #运动0.5秒后停止
robot.logout()

机器人关节运动

机器人关节运动到目标点位

joint_move(joint_pos, move_mode, is_block, speed)

参数说明
- joint_pos: 机器人关节运动目标位置。
- move_mode: 0代表绝对运动，1代表相对运动
- is_block：设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口。阻塞表示机器人运动完成才会有返回值，非阻塞表示接口调用完成立刻就有返回值。
- speed: 机器人关节运动速度，单位：rad/s
- acc: 关节加速度默认 3.5rad/s^2
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import time
import math
import jkrc

# 运动模式
ABS  = 0
INCR = 1

# 关节目标角度（单位：弧度）
joint_pos = [math.pi, math.pi/2, 0, math.pi/4, 0, 0]

# 返回机器人对象
robot = jkrc.RC("192.168.220.155")
robot.login()         # 登录
robot.power_on()      # 上电
robot.enable_robot()  # 使能机器人

print("move1")
robot.joint_move(joint_pos, ABS, True, 0.1)
time.sleep(3)

robot.logout()

机器人扩展关节运动

机器人扩展关节运动。增加关节角加速度和关节运动终点误差。

joint_move_extend(joint_pos, move_mode, is_block, speed, acc, tol)

参数说明
- joint_pos: 机器人关节运动各目标关节角度。
- move_mode: 指定运动模式, 0为绝对运动，1为增量运动，2代表连续运动。
- is_block: 是否为阻塞接口，True为阻塞接口，False为非阻塞接口。
- speed: 机器人关节运动速度，单位：rad/s
- acc：机器人关节运动角加速度。
- tol：机器人运动终点误差。
返回值
- 成功：(0, )
- 失败：其它
代码示例：

# -*- coding: utf-8 -*-
import jkrc                           #导入模块  
robot = jkrc.RC("192.168.220.155")  #返回一个机器人对象  
robot.login()  
robot.joint_move_extend(joint_pos=[1, 1, 1, 1, 1, 1],move_mode=0, is_block=True, speed= 0.2, acc=1, tol=0.1)  
robot.joint_move_extend(joint_pos=[-1, 1, 1, 1, 1, 0],move_mode=0, is_block=True, speed=0.2, acc=1, tol=0.1)  
robot.logout() #登出

机器人末端直线运动

机器人末端直线运动到目标点位。

linear_move(end_pos, move_mode, is_block, speed)

参数说明
- end_pos: 机器人末端运动目标位置
- move_mode: 0 代表绝对运动，1代表相对运动
- is_block: 设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口。阻塞表示机器人运动完成才会有返回值，非阻塞表示接口调用完成立刻就有返回值。
- speed: 机器人直线运动速度，单位：mm/s,默认500mm/s
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import time
import jkrc
# 运动模式
ABS  = 0
INCR = 1
# TCP目标位置（单位：mm）
tcp_pos = [0, 0, -30, 0, 0, 0]
# 返回机器人对象
robot = jkrc.RC("192.168.220.155")
robot.login()         # 登录
robot.power_on()      # 上电
robot.enable_robot()  # 使能机器人
print("move1")
# 阻塞，沿z轴负方向以10mm/s运动30mm
ret = robot.linear_move(tcp_pos, INCR, True, 10)
print(ret[0])
time.sleep(3)
robot.logout()

提示：

由于机器人型号的不同，上述示例填写的位姿可能会逆解失败，返回 -4

机器人扩展末端直线运动

机器人扩展末端直线运动。增加空间加速度和空间运动终点误差。

linear_move_extend(end_pos, move_mode, is_block, speed, acc, tol)

参数说明
- end_pos: 机器人末端运动目标位置。
- move_mode: 指定运动模式, 0为绝对运动，1为增量运动
- is_block: 是否为阻塞接口，True为阻塞接口，False为非阻塞接口。
- speed: 机器人笛卡尔空间运动速度，单位：mm/s
- acc：机器人笛卡尔空间加速度，单位：mm/s^2。
- tol：机器人运动终点误差。
返回值
- 成功：(0,)
- 失败：其它

机器人扩展末端直线运动

机器人扩展末端直线运动。增加姿态速度和姿态加速度。

linear_move_extend_ori(end_pos, move_mode, is_block, speed, accel, tol, ori_vel, ori_acc)

参数说明
- end_pos: 机器人末端运动目标位置。
- move_mode: 指定运动模式, 0为绝对运动，1为增量运动
- is_block: 是否为阻塞接口，True为阻塞接口，False为非阻塞接口。
- speed: 机器人笛卡尔空间运动速度，单位：mm/s
- acc：机器人笛卡尔空间加速度，单位：mm/s^2。
- tol：机器人运动终点误差。
- ori_vel: 姿态速度，默认值为3.14rad/s
- ori_acc: 姿态加速度，默认值为12.56rad/s²
返回值
- 成功：(0,)
- 失败：其它

机器人末端圆弧运动

circular_move (end_pos, mid_pos, move_mode, is_block, speed, acc, tol)

参数说明
- end_pos: 机器人末端运动目标位置。
- mid_pos: 机器人末端运动中间点。
- move_mode: 指定运动模式, 0为绝对运动，1为增量运动，2代表连续运动。
- is_block: 是否为阻塞接口，True为阻塞接口，False为非阻塞接口。
- speed: 机器人直线运动速度，单位：mm/s
- acc：机器人直线运动角加速度，单位：mm/s^2
- tol：机器人运动终点误差。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import time
import math
import jkrc

# 运动模式
ABS  = 0
INCR = 1

# 圆弧运动目标点（笛卡尔位姿，单位：mm / rad）
end_pos = [ -200, 400, 400, -math.pi/2, 0, 0 ]
mid_pos = [ -300, 400, 500, -math.pi/2, 0, 0 ]

# 关节起始位置（单位：rad）
joint_pos = [ 105.791*math.pi/180,
              63.471*math.pi/180,
              -60.442*math.pi/180,
              176.971*math.pi/180,
              74.515*math.pi/180,
              0 ]

# 创建机器人对象
robot = jkrc.RC("192.168.220.155")
robot.login()
robot.power_on()
robot.enable_robot()

# 先做关节空间运动到起始点
robot.joint_move(joint_pos, ABS, True, 1)  # 阻塞运动，速度 1 rad/s
time.sleep(1)  # 确保运动完成

# 再做圆弧运动
robot.circular_move(end_pos=end_pos,
                    mid_pos=mid_pos,
                    move_mode=ABS,
                    is_block=True,
                    speed=20,   # mm/s
                    acc=1,      # 加速度
                    tol=0.1,    # 终点误差
                    )
time.sleep(1)

robot.logout()

机器人扩展末端圆弧运动

机器人末端圆弧运动，增加圈数设置

circular_move_extend (end_pos, mid_pos, move_mode, is_block, speed, acc, tol, opt_cond, cricle_cnt)

参数说明
- end_pos: 机器人末端运动目标位置。
- mid_pos: 机器人末端运动中间点。
- move_mode: 指定运动模式, 0为绝对运动，1为增量运动，2代表连续运动。
- is_block: 是否为阻塞接口，True为阻塞接口，False为非阻塞接口。
- speed: 机器人直线运动速度，单位：mm/s
- acc：机器人直线运动加速度，单位：mm/s^2
- tol：机器人运动终点误差。
- opt_cond: 占位符，传none。
- circle_cnt: 圆弧运动圈数。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import time
import math
import jkrc

# 运动模式
ABS  = 0
INCR = 1

# 圆弧运动目标点（笛卡尔位姿，单位：mm / rad）
end_pos = [ -200, 400, 400, -math.pi/2, 0, 0 ]
mid_pos = [ -300, 400, 500, -math.pi/2, 0, 0 ]

# 关节起始位置（单位：rad）
joint_pos = [ 105.791*math.pi/180,
              63.471*math.pi/180,
              -60.442*math.pi/180,
              176.971*math.pi/180,
              74.515*math.pi/180,
              0 ]

# 创建机器人对象
robot = jkrc.RC("192.168.220.155")
robot.login()
robot.power_on()
robot.enable_robot()

# 先做关节空间运动到起始点
robot.joint_move(joint_pos, ABS, True, 1)  # 阻塞运动，速度 1 rad/s
time.sleep(1)  # 确保运动完成

# 再做圆弧运动
robot.circular_move_extend(end_pos=end_pos,
                    mid_pos=mid_pos,
                    move_mode=ABS,
                    is_block=True,
                    speed=20,   # 速度 mm/s
                    acc=1,      # 加速度 mm/s^2
                    tol=0.1,    # 终点误差
                    opt_cond=None,
                    circle_cnt=1) #旋转1圈
time.sleep(1)

robot.logout()

机器人扩展末端圆弧运动

机器人末端圆弧运动，增加圆弧运动方案设置

circular_move_extend_mode(end_pos, mid_pos, move_mode, is_block, speed, accel, tol, option_cond, circle_cnt, circle_mode)

参数说明
- end_pos: 机器人末端运动目标位置。
- mid_pos: 机器人末端运动中间点。
- move_mode: 指定运动模式, 0为绝对运动，1为增量运动，2代表连续运动。
- is_block: 是否为阻塞接口，True为阻塞接口，False为非阻塞接口。
- speed: 机器人直线运动速度，单位：mm/s
- acc：机器人直线运动加速度，单位：mm/s^2
- tol：机器人运动终点误差。
- opt_cond: 占位符，传none。
- circle_cnt: 圆弧运动圈数。
- circle_mode: 指定机械臂圆弧运动模式，默认值为0，参数解释如下：
  - 0：固定采用起始姿态到终止姿态旋转角度小于180°的轴角进行姿态变化；(当前方案)
  - 1：固定采用起始姿态到终止姿态旋转角度大于180°的轴角进行姿态变化；
  - 2：根据中间点姿态自动选择选择角度小于180°还是大于180°；
  - 3：姿态夹角与圆弧轴线始终保持一致（当前整圆运动）。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import time
import math
import jkrc

# 运动模式
ABS  = 0
INCR = 1

# 圆弧运动目标点（笛卡尔位姿，单位：mm / rad）
end_pos = [ -200, 400, 400, -math.pi/2, 0, 0 ]
mid_pos = [ -300, 400, 500, -math.pi/2, 0, 0 ]

# 关节起始位置（单位：rad）
joint_pos = [ 105.791*math.pi/180,
              63.471*math.pi/180,
              -60.442*math.pi/180,
              176.971*math.pi/180,
              74.515*math.pi/180,
              0 ]

# 创建机器人对象
robot = jkrc.RC("192.168.220.155")
robot.login()
robot.power_on()
robot.enable_robot()

# 先做关节空间运动到起始点
robot.joint_move(joint_pos, ABS, True, 1)  # 阻塞运动，速度 1 rad/s
time.sleep(1)  # 确保运动完成

# 再做圆弧运动
robot.circular_move_extend_mode(end_pos=end_pos,
                    mid_pos=mid_pos,
                    move_mode=ABS,
                    is_block=True,
                    speed=20,   # 速度 mm/s
                    acc=1,      # 加速度 mm/s^2
                    tol=0.1,    # 终点误差
                    opt_cond=None,
                    circle_cnt=1, #旋转1圈
                    circle_mode=0)
time.sleep(1)

robot.logout()

终止当前机械臂运动

可以在任何情况下终止机器人的运动。

motion_abort ()

返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import time
import jkrc

robot = jkrc.RC("192.168.220.155")  # 返回机器人对象
robot.login()
robot.power_on()
robot.enable_robot()

print("move1")
# 关节增量运动（非阻塞）
robot.joint_move(
    joint_pos=[1, 0, 0, 0, 0, 0],
    move_mode=1,      # INCR
    is_block=False,   # 非阻塞
    speed=0.05
)

print("wait")
time.sleep(2)

print("stop")
robot.motion_abort()  # 强制中断当前运动

robot.logout()

查询机器人运动是否停止

is_in_pos()

返回值
- 成功：(0, state)，state为1代表机器人停止，0则相反
- 失败：其它

查询机器人运动状态

get_motion_status()

返回值
- 成功：(0, data)，
  - motion_line 当前运动指令的ID
  - motion_line_sdk 保留参数
  - inpos 当前运动是否已完成
  - err_add_line 添加运动指令失败(机械臂已经在目标位置)
  - queue 队列中等待处理的运动指令数
  - active_queue 队列中正在运动的指令数
  - queue_full 指令队列是否已满，0：队列未满，1：队列已满
  - paused 机械臂是否处于暂停状态，0：机械臂未暂停，1：机械臂已暂停
  - isOnLimit 机械臂是否处于软限位状态，0：机械臂正常，1：机械臂到达软限位
  - isInEstop 机械臂是否处于急停状态，0：机械臂正常，1：机械臂进入急停状态
  - isInCollision 机械臂是否处于碰撞状态，0：机械臂正常，1：机械臂触发碰撞
- 失败：其它

机械臂设置阻塞运动超时时间

该接口已废弃

机械臂设置阻塞运动超时时间。

set_block_wait_timeout（seconds）

参数说明 Seconds 大于0.5
返回值
- 成功：(0,)
- 失败：其它

机械臂操作信息设置与查询

获取机器人状态监测数据

获取机器人状态数据监测数据，支持多线程安全

get_robot_status ()

返回值
- 成功：(0, robotstatus)，robotstatus的长度为24，robotstatus返回数据顺序如下所示:
  - errcode 机器人运行出错时错误编号，0为运行正常，其它为异常
  - inpos 机器人运动是否到位标志，0为没有到位，1为运动到位
  - powered_on 机器人是否上电标志，0为没有上电，1为上电
  - enabled 机器人是否使能标志，0为没有使能，1为使能
  - rapidrate 机器人运行倍率
  - protective_stop 机器人是否检测到碰撞，0为没有检测到碰撞，1则相反
  - drag_status机器人是否处于拖拽状态，0为没有处于拖拽状态，1则相反
  - on_soft_limit 机器人是否处于限位，0为没有触发限位保护，1为触发限位保护
  - current_user_id 机器人目前使用的用户坐标系id
  - current_tool_id 机器人目前使用的工具坐标系id
  - dout 机器人控制柜数字输出信号
  - din 机器人控制柜数字输入信号
  - aout 机器人控制柜模拟输出信号
  - ain 机器人控制柜模拟输入信号
  - tio_dout 机器人末端工具数字输出信号
  - tio_din 机器人末端工具数字输入信号
  - tio_ain 机器人末端工具模拟输入信号
  - extio 机器人外部扩展模块IO信号
  - cart_position 机器人末端的笛卡尔空间位置值
  - joint_position 机器人关节空间位置
  - robot_monitor_data 机器人状态监测数据（scb主版本号、scb小版本号、控制器温度、机器人平均电压、机器人平均电流、机器人6个关节的监测数据（瞬时电流、瞬时电压、瞬时温度））
  - torq_sensor_monitor_data 机器人力矩传感器状态监测数据（力矩传感器ip地址、力矩传感器端口号、工具负载（负载质量、质心x轴坐标、质心y轴坐标、质心z轴坐标）、力矩传感器状态、力矩传感器异常错误码、6个力矩传感器实际接触力值、6个力矩传感器原始读数值、6个力矩传感器实际接触力值（不随初始化选项变化））
  - is_socket_connect sdk与控制器连接通道是否正常，0为连接通道异常，1为连接通道正常
  - emergency_stop 机器人是否急停，0为没有按下急停，1则相反
  - tio_key 机器人末端工具按钮 [0]free；[1]point；[2]末端灯光按钮
- 失败：其它

提示：

若机器人无对应IO，会返回如“no extio”字符串。

# -*- coding: utf-8 -*-
import jkrc  
  
robot = jkrc.RC("192.168.220.155")  
robot.login()  
ret = robot.get_robot_status()  
if ret[0] == 0:  
    print("the joint position is :",ret[1])   
    print(len(ret[1]))  
    for i in range(len(ret[1])):  
        print(ret[1][i])  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()

获取机械臂状态（simple）

获取机械臂状态

get_robot_status_simple()

返回值
- 成功：(0,data)
  - errcode:错误码
  - errmsg: 错误信息
  - powered_on: 是否上电
  - enabled: 是否上使能
- 失败：其它

获取当前机器人的六个关节角度值(伺服反馈)

获取当前机器人的六个关节角度值（伺服反馈)

get_actual_joint_position()

返回值
- 成功：(0, joint_pos), joint_pos是一个包含6位元素的元组 (j1, j2, j3, j4, j5, j6)，j1, j2,j3, j4, j5, j6 分别代表关节1到关节6的角度值。
- 失败：其它
代码示例

# -*- coding: utf-8 -*-    
import jkrc  
    
robot = jkrc.RC("192.168.220.155")#返回一个机器人对象  
ret = robot.login()#登录  
ret = robot.get_actual_joint_position()  
if ret[0] == 0:  
    print("the actual joint position is :",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()  #登出

获取当前机器人的六个关节角度值

get_joint_position()

返回值
- 成功：(0, joint_pos), joint_pos是一个包含6位元素的元组 (j1, j2, j3, j4, j5, j6)，j1, j2,j3, j4, j5, j6 分别代表关节1到关节6的角度值。
- 失败：其它
代码示例

# -*- coding: utf-8 -*-    
import jkrc  
    
robot = jkrc.RC("192.168.220.155")#返回一个机器人对象  
ret = robot.login()#登录  
ret = robot.get_joint_position()  
if ret[0] == 0:  
    print("the joint position is :",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()  #登出

设置机器人状态数据自动更新时间间隔

该接口已废弃

设置机器人状态数据自动更新时间间隔，可以改变系统占用率，默认尽可能快地发送以保证实时性（默认间隔：4ms）。

set_status_data_update_time_interval (millisecond)

参数说明
- millisecond: 时间参数说明，单位：ms。
返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc                           #导入模块  
robot = jkrc.RC("192.168.2.165")  #返回一个机器人对象  
robot.login()  
robot.set_status_data_update_time_interval(100)  
robot.logout()

获取当前设置下工具末端的位姿（伺服反馈）

get_actual_tcp_position()

返回值
- 成功： (0, cartesian_pose), cartesian_pose是一个包含6位元素的元组(x, y, z, rx ,ry, rz)，x, y, z, rx, ry, rz 代表机器人工具末端的位姿值
- 失败：其它
代码示例

# -*- coding: utf-8 -*-         
import jkrc  
  
robot = jkrc.RC("192.168.220.155")#返回一个机器人对象  
ret = robot.login()#登录  
ret = robot.get_actual_tcp_position()  
if ret[0] == 0:  
    print("the actual tcp position is :",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()  #登出

获取当前设置下工具末端的位姿

get_tcp_position()

返回值
- 成功： (0, cartesian_pose), cartesian_pose是一个包含6位元素的元组(x, y, z, rx ,ry, rz)，x, y, z, rx, ry, rz 代表机器人工具末端的位姿值
- 失败：其它
代码示例

# -*- coding: utf-8 -*-         
import jkrc  
  
robot = jkrc.RC("192.168.220.155")#返回一个机器人对象  
ret = robot.login()#登录  
ret = robot.get_tcp_position()  
if ret[0] == 0:  
    print("the tcp position is :",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()  #登出

获取机器人DH参数

获取用户坐标系信息

get_dh_param()

返回值
- 成功：(0, {'alpha': (0.0, 1.5707963, 0.0, 0.0, 1.5707963, -1.5707963), 'a': (0.0, 0.0, 897.0, 744.5, 0.0, 0.0), 'd': (196.5, 0.0, 0.0, -188.35000610351562, 138.5, 120.5), 'joint_homeoff': (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)})
DH参数解析

参数名	类型	说明	单位
`alpha` (α)	连杆扭角	相邻Z轴之间的夹角（绕X轴的旋转角）	弧度 (rad)
`a`	连杆长度	沿X轴的连杆长度（两相邻Z轴的公垂线距离）	毫米 (mm)
`d`	连杆偏移	沿Z轴的平移距离（相邻X轴之间的偏移）	毫米 (mm)
`joint_homeoff`	关节零位偏移	关节的零位校准偏移量（校正机械臂零点）	弧度 (rad)

* 失败：其它

设置用户坐标系信息

set_user_frame_data(id, user_frame, name)

参数说明
- id：用户坐标系ID，可选ID为1到15,0代表机器人基坐标系
- user_frame：用户坐标系参数说明[x,y,z,rx,ry,rz]
- name：用户坐标系别名
返回值
- 成功：(0,)
- 失败：其它

获取用户坐标系信息

get_user_frame_data(id)

参数说明
- id 用户坐标系ID查询结果
返回值
- 成功：(0, id, tcp), id : 用户坐标系ID，可选ID为1到15, 0代表机器人基坐标系tcp: 用户坐标系参数说明[x,y,z,rx,ry,rz]
- 失败：其它

查询当前使用的用户坐标系ID

get_user_frame_id()

返回值
- 成功：(0, id)，id值范围为0到15, 0代表机器人基坐标系
- 失败：其它

设置当前使用的用户坐标系ID

set_user_frame_id(id)

参数说明
- id: 用户坐标系ID
返回值
- 成功：(0,)
- 失败：其它

设置指定编号的工具信息

set_tool_data(id, tcp, name)

参数说明
- id：设置工具ID，可选ID为1到15，0代表末端法兰盘, 已被控制器使用。
- tcp：设置工具坐标系参数说明[x,y,z,rx,ry,rz]
- name：用户坐标系别名
返回值
- 成功：(0,)
- 失败：其它

查询目标工具坐标系的信息

查询机器人使用的工具信息

get_tool_data(id)

返回值
- 成功：(0, id, tcp), id值范围为0到15，0代表末端法兰盘, 已被控制器使用。工具坐标系参数说明[x,y,z,rx,ry,rz]
- 失败：其它

查询机器人当前使用的工具ID

get_tool_id()

返回值
- 成功：(0, id)，id值范围为0到15，0代表末端法兰盘，已被控制器使用。
- 失败：其它

设置当前使用的工具ID

set_tool_id(id)

参数说明
- id: 工具坐标系ID
返回值
- 成功：(0,)
- 失败：其它
代码示例：

# -*- coding: utf-8 -*-  
import time        
import jkrc  
robot = jkrc.RC("192.168.220.155") #返回一个机器人对象  
robot.login()                        #登录  
ret = robot.get_tool_data(1)    #查询工具坐标系数据  
if ret[0] == 0:  
    print("the tool data is :",ret)  
else:  
    print("some things happend,the errcode is: ",ret[0])  
ret = robot.set_tool_data(1,[0,0,1,0,0,0],'test') #设置工具坐标系数据  
print("set tool data ret:",ret)
time.sleep(0.5)  
ret = robot.get_tool_data(1)    #查询工具坐标系数据  
if ret[0] == 0:  
    print("the tool data is :",ret)  
else:  
    print("some things happend,the errcode is: ",ret[0])  
ret = robot.get_tool_id()     #查询工具坐标系id  
print("tool_id",ret)  
robot.set_tool_id(2)          #设置工具坐标系数据  
time.sleep(0.5)    
ret = robot.get_tool_id()     #查询工具坐标系id  
print("tool_id",ret)  
robot.logout()

设置数字输出变量（DO）的值

set_digital_output(iotype, index, value)

参数说明
- iotype：DO类型
- index：DO索引（从0开始）
- value：DO设置值
返回值
- 成功：(0,)
- 失败：其它
代码示例：设置DO3的值为1

# -*- coding: utf-8 -*-  
import jkrc
IO_CABINET  =0  #控制柜面板IO
IO_TOOL = 1     #工具IO
IO_EXTEND = 2   #扩展IO
robot = jkrc.RC("192.168.220.155")
robot.login()  
ret = robot.set_analog_output(iotype = IO_CABINET,index = 0,value = 1.55)# 设置控制柜面板IO0的输出值为1.55 
if ret[0] == 0:  
    print("set_analog_output success, ret = ",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()  #登出

设置模拟输出变量（AO）的值

set_analog_output(iotype, index, value)

参数说明
- iotype：AO类型
- index：AO索引（从0开始）
- value：AO设置值
返回值
- 成功：(0,)
- 失败：其它
代码示例：设置AO1的值为1.55

import jkrc
IO_CABINET  =0  #控制柜面板IO
IO_TOOL = 1     #工具IO
IO_EXTEND = 2   #扩展IO
robot = jkrc.RC("192.168.2.64")
robot.login()  
robot.set_analog_output(iotype = IO_CABINET,index = 0,value = 1.55)#    
robot.logout()  #登出

运动中设置数字输出变量（DO）的值

set_motion_digital_output(iotype, index, value, rel, distance)

参数说明
- iotype DO类型
- index DO索引（从0开始）
- value DO设置值
- rel 0: 相对于运动起点， 1：相对于运动终点
- distance 距离，指相对于起点或终点（依据rel参数）距离多少触发DO
返回值
- 成功：(0,)
- 失败：其它

运动中设置模拟输出变量（AO）的值

set_motion_analog_output(iotype, index, value, rel, distance)

参数说明
- iotype AO类型
- index AO索引（从0开始）
- value AO设置值
- rel 0: 相对于运动起点， 1：相对于运动终点
- distance 距离，指相对于起点或终点（依据rel参数）距离多少触发AO
返回值
- 成功：(0,)
- 失败：其它

查询数字输入（DI）状态

get_digital_input(iotype, index)

参数说明
- iotype: DI类型
- index: DI索引（从0开始）
返回值
- 成功：(0, value)，value: DI状态查询结果
- 失败：其它

查询数字输出（DO）状态

get_digital_output(iotype, index)

参数说明
- iotype: DO类型
- index: DO索引（从0开始）
返回值
- 成功：(0, value)，value: DO状态查询结果
- 失败：其它

查询模拟量输入变量（AI）的值

get_analog_input(iotype, index)

参数说明
- iotype：AI类型
- index：AI索引（从0开始）
返回值
- 成功：(0, value), value是AI状态查询结果，为浮点数
- 失败：其它

查询模拟量输出变量（AO）的值

get_analog_output(type, index)

参数说明
- type：AO类型
- index：AO索引（从0开始）
返回值
- 成功：(0, value), value是AO状态查询结果，为浮点数
- 失败：其它
代码示例：查询AO1的值为

# -*- coding: utf-8 -*-  
import jkrc
IO_CABINET  =0  #控制柜面板IO
IO_TOOL = 1     #工具IO
IO_EXTEND = 2   #扩展IO
robot = jkrc.RC("192.168.220.155")
robot.login()  
robot.set_analog_output(iotype = IO_CABINET,index = 0,value = 1.55)    
ret = robot.get_analog_output(iotype = IO_CABINET,index = 0)
print("AO value is:",ret[1])
robot.logout()  #登出

查询扩展IO模块是否运行

is_extio_running()

返回值
- 成功：(0, status)，status 为1时代表扩展IO模块，为0时则相反
- 失败：其它

机器人负载设置

set_payload(mass = m, centroid = [x,y,z])

参数说明
- mass：负载质量，单位: kg
- centroid：负载质心坐标[x, y ,z]，单位: mm
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc                               #导入模块
robot = jkrc.RC("192.168.220.155")      #返回一个机器人对象
robot.login()
robot.set_payload(mass= 1, centroid =[0.01,0.02,0.03])
robot.logout() 							#登出

获取机器人负载数据

get_payload()

返回值
- 成功：(0, payload)，payload是长度为2的元组 (mass, (x,y,z))，第一个元素是负载质量，第二个元素是质心坐标。
- 失败：其它
代码示例：

# -*- coding: utf-8 -*-  
import jkrc  
robot = jkrc.RC("192.168.220.155") #返回一个机器人对象  
robot.login()                       #登录  
robot.set_payload(mass= 1,centroid =[0.01,0.02,0.03])   
ret = robot.get_payload()    
if ret[0] == 0:  
    print("the payload is :",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()

设置 TIO V3电压参数

set_tio_vout_param(vout_enable,vout_vol)

参数说明
- vout_enable 电压使能，0:关，1开
- vout_vol 电压大小 0:24v 1:12v
返回值
- 成功：(0)
- 失败：其它

获取 TIO V3电压参数

get_tio_vout_param(vout_enable ,vout_vol)

参数说明
- vout_enable 电压使能，0:关，1开
- vout_vol 电压大小 0:24v 1:12v
返回值
- 成功：(0,(vout_enable ,vout_vol))
- 失败：其它

TIO添加或修改信号量

add_tio_rs_signal(sign_info)

参数说明
- sign_info：dict 信号量属性
  - sig_name 信号量名称
  - chn_id 通道ID
  - sig_type 信号量类型
  - sig_addr 信号量地址
  - value 信号量初始值
  - frequency 信号量频率
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc  

robot = jkrc.RC("192.168.220.155")  # 返回一个机器人对象  
robot.login()                       # 登录  

ret = robot.add_tio_rs_signal({
    'sig_name': 'signal_tmp',   # 信号量名称
    'chn_id': 0,                # RS485 通道 ID
    'sig_type': 0,              # 信号量类型
    'sig_addr': 0x1,            # 信号量地址
    'value': 5,                 # 信号量初始值
    'frequency': 5              # 信号量频率
})

if ret[0] == 0:  
    print("add_tio_rs_signal success, ret =", ret[0])  
else:  
    print("some things happened, errcode =", ret[0])   

robot.logout()

TIO删除信号量

del_tio_rs_signal(sign_name)

参数说明
- sign_info: str 信号量标识名
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc  

robot = jkrc.RC("192.168.220.155")  # 返回一个机器人对象  
robot.login()                       # 登录  
ret = robot.del_tio_rs_signal('signal_tmp')  
if ret[0] == 0:  
    print("del_tio_rs_signal success, ret =", ret[0])  
else:  
    print("some things happened, errcode =", ret[0])   

robot.logout()

TIO RS485 发送指令

send_tio_rs_command(chn_id, cmd)

参数说明
- chn_id：int 通道号
  - 0-通道1
  - 1-通道2
- cmd：str 数据字段(bytearray,可变的字节数组)
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc

robot = jkrc.RC("192.168.220.155")
robot.login()

cmd = bytearray(b"test_cmd")
ret = robot.send_tio_rs_command(0, cmd)

if ret[0] == 0:
    print("send_tio_rs_command success, ret =", ret[0])
else:
    print("some things happened, errcode =", ret[0])

robot.logout()

TIO刷新信号量信息

update_tio_rs_signal(sign_info)

参数说明
- sign_info：dict 信号量属性，是个字典类型数据
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc

robot = jkrc.RC("192.168.220.155")
robot.login()
ret = robot.update_tio_rs_signal({  
        'sig_name': 'signal_tmp',
        'frequency': 5
})
if ret[0] == 0:
    print("update_tio_rs_signal success, ret =", ret[0])
else:
    print("some things happened, errcode =", ret[0])
robot.logout()

TIO获取信号量信息

get_rs485_signal_info()

返回值
- 成功：(0,sign_info_list) sign_info_list: list 信号量信息数组
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc

robot = jkrc.RC("192.168.220.155")
robot.login()
ret = robot.get_rs485_signal_info()
if ret[0] == 0:
    print("get_rs485_signal_info success, sign_info_list: {}".format(ret, ret[1]))
else:
    print("some things happened, errcode =", ret[0])
robot.logout()

设置TIO模式

set_tio_pin_mode(pin_type, pin_mode)

参数说明
- pin_type: tio类型 0 for DI Pins, 1 for DO Pins, 2 for AI Pins
- pin_mode: tio模式
  - DI Pins: 0:0x00 DI2为NPN，DI1为NPN，1:0x01 DI2为NPN，DI1为PNP，2:0x10 DI2为PNP，DI1为NPN，3:0x11 DI2为PNP，DI1为PNP
  - DO Pins: 低8位数据高4位为DO2配置，低四位为DO1配置，0x0 DO为NPN输出，0x1 DO为PNP输出，0x2 DO为推挽输出，0xF RS485H接口
  - AI Pins: 0:模拟输入功能使能，RS485L禁止，1:RS485L接口使能，模拟输入功能禁止
返回值
- 成功：(0,)
- 失败：其它

获取TIO模式

get_tio_pin_mode(pin_type)

参数说明 pin_type: tio类型。0 for DI Pins, 1 for DO Pins, 2 for AI Pins。
返回值
- 成功：(0,pin_mode)
- 失败：其它

TIO RS485通讯参数配置

set_rs485_chn_comm(chn_id, slave_id, baudrate, databit,stopbit, parity)

参数说明
- chn_id：RS485 通道 ID 查询时 chn_id 作为输入参数说明
- slaveId：当通道模式设置为 Modbus RTU 时，需额外指定 Modbus 从站节点 ID，其余模式可忽略
- baudrate：波特率 4800,9600,14400,19200,38400,57600,115200,230400
- databit：数据位 7，8
- stopbit：停止位 1，2
- parity：校验位 78→无校验 79→奇校验 69→偶校验

TIO RS485通讯参数说明查询

get_rs485_chn_comm(chn_id)

返回值
- 成功：(0, (chn_id, slave_id,baudrate, databit, stopbit, parity))
- 失败：其它

TIO RS485通讯模式配置

set_rs485_chn_mode(chn_id, chn_mode)

参数说明
- chn_id: 0: RS485H, channel 1; 1:RS485L, channel 2
- chn_mode: 0: Modbus RTU, 1: Raw RS485, 2, torque sensor

TIO RS485通讯模式查询

get_rs485_chn_mode(chn_id)

参数说明
- chn_id 0: RS485H, channel 1; 1:RS485L, channel 2
返回值
- 成功：(0, chn_mode)
  - chn_mode: 0: Modbus RTU, 1: Raw RS485, 2: torque sensor
- 失败：其它

设置机器人安装角度

set_installation_angle(anglex, angley)

参数说明
- anglex：x方向安装角度，范围[0, PI]度
- anglez：z方向安装角度，范围[0, 360]度
返回值
- 成功：(0)
- 失败:其它

获取机器人安装角度

get_installation_angle()

参数说明
- anglex：x方向安装角度
- anglez：z方向安装角度
返回值
- 成功：(0, [qs, qx, qy, qz, rx, ry, rz])。安装角度四元数表示[qx, qy, qz, qs], 安装角度欧拉角表示[rx, ry, rz]，其中ry固定为0。
- 失败：其它。
代码示例

# -*- coding: utf-8 -*-
import jkrc  
robot = jkrc.RC("192.168.220.156")  
res = robot.login()  
if res[0] != 0:  
    raise "rc login failed."  
 
anglex = 3.14  
angley = 0  
res = robot.set_installation_angle(anglex, angley)  
if res[0] != 0:  
    raise "set installation angle failed."  
  
res = robot.get_installation_angle()  
if res[0] != 0:  
    raise "get installation angle failed."  
  
print("installation angle:")  
print("quat: [{x}, {y}, {z}, {s}]".format(s=res[1][0], x=res[1][1], y=res[1][2], z=res[1][3]))  
print("rpy: [{rx}, {ry}, {rz}]".format(rx=res[1][4], ry=res[1][5], rz=res[1][6]))  

robot.logout()

获取机械臂状态

get_robot_state()

参数说明
- 成功：(0,(estoped, power_on, servo_enabled))
  - estoped：急停。 0: 关， 1: 开
  - power_on：上电。 0: 关，1: 开
  - servo_enabled：伺服使能。 0: 关，1: 开
- 失败：其它
代码示例：

# -*- coding: utf-8 -*-
import jkrc  
robot = jkrc.RC("192.168.220.156")  
ret = robot.login()  
ret, (estoped, power_on, servo_enabled) = robot.get_robot_state()  
print('ret is {}, estop: {}, power_on {}, servo_enabled: {}'.format(ret, estoped, power_on, servo_enabled))  
robot.logout()

设置系统变量

set_user_var(id, value, name)

参数说明
- id：系统变量id
- value：系统变量的值
- name：系统变量的别名
返回值
- 成功：(0, )
- 失败：其它

获取系统变量

get_user_var()

返回值
- 成功：(0, data)
- 失败：其它
代码示例：

# -*- coding: utf-8 -*-
import jkrc  
robot = jkrc.RC("192.168.220.156")  
ret = robot.login()  
ret  = robot.set_user_var(5500, 1, "test")  
if ret[0] == 0:  
    print("set_user_var success")  
else:  
    print("some things happend,the errcode is: ",ret[0]) 
ret = robot.get_user_var()
print("get_user_var result is: ", ret)
robot.logout()

设置抖动抑制模式

set_vibsuppress_mode(mode| robot_id)

参数说明
- mode 抖动抑制模式，0：关闭，1：模式1，2：模式2
- robot_id 机械臂ID，默认值为 0(可选参数)
返回值
- 成功：(0, )
- 失败：其它

开启抖动抑制设置

vibsuppress_on(frequency | damping, robot_id)

参数说明
- frequency 震动频率
- damping 震动阻尼，默认值为 0.05(可选参数)
- robot_id 机械臂ID，默认值为 0(可选参数)
返回值
- 成功：(0, )
- 失败：其它

各个机型的初始默认频率如下表：

负载/机型	默认频率(Hz)
MiniCobot1	16
MiniCobot2	15
3kg(Zu3等)	14
5kg(C5/A5/双臂等)	12
7kg(Zu7等)	12
12kg(Zu12等)	8
16kg(Zu16)	7.5
18kg(Zu18)	7.5
20kg(Zu20)	7.5
30kg(Zu30)	7.4
Max40	5

关闭抖动抑制设置

vibsuppress_off(| robot_id)

参数说明
- robot_id 机械臂ID，默认值为 0(可选参数)
返回值
- 成功：(0, )
- 失败：其它
代码示例：

# -*- coding: utf-8 -*-
import jkrc  
robot = jkrc.RC("192.168.220.156")  
ret = robot.login()  
ret  = robot.set_vibsuppress_mode(1)  
if ret[0] == 0:  
    print("set_vibsuppress_mode success")  
else:  
    print("some things happend,the errcode is: ",ret[0]) 

ret = robot.vibsuppress_on(14)
if ret[0] == 0:  
    print("vibsuppress_on success")  
else:  
    print("some things happend,the errcode is: ",ret[0])

ret = robot.vibsuppress_off()
if ret[0] == 0:  
    print("vibsuppress_off success")  
else:  
    print("some things happend,the errcode is: ",ret[0]) 
robot.logout()

机械臂安全状态设置

查询机械臂是否处于急停状态

is_in_estop()

返回值
- 成功：(0, estop), estop为1代表机器人处于急停，0则相反
- 失败：其它

查询机器人是否超出限位

is_on_limit()

返回值
- 成功：(0, state)，state为1代表机器人超出限位，0则相反
- 失败：其它

查询机器人是否处于碰撞保护模式

is_in_collision()

返回值
- 成功：(0, state)，state为1代表机器人处于碰撞保护模式，0则相反
- 失败：其它

碰撞之后从碰撞保护模式恢复

collision_recover()

返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*- 
import jkrc  
import time  
  
robot = jkrc.RC("192.168.220.156")  
robot.login()  
robot.power_on()  
robot.enable_robot()  
ret = robot.get_collision_level()#获取当前碰撞等级  
print(ret)  
robot.set_collision_level(1)#设置碰撞等级  
ret = robot.get_collision_level()  
print(ret)  
num = 0  
while(1):  
    ret = robot.is_in_collision()  #查询是否处于碰撞保护模式
    collision_status = ret[1]  
    if collision_status == 1:  
        time.sleep(5)  
        robot.collision_recover()   #如果发生了碰撞，从碰撞保护模式恢复  
        print(" in collision "+ str(num))  
    else:  
        print("the robot is not in collision "+ str(num))  
    time.sleep(1)  
    num=num+1  
  
robot.logout()

设置机器人碰撞等级

set_collision_level(level)

参数说明
- level: 碰撞等级，取值范围[0,5] ，其中0为关闭碰撞，1为碰撞阈值25N，2为碰撞阈值 50N，3为碰撞阈值75N，4为碰撞阈值100N，5为碰撞阈值125N
返回值
- 成功：(0,)
- 失败：其它

获取机器人碰撞等级

get_collision_level()

返回值
- 成功：(0, level)，level是返回的碰撞等级，等级0-5。
  - 0为关闭碰撞，
  - 1为碰撞阈值25N，
  - 2为碰撞阈值50N，
  - 3为碰撞阈值75N，
  - 4为碰撞阈值100N，
  - 5为碰撞阈值125N
- 失败：其它

设置网络异常时机器人自动终止运动类型

设置网络异常控制句柄，当网络出现异常情况时，控制机器人运动状态。

set_network_exception_handle(millisecond, mnt)

参数说明
- millisecond: 时间参数，单位：ms。
- mnt: 网络异常时机器人需要进行的动作类型，0代表机器人保持原来的运动，1代表暂停运动，2代表终止运动。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import time        
import jkrc  
  
#运动模式  
ABS = 0  
INCR= 1  
robot = jkrc.RC("192.168.220.156")#返回机器人对象  
robot.login()#登录  
robot.power_on() #上电  
robot.enable_robot()  
robot.set_network_exception_handle(100,2)#设置100ms, 暂停运动。    
print("move1")  
num=0  
while(1):  
    robot.joint_move([1,1,1,1,1,1],ABS,False,0.5)  
    robot.joint_move([-1,1,1,1,1,1],ABS,False,0.5)  
    num = num +1  
    print(num)  
    time.sleep(6)  
robot.logout()

获取机器人运行过程中的错误码

获取机器人运行过程中最后一个错误码，当调用clear_error时，最后一个错误码会清零。

get_last_error()

返回值
- 成功：(0, error)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc  
robot = jkrc.RC("192.168.220.156")#返回一个机器人对象  
robot.login()   #登录  
robot.program_load("not_exist") #故意加载一个不存在的程序,引起报错  
ret = robot.get_last_error ()#没有设置错误码文件路径，只能得到错误码，得不到具体错误信息  
print(ret[1])   
robot.logout()  #登出

错误状态清除

clear_error()

返回值
- 成功：(0,)
- 失败：其它

设置错误码文件的路径

废弃接口

设置错误码文件路径，使用get_last_error接口时，如果要获得具体的错误信息，需要使用此接口设置错误码文件路径，如果只是需要获取错误码，不需要调用此接口。

注

注意：路径不能包含中文，否则无法使用。

set_errorcode_file_path (errcode_file_path)

参数说明
- errcode_file_path：错误码文件存放路径
返回值
- 成功：(0,)
- 失败：其它

机械臂EDG（External Data Guider）功能

机械臂EDG使能

机械臂EDG功能使能，使能后才可使用EDG相关接口

edg_init(en, edg_stat_ip)

参数说明
- en 使能开关，true为开启EDG功能，false为退出该功能
- edg_stat_ip SDK客户端IP地址
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc  
robot = jkrc.RC("192.168.220.156")#返回一个机器人对象  
robot.login()   #登录  

ret = robot.edg_init(
    en=True,                      # 是否启用 EDG 功能
    edg_stat_ip="192.168.220.144"  # 状态反馈模块 IP 地址
)
print("edg_init 返回值：", ret)
robot.logout()  #登出

注意：

使能后不能调用servo_j和servo_p;必须调用edg_init(false)关闭EDG功能后才能调用servo_j和servo_p

机械臂EDG使能扩展

机械臂EDG使能扩展，支持配置本机端口号及调用servo_j和servo_p。

edg_init_extend(en, edg_stat_ip, edg_port, edg_mode)

参数说明
- en 使能开关，true为开启该功能，false为退出该功能
- edg_stat_ip SDK客户端ip地址
- edg_port 本机端口号
- edg_mode EDG模式，默认值为0，0表示所有EDG相关的接口都可以调用，1表示除edg_servo_j和edg_servo_p外，所有接口都可以调用(此时可调用servo_j和servo_p)
返回值
- 成功：(0,)
- 失败：其它
代码示例：

# -*- coding: utf-8 -*-  
import jkrc  
robot = jkrc.RC("192.168.220.156")#返回一个机器人对象  
robot.login()   #登录  

ret = robot.edg_init_extend(
    en=True,
    edg_stat_ip="192.168.220.144",
    edg_port=30003,         # 端口号
    edg_mode=1              # 模式编号（根据协议定义）
)
print("edg_init_extend 返回值：", ret)
robot.logout()  #登出

机械臂高速获取EDG反馈数据

edg_get_stat(robot_index)

参数说明
- robot_index 使用默认值，无需传参
返回值
- 成功：(0,status), status的长度为6，status返回数据顺序如下所示：
  - joint_value 当前关节位置
  - joint_vel 当前关节速度
  - joint_torque 当前关节力矩
  - cart_pose 当前笛卡尔位置
  - torque_sensor 力矩传感器数据
  - io_state 依次为 din、dout、ain、aout、tool_din、tool_dout、tool_ain
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc  
robot = jkrc.RC("192.168.220.156")#返回一个机器人对象  
robot.login()   #登录  

ret = robot.edg_init_extend(
    en=True,
    edg_stat_ip="192.168.220.144",
    edg_port=30003,         # 端口号
    edg_mode=1              # 模式编号（根据协议定义）
)
print("edg_init_extend 返回值：", ret)
ret = robot.edg_get_stat(robot_index=0)
print("edg_get_stat 返回值：", ret)
robot.logout()  #登出

机械臂获取EDG反馈发出时间戳

机械臂获取EDG反馈数据发出时间戳

edg_stat_details()

返回值
- 成功：(0,details), details的长度为3，数据顺序：秒、纳秒、时间戳计数
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc  
robot = jkrc.RC("192.168.220.156")#返回一个机器人对象  
robot.login()   #登录  

ret = robot.edg_init_extend(
    en=True,
    edg_stat_ip="192.168.220.144",
    edg_port=30003,         # 端口号
    edg_mode=1              # 模式编号（根据协议定义）
)
print("edg_init_extend 返回值：", ret)
ret = robot.edg_get_stat(robot_index=0)
print("edg_get_stat 返回值：", ret)
# 获取 EDG 状态详情
ret = robot.edg_stat_details()
print("edg_stat_details 返回值：", ret)
robot.logout()  #登出

机械臂EDG关节空间伺服模式运动

edg_servo_j(joint_pos, move_mode, step_num, robot_index)

参数说明
- joint_pos 机械臂关节运动目标位置
- move_mode 指定运动模式：0代表绝对运动，1代表增量运动
- step_num 倍分周期，edg_servo_j运动周期step_num*8ms，其中step_num>=1
- robot_index 使用默认值0
返回值
- 成功：(0,)
- 失败：其它
代码示例

# 伺服控制 - 关节空间
ret_val = rc.edg_servo_j(
    joint_pos=(0.0, -0.5, 1.0, 0.0, -0.5, 0.5),  # 六个关节角度
    move_mode=1,      # 控制模式（如：伺服）
    step_num=50,      # 插值步数
    robot_index=0     # 机器人编号
)
print("edg_servo_j 返回值：", ret_val)

机械臂EDG笛卡尔空间伺服模式运动

机械臂EDG笛卡尔空间位置控制模式

edg_servo_p(end_pos,move_mode,step_num,robot_index)

参数说明
- cartesian_pose 机械臂笛卡尔空间运动目标位置
- move_mode 指定运动模式：0代表绝对运动，1代表增量运动
- step_num 倍分周期，edg_servo_p运动周期为step_num*8ms，其中step_num>=1
- robot_index 使用默认值0
返回值
- 成功：(0,)
- 失败：其它
代码示例

# 伺服控制 - 笛卡尔空间
ret_val = rc.edg_servo_p(
    end_pos=(500.0, 200.0, 300.0, 0.0, 3.14, 0.0),  # X, Y, Z, RX, RY, RZ
    move_mode=1,        # 运动模式
    step_num=50,        # 插值步数
    robot_index=0       # 机器人编号
)
print("edg_servo_p 返回值：", ret_val)

使用App脚本程序

加载指定的作业程序

program_load(file_name)

参数说明
- file_name：程序名称，传入的名称是一个字符串，比如 “file_name”
返回值
- 成功：(0,)
- 失败：其它

获取已加载的作业程序名称

get_loaded_program()

返回值
- 成功：(0, file_name)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc
robot = jkrc.RC("192.168.220.1564")#返回一个机器人对象
robot.login()  #登录
ret = robot.program_load("program_test")#加载通过App编写的脚本 program_test需要自己编写
ret = robot.get_loaded_program()  
print("the loaded program is:",ret[1])
robot.logout() #登出

获取当前机器人作业程序的执行行号

get_current_line()

返回值
- 成功：(0, curr_line), curr_line: 当前行号查询结果。
- 失败：其它

运行当前加载的作业程序

program_run()

返回值
- 成功：(0,)
- 失败：其它

暂停当前运行的作业程序

program_pause()

返回值
- 成功：(0,)
- 失败：其它

继续运行当前暂停的作业程序

program_resume()

返回值
- 成功：(0,)
- 失败：其它

终止当前执行的作业程序

program_abort()

返回值
- 成功：(0,)
- 失败：其它

获取机器人作业程序执行状态

get_program_state()

返回值
- 成功：(0, state)，state的值有三种可能分别是0、1、2
  - 0代表程序停止运行
  - 1代表程序正在运行
  - 2代表程序暂停
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import time
import jkrc
import threading

stop_flag = threading.Event()

def print_state(name, robot):
    while not stop_flag.is_set():
        ret = robot.get_program_state()
        print("the robot program state is:", ret[1])
        time.sleep(1)

robot = jkrc.RC("192.168.220.156")
robot.login()
ret = robot.program_load("program_test")
ret = robot.get_loaded_program()    
print("the loaded program is:", ret[1])
robot.program_run()

t = threading.Thread(target=print_state, args=("p1_state", robot))
t.start()  # 普通子线程，不设置 daemon

time.sleep(2)
robot.program_pause()
time.sleep(2)
robot.program_resume()
time.sleep(2)
robot.program_abort()
time.sleep(3)

# 通知子线程退出并等待
stop_flag.set()
t.join()

robot.logout()

获取机械臂作业程序的信息

获取机械臂作业程序信息

get_program_info()

返回值
- 成功：(0, logic_line, motion_line, file, program_state)
  - logic_line 程序脚本执行行号
  - motion_line 正在执行的运动CMD id
  - file 当前程序文件
  - program_state 程序执行状态
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import time
import jkrc
import threading

stop_flag = threading.Event()

def print_state(name, robot):
    while not stop_flag.is_set():
        ret = robot.get_program_info()
        print("the robot program info is:", ret)
        time.sleep(1)

robot = jkrc.RC("192.168.220.157")
robot.login()
ret = robot.program_load("program_test")
ret = robot.get_loaded_program()    
print("the loaded program is:", ret[1])
robot.program_run()

t = threading.Thread(target=print_state, args=("p1_state", robot))
t.start()  # 普通子线程，不设置 daemon

time.sleep(2)
robot.program_pause()
time.sleep(2)
robot.program_resume()
time.sleep(2)
robot.program_abort()
time.sleep(3)

# 通知子线程退出并等待
stop_flag.set()
t.join()

robot.logout()
import time
import jkrc
import threading

stop_flag = threading.Event()

def print_state(name, robot):
    while not stop_flag.is_set():
        ret = robot.get_program_info()
        print("the robot program info is:", ret)
        time.sleep(1)

robot = jkrc.RC("192.168.220.157")
robot.login()
ret = robot.program_load("program_test")
ret = robot.get_loaded_program()    
print("the loaded program is:", ret[1])
robot.program_run()

t = threading.Thread(target=print_state, args=("p1_state", robot))
t.start()  # 普通子线程，不设置 daemon

time.sleep(2)
robot.program_pause()
time.sleep(2)
robot.program_resume()
time.sleep(2)
robot.program_abort()
time.sleep(3)

# 通知子线程退出并等待
stop_flag.set()
t.join()

robot.logout()

设置机器人运行速度倍率

set_rapidrate(rapid_rate)

参数说明
- rapid_rate：机器人运行速度倍率
返回值
- 成功：(0,)
- 失败：其它

获取机器人运行速度倍率

get_rapidrate()

返回值
- 成功：(0, rapidrate)，rapidrate是速度倍率，返回值是0到1之间的闭区间
- 失败：其它

轨迹复现

设置轨迹复现配置参数

设置轨迹复现配置参数，可设置空间位置采集精度，姿态采集精度，执行脚本运行速度，执行脚本运行加速度。

set_traj_config(xyz_interval, rpy_interval, vel, acc)

参数说明
- xyz_interval：轨迹复现的坐标精度
- rpy_interval：轨迹复现的姿态精度
- vel：轨迹复现的运行速度
- acc：轨迹复现的运行加速度
返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc  
import time  
  
#坐标系  
COORD_BASE  = 0  
COORD_JOINT = 1  
COORD_TOOL  = 2  
#运动模式  
ABS = 0  
INCR= 1  
  
robot = jkrc.RC("192.168.2.160")  
robot.login()  
robot.power_on()  
robot.enable_robot()  
robot.joint_move(joint_pos =[1,1,1,1,1,1] ,move_mode = 0 ,is_block = True ,speed = 10 )  
print("joint")  
robot.set_traj_config([0.1, 0.1, 25, 100]) #设置轨迹复现参数，仅录制过程有效  
time.sleep(0.1)  
ret = robot.get_traj_config()#获取轨迹复现参数  
print("traj_config:")  
print(ret)  
robot.set_traj_sample_mode(True, 'pythonTrack')#开启轨迹复现采集  
time.sleep(0.1)  
robot.joint_move(joint_pos =[-1,1,1,1,1,1] ,move_mode = 0 ,is_block = True ,speed = 30*3.14/180 )#阻塞运动  
robot.joint_move(joint_pos =[1,1,1,1,1,1] ,move_mode = 0 ,is_block = True ,speed = 30*3.14/180 )  
# robot.jog(2,INCR,COORD_BASE,10,-2)  
# robot.jog(2,INCR,COORD_BASE,10,2)  
robot.set_traj_sample_mode(False, 'pythonTrack')#结束轨迹复现采集  
time.sleep(1)  
res = robot.generate_traj_exe_file('pythonTrack')#将采集到的轨迹复现文件转化为可执行脚本  
print(res)  
robot.program_load("track/pythonTrack")#加载轨迹程序  
time.sleep(0.1)  
robot.program_run()

获取轨迹复现配置参数

获取轨迹复现配置参数，可获得空间位置采集精度，姿态采集精度，执行脚本运行速度，执行脚本运行加速度。

get_traj_config()

返回值
- 成功：(0 , ( xyz_interval, rpy_interval, vel, acc))
  - xyz_interval：空间位置采集速度
  - rpy_interval：姿态采集精度
  - vel：执行脚本运行速度
  - acc：执行脚本运行加速度
- 失败：其它

采集轨迹复现数据控制开关

set_traj_sample_mode(mode, filename)

参数说明
- mode：控制模式，True代表开始采集数据，False代表结束数据采集。
- filename：数据的存储文件名。
返回值
- 成功：(0,)
- 失败：其它

采集轨迹复现数据状态查询

提示：

在数据采集状态时，不允许再次开启数据采集开关。

get_traj_sample_status()

返回值
- 成功：(0, sample_status)，sample_status：数据状态，True代表正在采集数据，False代表数据采集结束。
- 失败：其它

查询控制器中已存在的轨迹复现数据文件名

该接口已废弃

get_exist_traj_file_name ()

返回值
- 成功：(0,)
- 失败：其它

重命名轨迹复现数据的文件名

该接口已废弃

rename_traj_file_name (src, dest)

参数说明
- src：源文件名
- dest：目标文件名，文件名长度不能超过100个字符，不能为空，目标文件名不支持中文。
返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc                               #导入模块  
robot = jkrc.RC("192.168.2.226")      #返回一个机器人对象  
robot.login()  
robot.rename_traj_file_name('/home/src', '/home/dst')  
robot.logout() #登出

删除控制器中轨迹复现数据的文件

该接口已废弃

remove_traj_file(filename)

参数说明
- filename：所要删除的文件名
返回值
- 成功：(0, )
- 失败：其它
代码示例

import jkrc                           #导入模块  
robot = jkrc.RC("192.168.2.226")  #返回一个机器人对象  
robot.login()  
robot.remove_traj_file('test')  
robot.logout() #登出

控制器中轨迹复现数据文件生成控制器执行脚本

generate_traj_exe_file(filename)

参数说明
- filename：数据的文件名
返回值
- 成功：(0, )
- 失败：其它

机器人运动学

求机器人逆解

计算指定位姿在当前工具、当前安装角度以及当前用户坐标系设置下的逆解。

kine_inverse(ref_pos, cartesian_pose)

参数说明
- ref_pos：关节空间参考位置，建议选用机器人当前关节位置。
- cartesian_pose：笛卡尔空间位姿计算结果。
返回值
- 成功：(0 , joint_pos) joint_pos是一个包含6位元素的元组 (j1, j2, j3, j4, j5, j6)，j1, j2, j3, j4, j5, j6分别代表关节1到关节6的角度值
- 失败：其它

求机器人逆解拓展

计算指定位姿在指定工具、当前安装角度以及指定用户坐标系设置下的逆解。

kine_inverse_extend(ref_pos, cartesian_pose, tool, userFrame)

参数说明
- ref_pos：关节空间参考位置，建议选用机器人当前关节位置。
- cartesian_pose：笛卡尔空间位姿计算结果。
- tool 指定的工具坐标系
- userFrame 指定的用户坐标系
返回值
- 成功：(0 , joint_pos) joint_pos是一个包含6位元素的元组 (j1, j2, j3, j4, j5, j6)，j1, j2, j3, j4, j5, j6分别代表关节1到关节6的角度值
- 失败：其它

求机器人正解

计算指定关节位置在当前工具、当前安装角度以及当前用户坐标系设置下的位姿值。

kine_forward(joint_pos)

参数说明
- joint_pos：关节空间位置
返回值
- 成功：(0, cartesian_pose)，cartesian_pose是一个包含6位元素的元组(x, y, z, rx, ry, rz)， x, y, z, rx, ry, rz 代表机器人工具末端的位姿值
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc  

robot = jkrc.RC("192.168.220.158") #返回一个机器人对象  
robot.login()                   #登录  
ret = robot.get_joint_position()  
if ret[0] == 0:  
    print("the joint position is :",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])       
joint_pos = ret[1]      
ret = robot.kine_forward(joint_pos)   #求机器人正解
if ret[0] == 0:  
    print("kine_forward success, result = :",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])               
robot.logout()  #登出

求机器人正解拓展

计算指定关节位置在指定工具、当前安装角度以及指定用户坐标系设置下的位姿值。

kine_forward_extend(joint_pos, tool, userFrame)

参数说明
- joint_pos：关节空间位置
- tool 指定的工具坐标系
- userFrame 指定的用户坐标系
返回值
- 成功：(0, cartesian_pose)，cartesian_pose是一个包含6位元素的元组(x, y, z, rx, ry, rz)， x, y, z, rx, ry, rz 代表机器人工具末端的位姿值
- 失败：其它

欧拉角到旋转矩阵的转换

rpy_to_rot_matrix(rpy = [rx,ry,rz])

参数说明
- rpy：待转换的欧拉角数据[rx,ry,rz]
返回值
- 成功：(0, rot_matrix)，rot_matrix是一个3x3的旋转矩阵（行优先排列）
- 失败：其它

旋转矩阵到欧拉角的转换

rot_matrix_to_rpy(rot_matrix)

参数说明
- rot_matrix: 转换的旋转矩阵数据
返回值
- 成功：(0, rpy), rpy是长度为3的欧拉角元组(rx,ry,rz)
- 失败：其它

四元数到旋转矩阵的转换

quaternion_to_rot_matrix(quaternion = [w,x,y,z])

参数说明
- quaternion：待转换的四元数数据
返回值
- 成功：(0, rot_matrix)，rot_matrix是一个3x3的旋转矩阵
- 失败：其它

旋转矩阵到四元数的转换

rot_matrix_to_quaternion(rot_matrix)

参数说明
- rot_matrix：3x3的旋转矩阵
返回值
- 成功：(0, quaternion)，quaternion是长度为4的四元数元组(w,x,y,z)
- 失败：其它
代码示例

import jkrc  
robot = jkrc.RC("192.168.2.160")  
robot.login()  
ret = robot.get_tcp_position()  
print(ret)  
rpy = [ret[1][3], ret[1][4], ret[1][5]]#获取rpy  
ret = robot.rpy_to_rot_matrix(rpy)#rpy转换成旋转矩阵  
print(ret)  
rot_matrix = ret[1]#获取旋转矩阵  
ret = robot.rot_matrix_to_rpy(rot_matrix)#旋转矩阵转换成rpy  
print(ret)  
ret = robot.rot_matrix_to_quaternion(rot_matrix)#旋转矩阵转换成四元数  
print(ret)  
quaternion = ret[1]  
ret = robot.quaternion_to_rot_matrix(quaternion)#旋转矩阵转换成四元数  
print(ret)  
robot.logout()

获取当前连接机械臂的DH参数

获取机械臂DH参数

get_dh_param()

返回值
- 成功：(0, dhparam)，dhparam是DH参数
- 失败：其它
代码示例

# -*- coding: utf-8 -*-  
import jkrc  

robot = jkrc.RC("192.168.220.158") #返回一个机器人对象  
robot.login()                   #登录   
ret = robot.get_dh_param()
if ret[0] == 0:  
    print("get_dh_param success, result is: ",ret[1])  
else:  
    print("some things happend,the errcode is: ",ret[0])               
robot.logout()  #登出

机器人伺服运动

提示：

当用户使用这个接口的时候需要先调用servo_move_enable(True)，进入位置控制模式。
这条指令一般是高校科研当中做轨迹规划时使用。
当用户使用此模式控制机器人的运动的时候，控制器的规划器不参与运动的插补，位置指令会直接发给伺服，所以用户需要自己进行轨迹规划，否则机器人的运动效果会比较差，如抖动剧烈等现象，无法达到用户的预期。
由于控制器的控制周期为8ms，建议用户的发送周期也为8ms，并且需要连续发送，只发一次没有效果。如果网络状况较差，发送周期可以小于8ms。
JAKA机器人的关节速度上限是180度/秒。如果发送的关节角度使关节速度超过了此上限，这条指令就会失效。比如发送的关节角度是1.5,0.5,0.5,0.5,0.5,0.5，发送周期是8ms，那么1.5/0.008= 187.5 度/秒，超过了关节速度上限。那么指令将会失效。
使用完这条指令，需要使用servo_move_enable(False)，退出位置控制模式。
这条指令和前文提到的joint_move()区别较大，joint_move的插补是由控制器进行的，用户无需关心。用户使用servo_j指令时需要预先进行轨迹规划，否则使用效果会很差，无法达到预期。若无特殊需要，机器人在关节空间的运动建议使用joint_move，而不是servo_j。

查询机械臂是否处于伺服运动状态

is_in_servomove()

返回值
- 成功：(0,in_servo)，in_servo 为1代表机器人处于伺服运动模式，0则相反
- 失败：其它

机器人servo move模式使能

servo_move_enable(enable|is_block, robot_id)

参数说明
- enable：TRUE为进入SERVO MOVE模式，FALSE表示退出该模式
- is_block：TRUE为阻塞模式，FALSE为非阻塞模式，默认值为TRUE(可选参数)
- robot_id：机械臂ID，默认值为 0(可选参数)
返回值
- 成功：(0,)
- 失败：其它

机器人关节空间伺服模式运动

servo_j(joint_pos, move_mode|step_num, do_info, robot_id)

参数说明
- joint_pos：机器人关节运动目标位置。
- move_mode：指定运动模式。0为绝对运动，1为增量运动。
- step_num：倍分周期，servo_j运动周期为step_num*8ms，其中step_num>=1，默认值为1(可选参数)
- do_info：指定DO信息，默认值为nullptr(可选参数)
- robot_id：机械臂ID，默认值为0(可选参数)
返回值
- 成功：(0,queue_num), queue_num返回控制器的队列长度（不能超过100）
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc
import time
import math

ABS = 0
Enable = True

robot = jkrc.RC("192.168.220.158")
robot.login()
robot.power_on()
robot.enable_robot()
robot.servo_move_enable(Enable, False) #非阻塞模式开启伺服运动模式

print("servo mode enabled")

target_joint = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
do_info = [0, 0, 1]
step_num = 1

# ===== 运动参数 =====
amp_deg = 10.0
amp = math.radians(amp_deg)
freq = 0.2                 # Hz
dt = 0.008                 # 8 ms → 125 Hz

t = 0.0

try:
    while True:
        ret = robot.servo_j(target_joint, ABS, step_num, do_info)

        if ret[0] != 0:
            print("servo_j error:", ret)
            break

        queue_len = ret[1]
        print("queue_len =", queue_len)

        # === 队列限流 ===
        if queue_len > 10:
            time.sleep(0.01)
            continue

        # === 生成往复轨迹 ===
        target_joint[0] = amp * math.sin(2 * math.pi * freq * t)
        t += dt

except KeyboardInterrupt:
    print("Interrupted by user")

finally:
    robot.servo_move_enable(False, False)
    robot.logout()
    print("servo mode disabled")

机器人笛卡尔空间伺服模式运动

servo_p(cartesian_pose, move_mode|step_num, do_info, robot_id)

参数说明
- cartesian_pose：机器人笛卡尔空间运动目标位置。
- move_mode：指定运动模式，0为绝对运动，1为增量运动。
- step_num：倍分周期，servo_j运动周期为step_num*8ms，其中step_num>=1，默认值为1(可选参数)
- do_info：指定DO信息，默认值为nullptr(可选参数)
- robot_id：机械臂ID，默认值为0(可选参数)
返回值
- 成功：(0,queue_num), queue_num返回控制器的队列长度（不能超过100）
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc
import time
import math

ABS = 0
Enable = True

robot = jkrc.RC("192.168.220.158")
robot.login()
robot.power_on()
robot.enable_robot()

start_joint = [0.0, -0.5, 1.2, 0.0, 1.0, 0.0]
robot.joint_move(start_joint, ABS, True, 0.5)

robot.servo_move_enable(Enable, True) #阻塞模式开启伺服运动模式

print("servo_p mode enabled")

# ===== 读取当前 TCP 位姿作为基准 =====
ret = robot.get_tcp_position()
if ret[0] != 0:
    raise RuntimeError("get_tcp_position failed")

base_pose = list(ret[1])   # [x, y, z, rx, ry, rz]

print("base_pose:", base_pose)

# ===== 伺服参数 =====
do_info = [0, 0, 1]
step_num = 1

amp_mm = 8.0              # 平移幅度
amp_rot = 0.02            # 姿态扰动
freq = 0.2                # Hz
dt = 0.008                # 8 ms

t = 0.0

try:
    while True:
        # === 生成笛卡尔往复轨迹 ===
        pose = base_pose.copy()
        # ---- 平移：X 方向往复 ----
        pose[0] = base_pose[0] + amp_mm * math.sin(2 * math.pi * freq * t)

        # ---- 姿态微扰：绕 Z 轴----
        pose[5] = base_pose[5] + amp_rot * math.sin(2 * math.pi * freq * t)

        # === 发送 servo_p ===
        t_start = time.perf_counter()
        ret = robot.servo_p(pose, ABS, step_num, do_info)
        t_end = time.perf_counter()
        servo_cost_ms = (t_end - t_start) * 1000.0
        print("servo_p cost: %.2f ms" % servo_cost_ms)
        if ret[0] != 0:
            print("servo_p error:", ret)
            break

        t += dt

except KeyboardInterrupt:
    print("Interrupted by user")

finally:
    robot.servo_move_enable(False)
    robot.logout()
    print("servo mode disabled")

机器人servo模式下禁用滤波器

机器人SERVO模式下禁用滤波器，该指令在SERVO模式下不可设置，退出SERVO后可设置。

servo_move_use_none_filter()

返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc                           #导入模块  
robot = jkrc.RC("192.168.220.158")  #返回一个机器人对象  
robot.login()  
robot.servo_move_use_none_filter()  
robot.logout() #登出

机器人servo模式下关节空间一阶低通滤波

机器人SERVO模式下关节空间一阶低通滤波，该指令在SERVO模式下不可设置，退出SERVO后可设置。

servo_move_use_joint_LPF(cutoffFreq)

参数说明
- cutoffFreq：一阶低通滤波器截止频率。
返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc                           #导入模块  
robot = jkrc.RC("192.168.2.226")  #返回一个机器人对象  
robot.login()  
robot.servo_move_use_joint_LPF(0.5)  
robot.logout() #登出

机器人servo模式下关节空间非线性滤波

机器人SERVO模式下关节空间非线性滤波，该指令在SERVO模式下不可设置，退出SERVO后可设置。

servo_move_use_joint_NLF(max_vr, max_ar, max_jr)

参数说明
- max_vr：笛卡尔空间姿态变化速度的速度上限值（绝对值）°/s
- max_ar：笛卡尔空间姿态变化速度的加速度上限值（绝对值）°/s^2
- max_jr：笛卡尔空间姿态变化速度的加加速度上限值（绝对值）°/s^3
代码示例

import jkrc                           #导入模块  
robot = jkrc.RC("192.168.2.226")  #返回一个机器人对象  
robot.login()  
robot.servo_move_use_joint_NLF(max_vr=2, max_ar=2, max_jr=4)  
robot.logout() #登出

机器人servo模式下笛卡尔空间非线性滤波

机器人SERVO模式下笛卡尔空间非线性滤波，该指令在SERVO模式下不可设置，退出SERVO后可设置。

servo_move_use_carte_NLF(max_vp, max_ap, max_jp, max_vr, max_ar, max_jr|ori_quat)

参数说明
- max_vp：笛卡尔空间下移动指令速度的上限值（绝对值）mm/s
- max_ap：笛卡尔空间下移动指令加速度的上限值（绝对值）mm/s^2
- max_jp：笛卡尔空间下移动指令加加速度的上限值（绝对值）mm/s^3
- max_vr：笛卡尔空间姿态变化速度的速度上限值（绝对值）°/s
- max_ar：笛卡尔空间姿态变化速度的加速度上限值（绝对值）°/s^2
- max_jr：笛卡尔空间姿态变化速度的加加速度上限值（绝对值）°/s^3
- ori_quat：指定描述笛卡尔空间姿态的表示方式。0表示使用欧拉角描述，1表示使用四元数描述。默认为0（可选参数）
返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc                           #导入模块  
robot = jkrc.RC("192.168.2.226")  #返回一个机器人对象  
robot.login()  
robot.servo_move_use_carte_NLF(max_vp=2, max_ap=2, max_jp=4,max_vr=2, max_ar=2, max_jr=4)  
robot.logout() #登出

机器人servo模式下关节空间多阶均值滤波

机器人SERVO模式下关节空间多阶均值滤波，该指令在SERVO模式下不可设置，退出SERVO后可设置。

servo_move_use_joint_MMF(max_buf, kp, kv, ka)

参数说明
- max_buf: 均值滤波器缓冲区的大小。
- kp：加速度滤波系数。
- kv：速度滤波系数
- ka：位置滤波系数
返回值
- 成功：(0,)
- 失败：其它
代码示例

import jkrc                           #导入模块  
robot = jkrc.RC("192.168.2.226")  #返回一个机器人对象  
robot.login()  
robot.servo_move_use_joint_MMF(max_buf=20 , kp=0.2 , kv=0.4 ,ka=0.2)  
robot.logout() #登出

Servo模式下速度前瞻参数设置

SERVO模式下速度前瞻滤波器,该指令在SERVO模式下不可设置，退出SERVO后可设置

servo_speed_foresight(max_buf, kp|ori_quat)

参数说明
- max_buf: 均值滤波器缓冲区的大小。
- kp：加速度滤波系数。
- ori_quat：指定描述笛卡尔空间姿态的表示方式。0表示使用欧拉角描述，1表示使用四元数描述。默认为0（可选参数）
返回值
- 成功：(0,)
- 失败：其它

Servo模式下关节空间PCM滤波设置

SERVO模式下关节空间PCM滤波器,该指令在SERVO模式下不可设置，退出SERVO后可设置

servo_move_use_joint_PCM(max_buf, kp)

参数说明
- max_buf: 均值滤波器缓冲区的大小。
- kp：加速度滤波系数。
返回值
- 成功：(0,)
- 失败：其它

Servo模式下笛卡尔空间PCM滤波设置

SERVO模式下笛卡尔空间PCM滤波器,该指令在SERVO模式下不可设置，退出SERVO后可设置

servo_move_use_carte_PCM(max_buf, kp)

参数说明
- max_buf: 均值滤波器缓冲区的大小。
- kp：加速度滤波系数。
返回值
- 成功：(0,)
- 失败：其它

机器人力控接口

JAKA机器人提供了一套基于末端力传感器的力控接口，用户可以基于这些接口完成高级的力控功能如恒力柔顺控制等，进而实现一些较复杂的应用场景，如笛卡尔空间指定方向拖拽、力控装配、打磨等。

但需要注意的是，这些接口依赖于末端力传感器。

本节内容建议在完成阅读力控产品使用手册open in new window的基础上阅读，并参考节卡SDK力控功能快速入门指南open in new window配合理解。为避免文字冗长，本节中“力控”都代表“力柔顺控制”，“末端力传感器”、“力传感器”、“传感器”都代表安装于机器人末端的6维或1维力/力矩传感器。

设置末端力传感器型号

设置传感器型号，输入数字代表对应的传感器型号。

set_torsensor_brand(sensor_brand)

参数说明
- sensor_brand 传感器型号，取值范围为1-6或10，需要与传感器硬件外壳铭刻的型号数字相匹配。其中10特指已经内置与机器人法兰内部的传感器，此型传感器由系统自动管理，无需调用此接口进行配置
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc                       #导入模块  
robot = jkrc.RC("192.168.220.158")  #返回一个机器人对象  
robot.login()  
ret = robot.set_torsenosr_brand(2)
if ret[0] == 0:  
    print("set_torsenosr_brand success")  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout() #登出

获取末端力传感器型号

get_torsensor_brand()

返回值
- 成功：(0, sensor_brand)，sensor_brand: 传感器型号。
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc                       #导入模块  
robot = jkrc.RC("192.168.220.158")  #返回一个机器人对象  
robot.login()  
ret=robot.get_torsenosr_brand()  
if ret[0] == 0:  
    print("the sensor_band is", ret[1]) 
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout() #登出

开启或关闭末端力传感器

set_torque_sensor_mode(sensor_mode)

参数说明
- sensor_mode：传感器工作模式，0代表关闭传感器，1代表开启传感器。
返回值
- 成功：(0,)
- 失败：其它

设置传感器末端负载

设置传感器末端负载，输入为负载质量，负载质心位置坐标。

注意：请仔细区分set_torq_sensor_tool_payload和set_payload的区别。

payload影响的是机械臂的动力学；

tool_payload影响的是力控效果（即力控时机械臂的力、力矩补偿）

注意末端法兰已内置传感器的机械臂型号（如S系列），传感器末端负载与机械臂负载无区别，在这种情况下它们对应的两个设置和查询接口是等价的

set_torq_sensor_tool_payload (mass, centroid)

参数说明
- mass：负载质量，单位: kg
- centroid：负载质心坐标位置[x, y, z]，单位：mm
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc                       #导入模块  
robot = jkrc.RC("192.168.220.158")  #返回一个机器人对象  
robot.login()  
ret = robot.set_torq_sensor_tool_payload(mass= 1, centroid =[10,10,0])  
if ret[0] == 0:  
    print("set_torq_sensor_tool_payload success") 
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout() #登出

获取传感器末端负载

获取传感器末端负载质量，负载质心位置坐标。

get_torq_sensor_tool_payload ()

返回值
- 成功：(0,(mass, centroid))
  - mass: 负载质量, 单位: kg。
  - centroid: 负载质心位置[x, y, z]，单位: mm。
- 失败：其它

获取末端负载辨识状态

get_torq_sensor_identify_status()

参数说明
- identify_status：辨识状态，0代表辨识完成结果已可以读取，1代表暂无可以读取的辨识结果，2代表辨识失败。
返回值
- 成功：(0,identify_status)
- 失败：其它

开始辨识工具末端负载

开始辨识工具末端负载，输入为一个元组含6个元素，分别对应结束位置6个关节角。注意：这是一条会触发运动的指令，会使机器人运动到joint_pos指定的位置。

start_torq_sensor_payload_identify(joint_pos)

参数说明
- joint_pos：负载辨识终点，关于终点点位设置的注意事项，请参考力控产品使用手册open in new window中对相关功能的说明。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-   
import time        
import jkrc  
PI = 3.1415926  

robot = jkrc.RC("192.168.220.158")#返回一个机器人对象  
ret = robot.login()#登录  
ret = robot.power_on()  
ret = robot.enable_robot()  
robot.set_torsenosr_brand(2)  
robot.set_torque_sensor_mode(1)  
robot.set_compliant_type(1, 1)  
print("inint sensor comple")  
print("ready to run")  
ret = robot.get_joint_position()  
joint_pos_origin = ret[1]  
joint_pos = ret[1]  
print(joint_pos)  
joint_pos[3] += PI / 4  
if (joint_pos[3] > 265 * PI / 180):  
    joint_pos[3] -= 90  
joint_pos[4] += PI / 4  
if (joint_pos[4] > 320 * PI / 180):  
    joint_pos[4] -= 90  
joint_pos[5] += PI / 4  
if (joint_pos[5] > 265 * PI / 180):  
    joint_pos[5] -= PI  
print(joint_pos)  
ret = robot.start_torq_sensor_payload_identify(joint_pos)  
time.sleep(1)  
flag = 1  
while (1 == flag):  
    ret = robot.get_torq_sensor_identify_staus()  
    print(ret)  
    time.sleep(1)  
    flag = ret[1]  
print("identy_finish")  
ret = robot.get_torq_sensor_payload_identify_result()  
print(ret)  
ret = robot.set_torq_sensor_payload()  
print(ret)  
ret = robot.get_torq_sensor_payload_identify_result()  
print(ret)  
robot.joint_move(joint_pos_origin,0,1,10)  
print("back")  
robot.logout()  #登出

获取末端负载辨识结果

获取末端负载辨识结果，输入为负载质量，负载质心位置坐标。

get_torq_sensor_payload_identify_result()

参数说明
- mass：负载质量，单位: kg
- centroid：负载质心位置[x, y, z]，单位: mm
返回值
- 成功：(0,)
- 失败：其它

设置末端力传感器通讯参数

set_torque_sensor_comm(type, ip_addr, port)

参数说明
- type：传感器类型
- ip_addr：传感器ip地址
- port：端口号
- 设置为1或使用USB时ip_addr和port不起作用，给定如示例所示的默认参数即可
返回值
- 成功：(0,)
- 失败：其它

获取末端力传感器通讯参数

get_torque_sensor_comm()

返回值
- 成功：(0, type,ip_addr,port)
  - type： 0为使用网口或USB，1为使用TIO。
  - ip_addr: 使用网口时传感器ip地址。
  - port: 使用网口时力控传感器端口号。
  - 使用TIO或USB时ip_addr和port为无效参数，返回值无实际意义
- 失败：其它

设置末端力传感器低通滤波器截止频率

set_torque_sensor_filter(torque_sensor_filter)

参数说明
- torque_sensor_filter: 低通滤波器参数，浮点数单位：HZ
返回值
- 成功：(0,)
- 失败：其它

获取末端力传感器低通滤波器截止频率

get_torque_sensor_filter()

参数说明
返回值
- 成功：(0,torque_sensor_filter)
  - torque_sensor_filter: 低通滤波器参数，浮点数单位：HZ
- 失败：其它

设置末端力传感器软限位

set_torque_sensor_soft_limit(fx, fy, fz, tx, ty, tz)

参数说明
- fx: 沿着x轴受力，单位：N
- fy: 沿着y轴受力，单位：N
- fz: 沿着z轴受力，单位：N
- tx: 绕着x轴的扭矩，单位：Nm
- ty: 绕着y轴的扭矩，单位：Nm
- tz: 绕着z轴的扭矩，单位：Nm
返回值
- 成功：(0,)
- 失败：其它

获取末端力传感器软限位

get_torque_sensor_soft_limit()

返回值
- 成功：(0,(fx,fy,fz,tx,ty,tz))
  - fx: 沿着x轴受力，单位：N
  - fy: 沿着y轴受力，单位：N
  - fz: 沿着z轴受力，单位：N
  - tx: 绕着x轴的扭矩，单位：Nm
  - ty: 绕着y轴的扭矩，单位：Nm
  - tz: 绕着z轴的扭矩，单位：Nm
- 失败：其它

开启或关闭工具拖拽

兼容性接口保留。

适配1.7.1控制器，1.7.2请使用替代接口。

开启或关闭工具拖拽，需要开启传感器并设置合理的柔顺控制参数，此外，推荐进行至少一次力控传感器校零后再开启工具拖拽。

enable_admittance_ctrl(enable_flag)

1.7.2控制器对应接口为

set_ft_ctrl_mode(enable_flag)

参数说明
- enable_flag：标志，0为关闭力控拖拽使能，1为开启。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-       
import jkrc  

robot = jkrc.RC("192.168.220.158")#返回一个机器人对象  
ret = robot.login()#登录  
ret = robot.power_on()  
ret = robot.enable_robot()  
robot.set_torsenosr_brand(2)  
robot.set_torque_sensor_mode(1)  
robot.set_compliant_type(1, 1)  
print("inint sensor comple")  
print("ready to run")  
#设置柔顺控制参数  
ret = robot.set_admit_ctrl_config(0, 0, 20, 5, 0, 0)  
ret = robot.set_admit_ctrl_config(1, 0, 20, 5, 0, 0)  
ret = robot.set_admit_ctrl_config(2, 1, 20, 10, 0, 0)
ret = robot.set_admit_ctrl_config(3, 0, 20, 5, 0, 0)  
ret = robot.set_admit_ctrl_config(4, 0, 20, 5, 0, 0)  
ret = robot.set_admit_ctrl_config(5, 0, 20, 5, 0, 0)  
#设置力控拖拽使能，1打开，0关闭  
ret = robot.enable_admittance_ctrl(1)  
print("enable_admittance_ctrl open!")  
print("input any word to quit:")  
a = input()  
ret = robot.enable_admittance_ctrl(0)  
ret = robot.set_admit_ctrl_config(2, 0, 20, 5, 0, 0)  
robot.set_torque_sensor_mode(0)  
robot.logout()  #登出

设置力控类型和校零（初始化）选项

兼容性接口保留。

适配1.7.1控制器，1.7.2拆分为多个对应替代接口。1.7.2控制器调用此接口时仅实现触发校零及设置力控类型功能，但需要注意在sensor_compensation给1时compliance_type参数必须给0，且必须等待1秒后才能再次调用此接口设置compliance_type参数。

set_compliant_type(sensor_compensation, compliance_type)

1.7.2控制器传感器校零接口为：

zero_end_sensor()

参数说明
- sensor_compensation：1代表立即进行一次传感器校零，并将APP的实时力曲线显示以及10000端口返回的torqsensor[1][2]切换为实际外力；0代表不做校零操作，并将不处于力控状态下时APP的实时力曲线显示以及10000端口返回的torqsensor[1][2]切换为传感器原始读数（若处于力控状态下则仍为实际外力）。
- compliance_type：0代表不使用任何一种柔顺控制方法，1代表开启恒力柔顺控制，2代表开启速度柔顺控制。
返回值
- 成功：(0,)
- 失败：其它
代码示例

# -*- coding: utf-8 -*-       
import jkrc  
robot = jkrc.RC("192.168.220.158")#返回一个机器人对象  
ret = robot.login()#登录  
ret = robot.set_compliant_type(1,1)
if ret[0] == 0:  
    print("set_compliant_type success")  
else:  
    print("some things happend,the errcode is: ",ret[0])  
robot.logout()  #登出

获取力控类型和读数显示（初始化）状态

兼容性接口保留。

适配1.7.1控制器，1.7.2为对应替代接口。1.7.2控制器调用此接口时仅实现获取力控类型功能，sensor_compensation参数无意义。

获取力控类型和传感器初始化状态

get_compliant_type()

返回值
- 成功：(0, sensor_compensation, compliance_type)
  - sensor_compensation 是否开启传感器补偿，1代表APP的实时力曲线显示以及torq_sensor_monitor_data.actTorque为实际外力；0代表不处于力控状态下时APP的实时力曲线显示以及torq_sensor_monitor_data.actTorque为传感器原始读数（若处于力控状态下则仍为实际外力）。
  - compliance_type 0 代表不使用任何一种柔顺控制方法 1 代表恒力柔顺控制，2 代表速度柔顺控制
- 失败：其它

设置柔顺控制参数

设置机器人柔顺控制时的关节坐标轴编号、柔顺方向、阻尼力、回弹力、恒力、法向跟踪等参数。

set_admit_ctrl_config(axis, opt, ftUser, ftConstant, ftNormalTrack, ftReboundFK)

参数说明
- axis: 代表笛卡尔空间坐标轴编号，取值为：0~5，分别对应fx fy fz mx my mz方向
- opt: 柔顺方向，0代表关闭，1代表启动。
- ftUser：阻尼力，表示用户需使用多大的力让机器人沿着某一方向以最大速度运动。
- ftConstant: 恒力，手动操作时全部设置为0。
- ftNormalTrack：法向跟踪，手动操作时全部设置为0。
- ftReboundFK: 回弹力，表示机器人回到初始状态的能力。
返回值
- 成功：(0,)
- 失败：其它

设置力控坐标系

兼容性接口保留。

适配1.7.1控制器，1.7.2针对不同力控功能拆分为多个对应替代接口。1.7.2控制器调用此接口时将调用全部的替代接口并设置为相同参数。

set_ft_ctrl_frame(ftFrame)

参数说明
- ftFrame: 0 工具； 1 世界
返回值
- 成功：(0,)
- 失败：其它

获取力控坐标系

兼容性接口保留。

适配1.7.1控制器，1.7.2针对不同力控功能拆分为多个对应替代接口。1.7.2控制器调用此接口时将返回恒力柔顺控制功能对应的力控坐标系。

获取力控坐标系

get_ft_ctrl_frame()

返回值
- 成功：(0,ftFrame)
  - ftFrame: 0 工具； 1 世界
- 失败：其它

设置力控柔顺控制参数

兼容性接口保留。

适配1.7.1控制器，1.7.2针对不同力控功能拆分为多个对应替代接口。1.7.2控制器调用此接口时将调用全部的替代接口并设置为相同参数。

获取力控柔顺控制参数，获取6个关节所对应的柔顺方向，阻尼力，回弹力，恒力，法向跟踪。

set_admit_ctrl_config(axis,opt,ftUser,ftReboundFK,ftConstant,ftNnormalTrack)

参数说明
- axis：0，x轴；1，y轴；2，z轴；3，rx；4，ry；5，rz。
- opt：0关，1开。
- ftUser：阻尼，影响机器人末端对外界环境所表现出的刚度。此参数越大，机器人末端表现出的刚度越大。单位为×8N·s/m(对于x/y/z)、×16Nm·s/π(对于rx/ry/rz)
- ftReboundFK：回弹，表示机器人柔顺控制过程中与指令轨迹（或初始位置）之间的弹性系数，单位为N/mm(对于x/y/z)、Nm/rad(对于rx/ry/rz)。
- ftConstant：代表目标力，单位为N(对于x/y/z)、Nm(对于rx/ry/rz)。
- ftNnormalTrack：历史兼容性接口，目前必须全部设置为0以确保正常运作。
- 关于对上述各参数的理解，请进一步参考力控产品使用手册open in new window中的相关说明。
返回值
- 成功：(0,)
- 失败：其它

获取力控柔顺控制参数

兼容性接口保留。

适配1.7.1控制器，1.7.2针对不同力控功能拆分为多个对应替代接口。1.7.2控制器调用此接口时将返回恒力柔顺控制功能对应的柔顺参数。

获取力控柔顺控制参数

get_admit_ctrl_config()

返回值
- 成功：(0, [[opt, ftUser, ftReboundFK, ftConstant, ftNormanlTrack], ……])
  - opt: 0关，1开。
  - ftUser：阻尼力，表示用户需使用多大的力让机器人沿着某一方向以最大速度运动。
  - ftReboundFK: 回弹力，表示机器人回到初始状态的能力。
  - ftConstant: 恒力，手动操作时全部设置为0。
  - ftNormalTrack：法向跟踪，手动操作时全部设置为0。
- 失败：其它

关闭力矩控制

关闭力柔顺控制（对恒力柔顺控制和速度柔顺控制生效，但不对工具拖拽生效）

disable_force_control ()

返回值
- 成功：(0,)
- 失败：其它

设置速度柔顺控制参数

1.7.2为废弃接口，不建议使用

设置速度柔顺控制参数，速度柔顺控制有3个等级，有4个比率等级。

set_vel_compliant_ctrl (level, rate1, rate2, rate3, rate4)

参数说明
- level: 柔顺控制等级, 等级分为：1, 2, 3
  - rate1: 比率等级1
  - rate2: 比率等级2
  - rate3: 比率等级3
  - rate4: 比率等级4

注意：

比率等级之间的关系： 0<rate4<rate3<rate2<rate1<1;

当level=1时，只能设置rate1, rate2, 而rate3, rate4的值全为0
当level=2时，只能设置rate1, rate2, rate3, 而rate4的值为0
当level=3时，能设置rate1, rate2, rate3, rate4的值

返回值
- 成功：(0,)
- 失败：其它

设置柔顺控制力矩条件

1.7.2为废弃接口，不建议使用

set_compliance_condition(fx, fy, fz, tx, ty, tz)

参数说明(以下参数为柔顺控制力矩限制，超过限制值会停止)
- fx: 沿着x轴受力，单位：N
- fy: 沿着y轴受力，单位：N
- fz: 沿着z轴受力，单位：N
- tx: 绕着x轴的扭矩，单位：Nm
- ty: 绕着y轴的扭矩，单位：Nm
- tz: 绕着z轴的扭矩，单位：Nm
返回值
- 成功：(0,)
- 失败：其它

注：

以下接口仅用于1.7.2及以上版本控制器，1.7.2及以上版本控制器请优先使用这些接口。

传感器校零

触发传感器校零，并且阻塞0.5秒。

zero_end_sensor()

返回值
- 成功：(0,)
- 失败：其它

传感器硬件级标定

触发传感器硬件级标定，用于提升传感器数值精度。

tio_sensor_calib(type)

参数说明
- type: 0：无作用。1：进行标定。2：查询当前标定数值。
返回值
- 成功：(0,)
- 失败：其它

注意

此指令不会立即生效，而是在重启机器人控制柜后，第一次上电时以当前传感器的状态进行标定。标定过程可能需要5-10秒，请注意下发此指令后，下一次重启上电后等待5-10秒再上使能以保证最好的标定效果。

此指令仅在需要进行极限的传感器数值精度提升时使用，不正确使用可能造成传感器零点偏离过大导致意外情况，不建议经常或反复进行标定，一般的传感器数值标定建议通过传感器校零接口进行软件调零。

此指令生效后，请务必记录开机后在APP上弹出的当前标定结果，并确保后续使用过程中的实际受力与此标定结果的和不超过传感器的量程。

获取传感器运行状态

get_torque_sensor_mode()

返回值
- 成功：(0,sensor_mode)
  - sensor_mode: 传感器处于开启或关闭状态，0为关闭；1为开启
- 失败：其它

获取传感器状态和数据

get_torque_sensor_data(type)

参数说明
- type: 获取数据的类型，1：与torq_sensor_monitor_data.actTorque相同；2：与torq_sensor_monitor_data.torque相同，传感器原始读数；3：与torq_sensor_monitor_data.realTorque相同，减去负载重力补偿和传感器偏置后的实际受力；
返回值
- 成功：(0,(errorCode, status, data))
  - errorCode: 错误码
  - status: 状态
  - data: 数据
- 失败：其它

设置恒力柔顺控制参数

set_ft_ctrl_config(type)

参数说明
- type: 获取数据的类型，1：与torq_sensor_monitor_data.actTorque相同；2：与torq_sensor_monitor_data.torque相同，传感器原始读数；3：与torq_sensor_monitor_data.realTorque相同，减去负载重力补偿和传感器偏置后的实际受力；
返回值
- 成功：(0,(errorCode, status, data))
  - errorCode: 错误码
  - status: 状态
  - data: 数据
- 失败：其它

获取力控工具拖拽开启状态

get_tool_drive_state()

返回值
- 成功：(0,enable_flag, drive_state)
  - enable_flag: 0 为关闭力控拖拽使能，1 为开启
  - drive_stat是拖拽的当前状态是否触发奇异点、速度、关节限位预警
- 失败：其它

获取工具拖拽坐标系

get_tool_drive_frame()

返回值
- 成功：(0,ftFrame)
  - ftFrame: 0 工具； 1 世界
- 失败：其它

设置工具拖拽坐标系

set_tool_drive_frame(ftFrame)

参数说明
- ftFrame: 0 工具； 1 世界
返回值
- 成功：(0,)
- 失败：其它

获取融合拖拽灵敏度

get_fusion_drive_sensitivity_level()

返回值
- 成功：(0,level)
  - level: 灵敏度等级，值0-5，0为关
- 失败：其它

设置融合拖拽灵敏度

set_fusion_drive_sensitivity_level(level)

参数说明
- level: 灵敏度等级，值0-5，0为关
返回值
- 成功：(0,)
- 失败：其它

获取运动限制（奇异点和关节限位）预警范围

get_motion_limit_warning_range(warningRange)

返回值
- 成功：(0,warningRange) warningRange: 预警范围
- 失败：其它

设置运动限制（奇异点和关节限位）预警范围

set_motion_limit_warning_range(warningRange)

参数说明
- warningRange: 预警范围
返回值
- 成功：(0,)
- 失败：其它

获取力控限速

get_compliant_speed_limit(vel，angularvel)

返回值
- 成功：(0,vel,angularvel)
  - vel: 线速度限制，mm/s:
  - angularvel: 角速度限制， rad/s
- 失败：其它

设置力控限速

set_compliant_speed_limit(vel，angularvel)

参数说明
- vel: 线速度限制，mm/s:
- angularvel: 角速度限制， rad/s
返回值
- 成功：(0,)
- 失败：其它

获取力矩参考中心

get_torque_ref_point()

返回值
- 成功：(0,refpoint)
  - refpoint: 0: 传感器中心； 1: TCP中心
- 失败：其它

设置力矩参考中心

set_torque_ref_point(refpoint)

参数说明
- refpoint: 0: 传感器中心。 1: TCP中心
返回值
- 成功：(0,)
- 失败：其它

获取传感器灵敏度

get_end_sensor_sensitivity_threshold ()

返回值
- 成功：(0,data)
  - fx: 沿着x轴受力，单位：N
  - fy: 沿着y轴受力，单位：N
  - fz: 沿着z轴受力，单位：N
  - tx: 绕着x轴的扭矩，单位：Nm
  - ty: 绕着y轴的扭矩，单位：Nm
  - tz: 绕着z轴的扭矩，单位：Nm
- 失败：其它

设置传感器灵敏度

set_end_sensor_sensitivity_threshold (fx, fy, fz, tx, ty, tz)

参数说明
- fx: 沿着x轴受力，单位：N
- fy: 沿着y轴受力，单位：N
- fz: 沿着z轴受力，单位：N
- tx: 绕着x轴的扭矩，单位：Nm
- ty: 绕着y轴的扭矩，单位：Nm
- tz: 绕着z轴的扭矩，单位：Nm
- 6维数组，0~1，越大传感器越不灵敏
返回值
- 成功：(0,data)
- 失败：其它

设置恒力柔顺控制参数

设置恒力柔顺控制参数，与原先set_admit_ctrl_config功能一致，仅入参删除ftNnormalTrack

参数说明
- axis 代表配置哪一轴，可选值为 0~5 柔顺方向，分别对应 fx fy fz mx my mz
- opt 0 代表没有勾选，非 0 值代表勾选
- ftDamping 阻尼力，表示机器人在力控过程中的硬度
- ftConstant 代表目标力
- ftReboundFK 回弹，表示机械臂向指令轨迹弹性回复的力度
返回值成功：(0,) 失败: 其它

set_cst_force_ctrl_config(axis, opt, ftDamping, ftConstant, ftReboundFK)

获取恒力柔顺控制参数

获取恒力柔顺控制参数，与原get_admit_ctrl_config一致

返回值
- 成功：(0, ((0.0, 50.0, 0.0, 0.0, 0.0), (0.0, 50.0, 0.0, 0.0, 0.0), (1.0, 25.0, 0.0, 5.0, 0.0), (0.0, 5.0, 0.0, 0.0, 0.0), (0.0, 5.0, 0.0, 0.0, 0.0), (0.0, 5.0, 0.0, 0.0, 0.0)))
  - 参数说明: 返回的是六个5维数组，分别代表六个轴对应的数据，每个数组的5个元素含义参考上一个接口说明。
- 失败: 其它

get_cst_force_ctrl_config()

设置恒力柔顺控制坐标系

设置恒力柔顺控制坐标系，调用控制器内部新接口

参数说明
- cstForceFrame 0工具 1世界
返回值成功：(0,) 失败: 其它

set_cst_force_ctrl_frame(cstForceFrame)

获取恒力柔顺控制坐标系

获取恒力柔顺控制坐标系，调用控制器内部新接口

返回值
成功：(0,cstForceFrame) * cstForceFrame 0工具 1世界失败: 其它

get_cst_force_ctrl_frame()

设置力控拖拽手感参数

设置力控拖拽手感参数，调用控制器内部对应接口

参数说明
- axis 代表配置哪一轴，可选值为 0~5 柔顺方向，分别对应 fx fy fz mx my mz
- opt 0 代表没有勾选，非 0 值代表勾选
- rigidity 拖拽手感，范围0~1，越大越硬
- rebound 回弹，表示机械臂向初始位置弹性回复的力度
返回值成功：(0,) 失败: 其它

set_tool_drive_config(axis, opt,rigidity, rebound)

获取工具拖拽参数

获取工具拖拽参数，调用控制器内部新接口

参数说明
- admit_ctrl_cfg 机械臂力控柔顺控制参数存储地址
返回值成功：

(0, ((0, 1, 0.0, 0.30000001192092896, <NULL>), (1, 1, 0.0, 0.30000001192092896, <NULL>), (2, 1, 0.0, 0.30000001192092896, <NULL>), (3, 1, 0.0, 0.30000001192092896, <NULL>), (4, 1, 0.0, 0.30000001192092896, <NULL>), (5, 1, 0.0, 0.30000001192092896, <NULL>)))

参数说明: 返回的是六个5维数组，分别代表六个轴对应的数据，每个数组的4个元素含义参考上一个接口说明。失败: 其它

get_tool_drive_config()

力控工具拖拽使能

力控工具拖拽使能，与enable_admittance_ctrl一致，需要先行设置工具拖拽参数，并开启和校零力控传感器

参数说明
- enable_flag 0 为关闭力控拖拽使能，1 为开启
返回值成功：(0,) 失败: 其它

enable_tool_drive(enable_flag)

开启或关闭恒力柔顺控制

参数说明
- enable_flag 0 为关闭，1 为开启，向控制器内部的compliantType变量赋值，与原set_compliant_type接口一致
返回值成功：(0,) 失败: 其它

enable_cst_force_ctrl(enable_flag)

设置力控终止条件

设置力控终止条件，与APP图形化编程同名指令含义相同

set_force_stop_condition([opt,lowerlimiton,lowerlimit,upperlimiton,upperlimit],[...],[...],[...],[...],[...])

参数说明
- opt 6维数组，分别代表6个维度上是否开启力控终止条件，0 代表没有勾选, 非 0 值代表勾选
- lowerlimiton 6维数组，0 代表不设置下限，非 0 值代表设置
- lowerlimit 6维数组，下限数值
- upperlimiton 6维数组，0 代表不设置下限，非 0 值代表设置
- upperlimit 6维数组，下限数值接口传入的6个列表（代表6个轴），每个列表有5个数据，具体含义如上。
返回值成功：(0,) 失败: 其它

set_force_stop_condition([0,1,2,3,4],[0,0,0,0,0]，[0,0,0,0,0]，[0,0,0,0,0]，[0,0,0,0,0]，[0,0,0,0,0])

获取恒力柔顺开启状态

获取恒力柔顺开启状态，读取控制器内部compliantType数值就行

返回值成功：(0,cst_force_ctrl_stat) * cst_force_ctrl_stat，0 代表未开启，1代表开启，2代表速度模式（兼容性，新版本不会有2）失败: 其它

get_cst_force_ctrl_stat()

设置进近限速

参数说明
- speed_limit 线速度限制，mm/s
- angular_speed_limit 角速度限制，rad/s
返回值成功：(0,speed_limit, angular_speed_limit) 失败: 其它

set_approach_speed_limit(speed_limit, angular_speed_limit)

获取进近限速

返回值成功：(0,speed_limit, angular_speed_limit) * speed_limit 线速度限制，mm/s * angular_speed_limit 角速度限制，rad/s 失败: 其它

get_approach_speed_limit()

设置恒力控制容差

参数说明
- force_tol 力容差
- torque_tol 力矩容差
返回值
- 成功：(0,)
- 失败：其它

set_cst_force_ctrl_tol(force_tol, torque_tol)

获取恒力控制容差

设置恒力控制容差

返回值
- 成功：(0, force_tol, torque_tol)
  - force_tol 力容差
  - torque_tol 力矩容差
- 失败：其它

get_cst_force_ctrl_tol()

FTP

FTP初始化

初始化ftp客户端，与控制柜建立连接，可导入导出program、track

init_ftp_client()

返回值
- 成功：(0,)
- 失败：其它

FTP关闭

close_ftp_client()

返回值
- 成功：(0,)
- 失败：其它

查询控制器FTP的目录

get_ftp_dir(remotedir, type)

参数说明
- remotedir：控制器内部文件夹名称
- type：0文件和文件夹 1文件 2文件夹
返回值
- 成功：(0,ret) ret为字符串
- 失败：其它
代码示例

# -*- coding: utf-8 -*-
import jkrc                           #导入模块  
robot = jkrc.RC("192.168.220.158")  #返回一个机器人对象  
robot.login()  
dir= "/program/"  
robot.init_ftp_client()  
result = robot.get_ftp_dir("/program/", 0)  
print(result)  
robot.close_ftp_client()  
robot.logout()

下载FTP文件

从机器人控制柜的ftp下载文件或文件夹到本地，查询轨迹“/track/”,查询脚本程序“/program/”

download_file(local, remote, opt)

参数说明
- remote 控制器内部文件名绝对路径，文件夹需要以""或“/”结尾取决于系统。如单个文件“/program/test/test.jks”或者文件夹“/program/test/”
- local 下载到本地文件名绝对路径
- opt 1单个文件 2文件夹
返回值
- 成功：(0,)
- 失败：其它
代码示例：将ftp端的program文件夹下载到桌面program文件夹内

import jkrc  
robot = jkrc.RC("192.168.2.26")#VMmodel  
robot.login()  
remote = "/program/"  
local= "C:\\Users\\Administrator\\Desktop\\program\\track\\"  
robot.init_ftp_client()  
result = robot.download_file(local, remote, 2)  
print(result)  
robot.close_ftp_client()  
robot.logout()

上传文件到FTP

从本地上传指定类型和名称的文件到控制器。

upload_file(local, remote,  opt)

参数说明
- remote 上传到控制器内部文件名绝对路径，文件夹需要以""或“/”结尾取决于系统
- local 本地文件名绝对路径
- opt 1单个文件 2文件夹
返回值
- 成功：(0,)
- 失败：其它
代码示例：将桌面的lxxpro文件夹内的所有文件和文件夹上传到ftp的program/文件夹下

import jkrc  
robot = jkrc.RC("192.168.2.26")#VMmodel  
robot.login()  
remote = "/program/"  
local= "C:\\Users\\Administrator\\Desktop\\lxxpro\\"  
robot.init_ftp_client()  
result = robot.upload_file(local, remote, 2)  
print(result)  
robot.close_ftp_client()  
robot.logout()

重命名FTP上的文件

重命名控制器指定类型和名称的文件。

rename_ftp_file(local, remote,  opt)

参数说明
- remote 控制器内部文件名绝对路径，文件夹需要以""或“/”结尾取决于系统
- des 重命名的目标名
- opt 1单个文件 2文件夹，重命名文件时会重命名文件夹内所有文件，便于/track/使用
返回值
- 成功：(0,)
- 失败：其它
代码示例：将ftp的lxxpro文件夹内的所有文件和文件夹重命名为lxx

import jkrc  
  
robot = jkrc.RC("192.168.2.26")#VMmodel  
robot.login()  
remote = "/lxxpro/"  
des = "lxx"  
robot.init_ftp_client()  
result = robot.rename_ftp_file(remote, des, 2)  
print(result)  
robot.close_ftp_client()  
robot.logout()

删除文件到FTP

从控制器删除指定类型和名称的文件。

del_ftp_file( remote, opt)

参数说明
- remote 控制器内部文件名绝对路径，文件夹需要以""或“/”结尾取决于系统
- opt 1单个文件 2文件夹
返回值
- 成功：(0,)
- 失败：其它
代码示例（谨慎操作，该示例会删除所有程序）

import jkrc  
  
robot = jkrc.RC("192.168.2.26")#VMmodel  
robot.login()  
dir= "/program/"  
robot.init_ftp_client()  
result = robot.del_ftp_file("/program/", 2)  
print(result)  
robot.close_ftp_client()  
robot.logout()

接口调用返回值列表及问题排查

错误代码	描述	处理建议
0	success	null
2	interface error or controller not support	核对控制器和SDK版本信息，进行升级或换用其他接口
-1	invalid handler	请检查调用接口前是否login
-2	invalid parameter	请检查参数是否正确
-3	fail to connect	请检查网络连接状态，或机器人IP是否正确
-4	kine_inverse error	逆解失败，请检查当前的坐标系，或参考关节角是否合理
-5	e-stop	急停状态，保留状态
-6	not power on	未上电
-7	not enable	未使能
-8	not in servo mode	不处于伺服模式，在执行servoJP 的时候，必须先进入伺服模式，请检查是否调用对应接口
-9	must turn off enable before power off	下电前必须下使能
-10	cannot operate, program is running	无法操作，程序正在执行中，请先关闭程序
-11	cannot open file, or file doesn't exist	无法打开文件，或者文件不存在
-12	motion abnormal	运动异常，可能处于奇异点附近，或者超出机器人运动限制
-14	ftp error	ftp异常
-15	socket msg or value oversize	超出限制异常
-16	kine_forward error	正解失败
-17	not support empty folder	不支持空文件夹
-20	protective stop	保护性停止
-21	emergency stop	急停
-22	on soft limit	处于软限位，此时无法手动拖动机器人，需要用APP上的示教功能接触软限位
-30	fail to encode cmd string	命令编码失败，一般是解析控制器返回的消息时出错
-31	fail to decode cmd string	命令解码失败，一般是解析控制器返回的消息时出错
-32	fail to uncompress port 10004 string	解压缩10004端口数据失败，可能受网络波动影响，或数据量太大的原因
-40	move linear error	直线运动失败，请检查是否路径中是否有奇异区域
-41	move joint error	关节运动失败，请检查设置的关节角度
-42	move circular error	圆弧运动失败,请检查设置的参数
-50	block_wait timeout	阻塞等待超时
-51	power on timeout	上电超时
-52	power off timeout	下电超时
-53	enable timeoff	使能超时
-54	disable timeout	下使能超时
-55	set userframe timeout	设置用户坐标系超时
-56	set tool timeout	设置工具坐标系超时
-57	edg init failed	edg功能初始化失败
-58	edg is running, cannot use servo_j or servo_p	edg功能正在执行中，无法使用servo_j或者servo_p接口
-59	current edg mode does not support using edg_servo_j or edg_servo_p.	edg功能正在执行中，无法使用edg_servo_j或者edg_servo_p接口
-60	set io timeout	设置IO超时
-61	operation timeout	接口超时
-62	servo queue is full	伺服队列已满
-63	servo is not running	伺服模式未启动
-9997	not implement	接口未实现
-9998	deprecated interface	接口未来将被移除（功能暂可用）
-9999	obsolete interface	接口未来将被移除（功能不可用）

问题反馈

文档中若出现不准确的描述或者错误，恳请读者见谅指正。如果您在阅读过程中发现任何问题或者有想提出的意见，可以发送邮件到 support@jaka.com ，我们将尽快给您回复。