C++

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

接口列表

机械臂基础

以下示例默认包含了必要的头文件，包含“JAKAZuRobot.h”, C++原生的头文件。

机械臂控制类构造函数

机械臂控制类构造函数，所有的接口都在该类中。

JAKAZuRobot();

机械臂登录

连接机械臂控制器，该接口启动成功，是其他接口调用的基础。

• 参数说明

  • ip  控制器ip地址

  • grpc_flag 是否使用grpc接口，默认值为false，使用tcp接口

  • username SDK户名，默认值为nullptr

  • password SDK密码，默认值为nullptr，app上设置的jaka_sdk密码

• 返回值 ERR_SUCC 成功 其他失败

errno_t login_in(const char *ip, bool grpc_flag = false, const char *username = nullptr, const char *password = nullptr);

机械臂注销

断开控制器连接，该接口调用成功后，除了login_in之外的函数均无法调用。

• 返回值 ERR_SUCC 成功 其他失败

errno_t  login_out();

机械臂上电

打开机械臂电源

• 返回值 ERR_SUCC 成功 其他失败

errno_t  power_on();

机械臂下电

关闭机械臂电源

• 返回值 ERR_SUCC 成功 其他失败

errno_t  power_off();

机械臂关机

机械臂控制柜关机

• 返回值 ERR_SUCC 成功 其他失败

errno_t  shut_down();

机械臂上使能

控制机械臂上使能

• 返回值 ERR_SUCC 成功 其他失败

errno_t  enable_robot();

机械臂下使能

控制机械臂下使能

• 返回值 ERR_SUCC 成功 其他失败

errno_t  disable_robot();

控制机械臂进入或退出拖拽模式

控制机械臂进入或退出拖拽模式

• 参数说明

  • enable  TRUE为进入拖拽模式，FALSE为退出拖拽模式

• 返回值 ERR_SUCC 成功 其他失败

errno_t  drag_mode_enable(BOOL enable);

查询机械臂是否处于拖拽模式

查询机械臂是否处于拖拽模式

• 参数说明

  • in_drag 查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_in_drag_mode(BOOL *in_drag);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
int example_drag()
{
    //实例API对象demo
    JAKAZuRobot demo;
    BOOL in_drag;
    demo.is_in_drag_mode(&in_drag);
    demo.drag_mode_enable(TRUE);
    return 0;
}

设置关节摩擦补偿系数（拖拽手感参数）

警告

废弃接口

设置机械臂各轴摩擦力补偿系数

• 参数说明

  • joint 关节编号 0~5

  • gain  摩擦力补偿系数，系数值范围0-200，,200就是补偿200%的摩擦力

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_drag_friction_compensation_gain(int joint, int gain);

获取关节摩擦补偿系数

获取机械臂各轴摩擦力补偿系数(拖拽手感参数)

• 参数说明

  • list 为int型6维数组，分别对应6个关节的摩擦力补偿系数

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_drag_friction_compensation_gain(DragFrictionCompensationGainList* list);

各个机型每个关节默认值：（Zu7=Zu5，Zu与Pro、S相同）

机型	关节1	关节2	关节3	关节4	关节5	关节6	备注
Zu7	90	90	90	70	70	70
A7	90	90	90	70	70	70
Zu12	60	60	60	45	45	45
A12	60	60	60	45	45	45
Zu18	60	60	64	45	45	45
Zu3	45	45	45	60	60	60
Pro16	100	100	80	90	90	90
Zu20	100	100	80	60	60	60
MiniCobo	5	5	5	10	10	10
Mini2	50	50	50	60	60	60

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
int example_drag()
{
    //实例API对象demo
    JAKAZuRobot demo;
    DragFrictionCompensationGainList list;
    demo.get_drag_friction_compensation_gain(&list);
    for(int i=0; i<6; i++){
        std::cout << list.gain[i] << std::endl;
    }
    return 0;
}

获取SDK版本号

获取机械臂控制器版本号

• 参数说明

  • version SDK版本号

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_sdk_version(char *version);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//获取sdk版本号
int example_getsdk_version()
{
    //实例API对象demo
    JAKAZuRobot demo;
    char ver[100];
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //查询当前SDK版本
    demo.get_sdk_version(ver);
    std::cout << " SDK version is :" << ver << std::endl;
    return 0;
}

获取SDK日志路径（静态方法）

获取SDK日志路径， 用于SDK对象创建前

• 参数说明

  • filepath SDK日志路径

• 返回值 ERR_SUCC 成功 其他失败

errno_t  static_get_SDK_filepath(char *filepath);

获取SDK日志路径

获取SDK日志路径

• 参数说明

  • path SDK日志路径

  • size path的长度

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_SDK_filepath(char* path, int size);

设置SDK日志路径（静态方法）

警告

废弃接口

设置SDK日志路径， 用于SDK对象创建前

• 参数说明

  • filepath SDK日志路径

• 返回值 ERR_SUCC 成功 其他失败

errno_t  static_set_SDK_filepath(char *filepath);

设置SDK日志路径

设置SDK日志路径

• 参数说明

  • filepath SDK日志路径

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_SDK_filepath(const char *filepath);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//设置SDK日志路径
int example_set_SDK_filepath()
{
    //设置SDK日志路径
    char path[20] = "D://test.log";
    errno_t ret;
    JAKAZuRobot demo;
    ret = demo.set_SDK_filepath(path);//设置SDK文件路径
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    std::cout << ret << std::endl;
    return 0;
}

设置SDK是否开启调试模式

警告

废弃接口

设置是否开启调试模式，选择TRUE时，开始调试模式，此时会在标准输出流中输出调试信息，选择FALSE时，不输出调试信息

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_debug_mode(BOOL mode);

获取控制器IP

获取控制器IP

• 参数说明

  • controller_name 控制器名字

  • ip_list 控制器ip列表，控制器名字为具体值时返回该名字所对应的控制器IP地址，控制器名字为空时，返回网段类内的所有控制器IP地址

• 返回值 ERR_SUCC 成功 其他失败

• 当app启动时，该函数失效

errno_t  get_controller_ip(char *controller_name,char *ip_list);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//获取控制器ip
int example_get_controller_ip()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    char ip_list[2000] = { 0 };
    char  controller_name1[50] = "";
    //获取控制器ip
    ret = demo.get_controller_ip( controller_name1, ip_list);
    std::cout << ret << std::endl;
    std::cout << " ip_list is :" << ip_list << std::endl;
    return 0;
}

机械臂运动

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

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

• 参数说明

  • type 运动规划器类型

    • -1 禁用规划器，默认采用T规划

    • 0 T规划，即速度优先

    • 1 S规划，即柔顺优先

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_motion_planner(MotionPlannerType type);

机械臂手动模式下运动

控制机械臂手动模式下jog运动

• 参数说明

  • aj_num 关节空间下代表关节号[0-5]，笛卡尔下依次为轴x，y，z，rx，ry，rz

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

  • coord_type 机械臂运动坐标系，可选坐标系有工具坐标系(COORD_TOOL)、基坐标系(COORD_BASE)或关节空间(COORD_JOINT)

  • vel_cmd 指令速度，旋转轴或关节运动单位为rad/s，移动轴单位为mm/s

  • pos_cmd 指令位置，旋转轴或关节运动单位为rad，移动轴单位为mm 当move_mode是连续时，参数可忽略

• 返回值 ERR_SUCC 成功 其他失败

• Ps:调用jog函数在到达目标位置前，需要持续发送该点位

errno_t  jog(int aj_num, MoveMode move_mode, CoordType coord_type, double vel_cmd, double pos_cmd);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include <thread>
#define PI = 3.14159265358979323846
//机械臂手动运动
int main()
{
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();

    double value = PI/6;
    JointValue joints;
    while(TRUE){
        demo.get_joint_position(&joints);
        static double start = joints.jVal[1];
        //手动运动，其中INCR代表增量运动，0.5代表速度为0.5rad/s
        demo.jog(1, INCR, COORD_JOINT, 0.5, value);
        if(std::abs(start + value - joints.jVal[1]) < 0.001){break;}
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    //手动运动停止
    demo.jog_stop(0);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    //机械臂去使能
    demo.disable_robot();
    //机械臂下电
    demo.power_off();
    return 0;
}

机械臂手动模式下运动停止

控制机械臂手动模式下运动停止

• 参数说明

  • num  机械臂轴号0-5，num为-1时，停止所有轴

• 返回值 ERR_SUCC 成功 其他失败

errno_t  jog_stop(int num);

机械臂关节运动

机械臂关节运动

• 参数说明

  • joint_pos 机械臂关节运动目标位置，为double型6维数组

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

  • is_block 设置接口是否为阻塞接口，TRUE为阻塞接口 FALSE为非阻塞接口，阻塞时默认30s超时

  • speed 机械臂关节运动速度，单位：rad/s

  • acc 机械臂关节运动角加速度，默认值为3.5rad/s²

  • tol 机械臂关节运动终点误差，该参数使得两段运动之间更平滑，使用该参数时需要连续多段运动，且为非阻塞状态，默认值为0mm

  • option_cond 机械臂关节可选参数，如果不需要，该值可不赋值

• 返回值 ERR_SUCC 成功 其他失败

errno_t  joint_move(const JointValue *joint_pos, MoveMode move_mode, BOOL is_block, double speed, double acc = 3.5, double tol = 0, const OptionalCond *option_cond= nullptr);

机械臂末端直线运动

机械臂末端直线运动

• 参数说明

  • end_pos 机械臂末端运动目标位置

    • tran 笛卡尔空间下，工具末端运动目标位置，单位为mm，依次为x，y，z

    • rpy 旋转轴空间下，工具末端运动目标姿态，单位为rad，依次为rx，ry，rz

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

  • is_block 设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口，阻塞时默认30s超时

  • speed 机械臂直线运动速度，单位：mm/s

  • acc 机械臂直线运动线加速度，默认值为500mm/s²

  • tol 机械臂直线运动终点误差.该参数使得两段运动之间更平滑，使用该参数时需要连续多段运动，且为非阻塞状态，默认值为0mm

  • option_cond 机械臂直线运动可选参数，如果不需要，该值可不赋值

  • ori_vel 姿态速度，默认值为3.14rad/s

  • ori_acc 姿态加速度，默认值为12.56rad/s²

• 返回值 ERR_SUCC 成功 其他失败

• 奇异点常出现的三种情况：

  • 工具末端位置在轴线Z1和Z2构成的平面上；

  • 轴线Z2,Z3,Z4共面；

  • 关节5角度为0或180°，即Z4,Z6平行；

  errno_t  linear_move(const CartesianPose *end_pos, MoveMode move_mode, BOOL is_block, double speed, double accel = 500, double tol = 0, const OptionalCond *option_cond = nullptr, double ori_vel = 3.14, double ori_acc = 12.56);
  

  代码示例：

  int example_linear_move()
  {
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    RobotStatus status;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //定义并初始化CartesianPose变量，旋转角为弧度。
    CartesianPose cart;
    cart.tran.x = 300; cart.tran.y = 300; cart.tran.z = 100;
    cart.rpy.rx = 3.14; cart.rpy.ry = 0 ; cart.rpy.rz = 0;
    //笛卡尔空间运动，其中ABS代表绝对运动，FALSE代表指令是非阻塞的，10代表速度为10mm/s
    std::cout << "rx=" << cart.rpy.rx << " , ry=" << cart.rpy.ry<< " , rz=" << cart.rpy.rz << std::endl;
    demo.linear_move(&cart, ABS, FALSE, 200, 10 ,1,NULL);  //需先移动到点位附近，防止经过奇异点
    for (int i = 3; i > 0;i--) {
        cart.tran.x = 150; cart.tran.y = 300;
        //笛卡尔空间扩展运动，其中ABS代表绝对运动，FALSE代表指令是非阻塞的，20代表最大速度为20mm/s ,10代表加速度为10mm/s2,5代表圆弧过度半径为5mm
        demo.linear_move(&cart, ABS, FALSE, 20, 10, 5, NULL);
        cart.tran.x = 150; cart.tran.y = 250;
        demo.linear_move(&cart, ABS, FALSE, 20, 10, 5, NULL);
        cart.tran.x = 225; cart.tran.y = 250;
        demo.linear_move(&cart, ABS, FALSE, 20, 10, 5, NULL);
        cart.tran.x = 300; cart.tran.y = 250;
        demo.linear_move(&cart, ABS, FALSE, 20, 10, 5, NULL);
        cart.tran.x = 300; cart.tran.y = 300;
        demo.linear_move(&cart, ABS, FALSE, 20, 10, 5, NULL);
        std::this_thread::sleep_for(std::chrono::milliseconds(3000));
    }
    demo.login_out();
    return 0;
  }
  

  机械臂圆弧运动

  机械臂末端圆弧运动，该接口使用当前点和输入的两个点规划圆形轨迹。

• 参数说明

  • end_pos 机械臂末端运动目标位置

    • tran 笛卡尔空间下，工具末端运动目标位置，单位为mm，依次为x，y，z

    • rpy 旋转轴空间下，工具末端运动目标姿态，单位为rad，依次为rx，ry，rz

  • mid_pos 机械臂末端运中间点

  • move_mode 机械臂运动模式，仅支持绝对运动(ABS)

  • is_block 设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口

  • speed 机械臂直线运动速度，单位：mm/s

  • acc 机械臂笛卡尔空间加速度, 单位：mm/s²

  • tol 机械臂笛卡尔空间运动终点误差

  • option_cond 机械臂关节可选参数，如果不需要，该值可不赋值

  • circle_cnt 指定机械臂圆弧运动圈数。默认值为0,为0时等价于circular_move

  • circle_mode 指定机械臂圆弧运动模式，默认值为0，参数解释如下：

    • 0：固定采用起始姿态到终止姿态旋转角度小于180°的轴角进行姿态变化；(当前方案)

    • 1：固定采用起始姿态到终止姿态旋转角度大于180°的轴角进行姿态变化；

    • 2：根据中间点姿态自动选择选择角度小于180°还是大于180°；

    • 3：姿态夹角与圆弧轴线始终保持一致（当前整圆运动）。

•  返回值 ERR_SUCC 成功 其他失败

errno_t circular_move(const CartesianPose *end_pos, const CartesianPose *mid_pos, MoveMode move_mode, BOOL is_block, double speed, double accel, double tol, const OptionalCond *option_cond = nullptr, double circle_cnt = 0, int circle_mode = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#define PI 3.14159265358979323846

//机械臂圆弧运动 ，关节速度上限3.14rad/s
int example_circle_move()
{
    OptionalCond opt;
    CartesianPose end_p,mid_p;
    end_p.tran.x = -200; end_p.tran.y = 400; end_p.tran.z = 400;
    end_p.rpy.rx = -PI/2 ; end_p.rpy.ry = 0 ; end_p.rpy.rz =0 ;
    mid_p.tran.x = -300; mid_p.tran.y = 400; mid_p.tran.z = 500;
    mid_p.rpy.rx = -PI/2 ; mid_p.rpy.ry = 0 ; mid_p.rpy.rz =0 ;

    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //定义并初始化关JointValue变量
    JointValue joint_pos = { 105.791*PI/180 , 63.471*PI/180 , -60.442*PI/180 , 176.971*PI/180 , 74.515*PI/180 , 0  };
    //关节空间运动，其中ABS代表绝对运动，TRUE代表指令是阻塞的，1代表速度为1rad/s
    demo.joint_move(&joint_pos, ABS, TRUE, 1);
    //圆弧运动，其中ABS代表绝对运动，TRUE代表指令是阻塞的，20代表直线速度为20mm/s，1代表加速度，0.1代表机械臂终点误差，opt为可选参数, 3代表圈数为3。
    demo.circular_move(&end_p, &mid_p, ABS, TRUE, 20, 1, 0.1,&opt);
    return 0;
}

代码示例2：

#include "jktypes.h"
#include "JAKAZuRobot.h"
#define PI 3.14159265358979323846

int example_circular_move()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();

    CartesianPose start_pos {-251.054,  -48.360, 374.000, 3.14, 0, 1.57};  // 开始点
    CartesianPose mid_pos = {-400.054, -198.360, 374.000, 3.14, 0, 1.57};  // 中间点
    CartesianPose end_pos = {-251.054, -348.360, 374.000, 3.14, 0, 1.57};  // 结束点

    demo.jog_stop(-1); // 停止当前关节运动

    JointValue ref_jv {0, 90*PI/180, 90*PI/180, 90*PI/180, -90*PI/180, 0};  // 先移动到到开始点附近
    demo.joint_move(&ref_jv, MoveMode::ABS, true, 20);

    JointValue start_jv;
    demo.get_joint_position(&ref_jv);  // 获取当前关节角
    demo.kine_inverse(&ref_jv, &start_pos, &start_jv); // 以当前关节角为参考，计算开始关节角
    demo.joint_move(&start_jv, MoveMode::ABS, true, 80);  // 移动到开始关节角位置
    OptionalCond opt;
    // 指定旋转3圈
    demo.circular_move(&end_pos, &mid_pos, MoveMode::ABS, true, 120, 100, 0.1, &opt, 3);

    demo.disable_robot();
    demo.power_off();
    demo.login_out();
}

机械臂运动终止

终止当前机械臂运动，机械臂脚本程序也会停止

• 返回值 ERR_SUCC 成功 其他失败

errno_t  motion_abort();

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include <thread>
#define PI 3.14159265358979323846

//机械臂运动终止
int example_motion_abort()
{
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //定义并初始化关JointValue变量
    printf("start_move");
    JointValue joint_pos = { 0 , 0 , 50*PI/180 , 0 , 0 , 0  };
    //关节空间运动，其中ABS代表绝对运动，TRUE代表指令是阻塞的，1代表速度为1rad/s
    demo.joint_move(&joint_pos, ABS, FALSE, 1);
    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
    //运动5s后终止
    demo.motion_abort();
    printf("stop_move");
    return 0;
}

查询机械臂运动是否停止

查询机械臂运动是否停止

• 参数说明

  • in_pos 查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_in_pos(BOOL *in_pos);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include <thread>
//查询机械臂运动是否停止
int example_is_in_pos()
{
    //实例API对象demo
    JAKAZuRobot demo;
    BOOL in_pos;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    while (1)
    {
        //查询是否运动停止
        demo.is_in_pos(&in_pos);
        std::cout << " in_pos is :" << in_pos << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    return 0;
}

查询机械臂运动状态

查询机械臂运动状态.

• 参数说明

  • status 机械臂运动状态

    • 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：机械臂触发碰撞

    errno_t get_motion_status(MotionStatus *status);
    

外部轴运动

外部轴上使能

外部轴上使能

• 参数说明

  • ext_id 外部轴ID

• 返回值 ERR_SUCC 成功 其他失败

errno_t enable_ext(int ext_id);

外部轴下使能

外部轴下使能

• 参数说明

  • ext_id 外部轴ID

• 返回值 ERR_SUCC 成功 其他失败

errno_t disable_ext(int ext_id);

获取外部轴状态

获取外部轴状态

• 参数说明

  • status_list 外部轴状态列表

  • ext_id 外部轴ID，-1代表获取所有外部轴状态

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ext_status(ExtAxisStatusList *status_list, int ext_id = -1);

外部轴jog运动

外部轴jog运动

• 参数说明

  • ext_id 外部轴ID，-1代表获取所有外部轴状态

  • is_abs 0代表绝对运动ABS，1代表增量运动INCR，2代表连续运动CONTINUE

  • vel 速度，增量和连续运动方向由速度控制

  • step ABS:step为目标位置; INCR:step为目标步长; CONTINUE:step无意义

• 返回值 ERR_SUCC 成功 其他失败

errno_t jog_ext(int ext_id, int is_abs, double vel, double step);

外部轴组合运动

获取外部轴状态

• 参数说明

  • status_list 外部轴状态列表（外部轴为关节运动时，单位为弧度rad；外部轴为直线运动时，单位为毫米mm）

  • ext_id 外部轴ID，-1代表获取所有外部轴状态

• 返回值 ERR_SUCC 成功 其他失败

errno_t multi_mov_with_ext(MultiMovInfoList multi_mov_info_list, DI_Info *di_info, int plannertype);

代码示例：

#include <iostream>
#include <thread>
#include <math.h>
#include "JAKAZuRobot.h"

#define rad2deg(x) ((x)*180.0/M_PI)
#define deg2rad(x) ((x)*M_PI/180.0)
void jog_ext();
void move_ext();
void movej_with_ext();
void movel_with_ext();
void movec_with_ext();
JAKAZuRobot robot;
errno_t ret;
int main()
{
    //初始化，上电上使能
    ret = robot.login_in("192.168.220.144",1,"jaka_sdk","Jaka123@");
    if(ret==0){std::cout << "登陆成功" << std::endl;}
    else {std::cout << "登陆失败" << std::endl;}
    robot.power_on();
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    robot.enable_robot();
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    JointValue jpos = {0, deg2rad(90), deg2rad(90), deg2rad(90), deg2rad(-90), deg2rad(10)};
    robot.joint_move(&jpos, ABS, true, 10);
    std::cout << "初始位置完成" << std::endl;
    robot.enable_ext(0);
    std::cout << "enable_ext完成" << std::endl;
    jog_ext();
    move_ext();
    movej_with_ext();
    movel_with_ext();
    movec_with_ext();

    robot.login_out();
    return 0;
}

void jog_ext()
{
    std::cout << " jog_ext" << std::endl;
    robot.set_auto_manual_mode(false);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    robot.jog_ext(0,0,80,5);
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    robot.jog_ext(0,0,80,4);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    robot.jog_stop(-1);
    robot.jog_ext(0,1,80,1);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    robot.jog_stop(-1);
    robot.jog_ext(0,1,-80,1);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    robot.jog_ext(0,2,1,0);
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    robot.jog_stop(-1);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    robot.jog_ext(0,2,-1,0);
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    robot.jog_stop(-1);

    robot.set_auto_manual_mode(true);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
void move_ext()
{
    std::cout << "单独外部轴运动" << std::endl;
    MultiMovInfoList move_ext;
    move_ext.count = 1;
    move_ext.is_block = 1;
    move_ext.multi_mov_info[0].motion_unit_type = 1;
    move_ext.multi_mov_info[0].move_type = 0;
    move_ext.multi_mov_info[0].motion_unit_id = 0;
    move_ext.multi_mov_info[0].end_pos[0] = 100;
    move_ext.multi_mov_info[0].move_mode = 0;
    move_ext.multi_mov_info[0].j_vel = 80;
    move_ext.multi_mov_info[0].j_acc = 80;
    move_ext.multi_mov_info[0].radius = 0.0;
    ret = robot.multi_mov_with_ext(move_ext);
    std::cout << "单独外部轴运动结束1" << std::endl;
    move_ext.multi_mov_info[0].end_pos[0] = 200;
    ret = robot.multi_mov_with_ext(move_ext);
    std::cout << "单独外部轴运动结束2" << std::endl;
    move_ext.multi_mov_info[0].end_pos[0] = 0;
    ret = robot.multi_mov_with_ext(move_ext);
    std::cout << "单独外部轴运动结束3" << std::endl;

}

void movej_with_ext()
{
    std::cout << "关节运动+外部轴运动" << std::endl;
    MultiMovInfoList movej_info;
    movej_info.count = 2;
    movej_info.is_block = 1;
    movej_info.multi_mov_info[0].motion_unit_type = 1;
    movej_info.multi_mov_info[0].move_type = 0;
    movej_info.multi_mov_info[0].motion_unit_id = 0;
    movej_info.multi_mov_info[0].end_pos[0] = 100;
    movej_info.multi_mov_info[0].move_mode = 0;
    movej_info.multi_mov_info[0].j_vel = 80;
    movej_info.multi_mov_info[0].j_acc = 80;
    movej_info.multi_mov_info[0].radius = 0.0;

    movej_info.multi_mov_info[1].motion_unit_type = 0;
    movej_info.multi_mov_info[1].move_type = 0;
    movej_info.multi_mov_info[1].motion_unit_id = 0;
    movej_info.multi_mov_info[1].end_pos[0] = deg2rad(90);
    movej_info.multi_mov_info[1].end_pos[1] = deg2rad(90);
    movej_info.multi_mov_info[1].end_pos[2] = deg2rad(90);
    movej_info.multi_mov_info[1].end_pos[3] = deg2rad(90);
    movej_info.multi_mov_info[1].end_pos[4] = deg2rad(-90);
    movej_info.multi_mov_info[1].end_pos[5] = 0;
    movej_info.multi_mov_info[1].move_mode = 0;
    movej_info.multi_mov_info[1].j_vel = deg2rad(80);
    movej_info.multi_mov_info[1].j_acc = deg2rad(200);
    movej_info.multi_mov_info[1].radius = 0.0;
    ret = robot.multi_mov_with_ext(movej_info);
    std::cout << "关节运动+外部轴运动结束1" << std::endl;


    movej_info.multi_mov_info[0].end_pos[0] = 0;
    movej_info.multi_mov_info[1].end_pos[0] = deg2rad(0);
    ret = robot.multi_mov_with_ext(movej_info);
    std::cout << "关节运动+外部轴运动结束2" << std::endl;
}

void movel_with_ext()
{
    std::cout << "直线运动+外部轴运动" << std::endl;
    MultiMovInfoList multi_mov_info_list;
    multi_mov_info_list.count = 2;
    multi_mov_info_list.is_block = TRUE;

    multi_mov_info_list.multi_mov_info[0].motion_unit_type = 1;
    multi_mov_info_list.multi_mov_info[0].move_type = 0;
    multi_mov_info_list.multi_mov_info[0].motion_unit_id = 0;
    multi_mov_info_list.multi_mov_info[0].end_pos[0] = 100;
    multi_mov_info_list.multi_mov_info[0].vel = 80;
    multi_mov_info_list.multi_mov_info[0].acc = 80;

    multi_mov_info_list.multi_mov_info[1].motion_unit_type = 0;
    multi_mov_info_list.multi_mov_info[1].move_type = 1;
    multi_mov_info_list.multi_mov_info[1].motion_unit_id = 0;
    multi_mov_info_list.multi_mov_info[1].end_pos[0] = 0;
    multi_mov_info_list.multi_mov_info[1].end_pos[1] = -300;
    multi_mov_info_list.multi_mov_info[1].end_pos[2] = 300;
    multi_mov_info_list.multi_mov_info[1].end_pos[3] = deg2rad(-180);
    multi_mov_info_list.multi_mov_info[1].end_pos[4] = deg2rad(0);
    multi_mov_info_list.multi_mov_info[1].end_pos[5] = deg2rad(180);
    multi_mov_info_list.multi_mov_info[1].vel = 80;
    multi_mov_info_list.multi_mov_info[1].acc = 80;
    multi_mov_info_list.multi_mov_info[1].ori_vel = deg2rad(180);
    multi_mov_info_list.multi_mov_info[1].ori_acc = deg2rad(720);

    ret = robot.multi_mov_with_ext(multi_mov_info_list);
    std::cout << "直线运动+外部轴运动结束1" << std::endl;

    multi_mov_info_list.multi_mov_info[0].end_pos[0] = 0;
    multi_mov_info_list.multi_mov_info[1].end_pos[0] = -300;
    multi_mov_info_list.multi_mov_info[1].end_pos[1] = 100;
    multi_mov_info_list.multi_mov_info[1].end_pos[2] = 300;
    ret = robot.multi_mov_with_ext(multi_mov_info_list);
    std::cout << "直线运动+外部轴运动结束2" << std::endl;

}

void movec_with_ext()
{
    std::cout << "圆弧运动+外部轴运动" << std::endl;
    MultiMovInfoList multi_mov_info_list;
    multi_mov_info_list.count = 2;
    multi_mov_info_list.is_block = TRUE;
    multi_mov_info_list.multi_mov_info[0].motion_unit_type = 1;
    multi_mov_info_list.multi_mov_info[0].move_type = 0;
    multi_mov_info_list.multi_mov_info[0].motion_unit_id = 0;
    multi_mov_info_list.multi_mov_info[0].end_pos[0] = 100;
    multi_mov_info_list.multi_mov_info[0].vel = 80;
    multi_mov_info_list.multi_mov_info[0].acc = 80;

    multi_mov_info_list.multi_mov_info[1].motion_unit_type = 0;
    multi_mov_info_list.multi_mov_info[1].move_type = 2;
    multi_mov_info_list.multi_mov_info[1].motion_unit_id = 0;
    multi_mov_info_list.multi_mov_info[1].mid_pos.tran.x = -145.178;
    multi_mov_info_list.multi_mov_info[1].mid_pos.tran.y = 15.344;
    multi_mov_info_list.multi_mov_info[1].mid_pos.tran.z = 291.208;
    multi_mov_info_list.multi_mov_info[1].mid_pos.rpy.rx = deg2rad(179.943);
    multi_mov_info_list.multi_mov_info[1].mid_pos.rpy.ry = deg2rad(0);
    multi_mov_info_list.multi_mov_info[1].mid_pos.rpy.rz = deg2rad(89.694);

    multi_mov_info_list.multi_mov_info[1].end_pos[0] = -345.178;
    multi_mov_info_list.multi_mov_info[1].end_pos[1] = 15.344;
    multi_mov_info_list.multi_mov_info[1].end_pos[2] = 291.208;
    multi_mov_info_list.multi_mov_info[1].end_pos[3] = deg2rad(179.943);
    multi_mov_info_list.multi_mov_info[1].end_pos[4] = deg2rad(0);
    multi_mov_info_list.multi_mov_info[1].end_pos[5] = deg2rad(89.694);
    multi_mov_info_list.multi_mov_info[1].vel = 80;
    multi_mov_info_list.multi_mov_info[1].acc = 200;
    multi_mov_info_list.multi_mov_info[1].ori_vel = deg2rad(180);
    multi_mov_info_list.multi_mov_info[1].ori_acc = deg2rad(720);
    ret = robot.multi_mov_with_ext(multi_mov_info_list);
    std::cout << "圆弧运动+外部轴运动结束1" << std::endl;

    multi_mov_info_list.multi_mov_info[0].end_pos[0] = 0;
    multi_mov_info_list.multi_mov_info[1].end_pos[0] = -300;
    multi_mov_info_list.multi_mov_info[1].end_pos[1] = 100;
    multi_mov_info_list.multi_mov_info[1].end_pos[2] = 300;
    multi_mov_info_list.multi_mov_info[1].end_pos[3] = deg2rad(-180);
    multi_mov_info_list.multi_mov_info[1].end_pos[4] = deg2rad(0);
    multi_mov_info_list.multi_mov_info[1].end_pos[5] = deg2rad(180);
    ret = robot.multi_mov_with_ext(multi_mov_info_list);
    std::cout << "圆弧运动+外部轴运动结束2" << std::endl;
}

机械臂操作信息设置与获取

获取机械臂状态监测数据（唯一多线程安全接口）

获取机械臂状态数据，多线程安全

• 参数说明

  • status 机械臂状态

    • errcode 机械臂错误码，0：无错误

    • inpos 机械臂运动是否完成，0：机械臂未完成运动，1：机械臂已完成运动

    • powered_on 机械臂是否上电，0：机械臂未上电，1：机械臂已上电

    • enabled 机械臂是否使能，0：机械臂未使能，1：机械臂已使能

    • rapidrate 机械臂运动速度比例

    • protective_stop 机械臂是否检测到碰撞，0：正常，1：触发碰撞

    • emergency_stop 机械臂是否发生急停，0：正常，1：处于急停状态

    • dout 机械臂控制柜数字输出信号，dout[0]是信号数量

    • din 机械臂控制柜数字输入信号，din[0]是信号数量

    • ain 机械臂控制柜模拟输入信号，ain[0]是信号数量

    • aout 机械臂控制柜模拟输出信号，aout[0]是信号数量

    • tio_dout 机械臂末端工具数字输出信号，tio_dout[0]是信号数量

    • tio_din 机械臂末端工具数字输入信号，tio_din[0]是信号数量

    • tio_ain 机械臂末端工具模拟输入信号，tio_ain[0]是信号数量

    • tio_key 机械臂末端工具三个按钮状态，[0]free;[1]point;[2]pause_resume

    • extio 机械臂外部应用IO

    • modbus_slave 机械臂Modbus从机

    • profinet_slave 机械臂Profinet从机

    • eip_slave 机械臂Ethernet/IP从机

    • current_tool_id 当前使用的工具坐标系ID

    • cartesiantran_position 机器人末端工具在笛卡尔空间中的位置

    • joint_position 机器人关节空间位置

    • on_soft_limit 机械臂是否处于软限位状态，0：机械臂正常，1：机械臂到达软限位

    • current_user_id 当前使用的用户坐标系ID

    • drag_status 机械臂是否处于拖拽状态，0：机械臂正常，1：机械臂处于托拽状态

    • robot_monitor_data 机械臂状态监测数据

    • torq_sensor_monitor_data 机械臂扭矩传感器状态监测数据

    • is_socket_connect 控制器连接状态，0：控制器连接异常，1：控制器连接正常

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_robot_status(RobotStatus *status);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//获取机械臂状态监测数据
int example_get_robot_status()
{
    //实例API对象demo
    JAKAZuRobot demo;
    RobotStatus robstatus;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //获取机械臂状态监测数据
    demo.get_robot_status(&robstatus);
    demo.login_out();
    return 0;
}

获取机械臂状态监测数据

获取机械臂状态数据，多线程安全

• 参数说明

  • status 机械臂状态

    • error 机械臂错误码，0表示无错误

    • errmsg 机械臂错误信息

    • powered_on 机械臂是否上电，0：机械臂未上电，1：机械臂已上电

    • enabled 机械臂是否使能，0：机械臂未使能，1：机械臂已使能

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_robot_status_simple(RobotStatus_simple *status);

获取当前机械臂关节角度——伺服反馈

获取当前机械臂关节角度，将关节角矩阵保存在输入参数joint_position中

• 参数说明

  • joint_position 关节角度查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_actual_joint_position(JointValue *joint_position);

获取当前机械臂关节角度

获取当前机械臂关节角度，将关节角矩阵保存在输入参数joint_position中

• 参数说明

  • joint_position 关节角度查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_joint_position(JointValue *joint_position);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//获取当前机械臂关节角
int example_get_joint_position()
{
    //实例API对象demo
    JAKAZuRobot demo;
    JointValue jot_pos;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //获取当前关节角
    demo.get_joint_position(&jot_pos);
    for (int i = 0; i < 6; i++)
    {
        std::cout << "joint [" << i+1 <<"] is :"<< jot_pos.jVal[i] << std::endl;
    }
    return 0;
}

设置手动或自动模式

设置机械臂操作模式，自动模式下，不可进行机械臂安全相关的设置；手动模式下，会自动进入缩进模式，确保操作安全。

• 参数说明

  • mode 模式参数，0：手动模式，1：自动模式

  • robot_id 机器人ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_auto_manual_mode(int mode, int robot_id = 0);

获取当前机械臂操作模式

获取当前机械臂操作模式

• 参数说明

  • mode 模式参数，0：手动模式，1：自动模式

  • robot_id 机器人ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_auto_manual_mode(int *mode, int robot_id = 0);

设置机械臂状态数据自动更新时间间隔

警告

废弃接口

设置机械臂状态数据自动更新时间间隔,特指get_robot_status()

• 参数说明

  • millisecond 时间参数，单位：ms

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_status_data_update_time_interval(float millisecond);

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

获取当前设置下工具末端的位姿，将位姿保存在输入参数tcp_position中

• 参数说明

  • tcp_position 工具末端位置查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_actual_tcp_position(CartesianPose *tcp_position);

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

获取当前设置下工具末端的位姿，将位姿保存在输入参数tcp_position中

• 参数说明

  • tcp_position 工具末端位置查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_tcp_position(CartesianPose *tcp_position);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//获取工具末端位姿
int example_get_tcp_position()
{
    //实例API对象demo
    JAKAZuRobot demo;
    CartesianPose tcp_pos;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //获取工具末端位姿
    demo.get_tcp_position(&tcp_pos);
    std::cout << "tcp_pos is :n x: " << tcp_pos.tran.x << "  y: " << tcp_pos.tran.y << "  z: " << tcp_pos.tran.z << std::endl;
    std::cout << "rx: " << tcp_pos.rpy.rx << "  ry: " << tcp_pos.rpy.ry << "  rz: " << tcp_pos.rpy.rz << std::endl;
    return 0;
}

设定用户坐标系信息

设置指定编号的用户坐标系信息

• 参数说明

  • id 用户坐标系编号 ，取值范围为[1,15]，0为默认世界坐标系，不可更改。

  • user_frame 用户坐标系偏置值

  • name 用户坐标系别名

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_user_frame_data(int id, const CartesianPose *user_frame, const char *name);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//用户坐标系查看及调整
int example_user_frame()
{
    int id_ret, id_set;
    id_set = 2;
    CartesianPose tcp_ret, tcp_set;
    char name[50] = "test";
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    //查询当前使用的用户坐标系ID
    demo.get_user_frame_id(&id_ret);
    //获取当前使用的用户坐标系信息
    demo.get_user_frame_data(id_ret, &tcp_ret);
    std::cout << "id_using=" << id_ret << " nx=" << tcp_ret.tran.x << " y=" << tcp_ret.tran.y << " z=" << tcp_ret.tran.y << std::endl;
    std::cout << "rx=" << tcp_ret.rpy.rx << " y=" << tcp_ret.rpy.ry << " z=" << tcp_ret.rpy.rz << std::endl;
    //初始化用户坐标系坐标
    tcp_set.tran.x = 0; tcp_set.tran.y = 0; tcp_set.tran.z = 10;
    tcp_set.rpy.rx = 120 ; tcp_set.rpy.ry = 90 ; tcp_set.rpy.rz = -90 ;
    //设置用户坐标系信息
    demo.set_user_frame_data(id_set, &tcp_set, name);
    //切换当前使用的用户坐标系坐标
    demo.set_user_frame_id(id_set);
    //查询当前使用的用户坐标系ID
    demo.get_user_frame_id(&id_ret);
    //获取设置的用户坐标系信息
    demo.get_user_frame_data(id_ret, &tcp_ret);
    std::cout << "id_using=" << id_ret << " nx=" << tcp_ret.tran.x << " y=" << tcp_ret.tran.y << " z=" << tcp_ret.tran.y << std::endl;
    std::cout << "rx=" << tcp_ret.rpy.rx << " y=" << tcp_ret.rpy.ry << " z=" << tcp_ret.rpy.rz << std::endl;
    return 0;
}

获取用户坐标系信息

查询当前使用的用户坐标系信息

• 参数说明

  • id 用户坐标系ID

  • user_frame 用户坐标系偏置值

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_user_frame_data(int id, CartesianPose *user_frame);

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

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

• 参数说明

  • id 用户坐标系ID ，取值范围为[0,15]，其中0为世界坐标系

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_user_frame_id(const int id);

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

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

• 参数说明

  • id 获取的结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_user_frame_id(int *id);

设置工具信息

配置指定编号的工具信息

• 参数说明

  • id 工具编号,取值范围为[1,15]

  • tcp 工具坐标系相对法兰坐标系偏置

  • name 指定工具的别名

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_tool_data(int id, const CartesianPose *tcp, const char *name);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//工具坐标系查看及调整
int example_tool()
{
    int id_ret,id_set;
    id_set = 2;
    CartesianPose tcp_ret,tcp_set;
    char name[50] = "test";
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    //查询当前使用的工具ID
    demo.get_tool_id(&id_ret);
    //获取当前使用的工具信息
    demo.get_tool_data(id_ret,&tcp_ret);
    std::cout << "id_using=" << id_ret << " x=" << tcp_ret.tran.x << " y=" << tcp_ret.tran.y << " z=" << tcp_ret.tran.y << std::endl;
    std::cout << "rx=" << tcp_ret.rpy.rx << " ry=" << tcp_ret.rpy.ry << " rz=" << tcp_ret.rpy.rz << std::endl;
    //初始化工具坐标
    tcp_set.tran.x = 0; tcp_set.tran.y = 0; tcp_set.tran.z = 10;
    tcp_set.rpy.rx = 120 ; tcp_set.rpy.ry = 90 ; tcp_set.rpy.rz = -90 ;
    //设置工具信息
    demo.set_tool_data(id_set, &tcp_set, name);
    //切换当前使用的工具坐标
    demo.set_tool_id(id_set);
    //查询当前使用的工具ID
    demo.get_tool_id(&id_ret);
    //获取设置的工具信息
    demo.get_tool_data(id_ret, &tcp_ret);
    std::cout << "id_using=" << id_ret << " nx=" << tcp_ret.tran.x << " y=" << tcp_ret.tran.y << " z=" << tcp_ret.tran.y << std::endl;
    std::cout << "rx=" << tcp_ret.rpy.rx << " ry=" << tcp_ret.rpy.ry << " rz=" << tcp_ret.rpy.rz << std::endl;
    return 0;
}

获取工具信息

查询当前使用的工具信息，使用示例参考设置工具信息

• 参数说明

  • id 工具ID查询结果

  • tcp 工具坐标系相对法兰坐标系偏置

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_tool_data(int id, CartesianPose *tcp);

查询当前使用的工具ID

查询当前使用的工具ID

• 参数说明

  • id 工具ID查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_tool_id(int *id);

设置当前使用的工具ID

设置当前使用的工具ID，在网络波动时，切换ID后需要一定延时才能生效，

• 参数说明

  • id 工具坐标系ID ,取值范围为[0,15]，0为使用默认末端法兰中心坐标系

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_tool_id(const int id);

设置数字输出变量

设置数字输出变量(DO)的值

• 参数说明

  • type DO类型

    • IO_CABINET，控制器IO

    • IO_TOOL，工具IO

    • IO_EXTEND，扩展IO

    • IO_REALY，继电器IO，只有Cabv3支持

    • IO_MODBUS_SLAVE，Modbus从站IO

    • IO_PROFINET_SLAVE，Profinet从站IO

    • IO_EIP_SLAVE，ETHRENET/IP从站IO

  • index DO索引（从0开始）

  • value DO设置值

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_digital_output(IOType type, int index, BOOL value);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include <thread>
//设置与查询数字输出
int main()
{
    BOOL DO3;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //查询do3的状态
    demo.get_digital_output(IO_CABINET, 2, &DO3);
    std::cout << "D03 = " << DO3 << std::endl;
    //io_cabinet是控制柜面板IO，2代表DO3，1对应要设置的DO值。
    demo.set_digital_output(IO_CABINET, 2, 1);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));//需要延时1s
    //查询do3的状态
    demo.get_digital_output(IO_CABINET, 2, &DO3);
    std::cout << "D03 = " << DO3 << std::endl;
    return 0;
}

设置模拟输出变量

设置模拟输出变量的值(AO)的值

• 参数说明

  • type AO类型，可选类型参考设置数字输出变量; 做modbus从站IO时，索引为4

  • index AO索引 （从0开始）

  • value AO设置值

• 返回值 ERR_SUCC 成功 其他失败

• Ps:V3版本暂不支持控制柜类型模拟IO，使用时type不能选择控制柜IO

errno_t  set_analog_output(IOType type, int index, float value);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include <thread>
//设置与查询模拟输出
int main()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    float AO1;
    //查询Ao的状态
    demo.get_analog_output(IO_MODBUS_SLAVE, 0, &AO1);
    std::cout << "AO1 = " << AO1 << std::endl;
    //IO_MODBUS_SLAVE是modbus IO，0代表AO1，1.5对应要设置的AO值。
    demo.set_analog_output(IO_MODBUS_SLAVE, 0, 2);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    //查询Ao的状态
    demo.get_analog_output(IO_MODBUS_SLAVE, 0, &AO1);
    std::cout << "AO1 = " << AO1 << std::endl;
    return 0;
}

运动中设置数字输出变量

运动中设置数字输出变量(DO)的值

• 参数说明

  • type DO类型，可选类型参考设置数字输出变量

  • index DO索引（从0开始）

  • value DO设置值

  • rel 0: 相对于运动起点， 1：相对于运动终点

  • distance 距离，指相对于起点或终点（依据rel参数）距离多少触发DO

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_motion_digital_output(IOType type, int index, BOOL value, BOOL rel, double distance);

运动中设置模拟输出变量

运动中设置模拟输出变量(AO)的值

• 参数说明

  • type AO类型，可选类型参考设置数字输出变量

  • index AO索引（从0开始）

  • value AO设置值

  • rel 0: 相对于运动起点， 1：相对于运动终点

  • distance 距离，指相对于起点或终点（依据rel参数）距离多少触发AO

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_motion_analog_output(IOType type, int index, BOOL value, BOOL rel, double distance);

查询数字输入状态

查询数字输入(DI)状态

• 参数说明

  • type DI类型，可选类型参考设置数字输出变量

  • index DI索引（从0开始）

  • result DI状态查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_digital_input(IOType type, int index, BOOL *result);

查询数字输出状态

查询数字输出(DO)状态

• 参数说明

  • type DO类型，可选类型参考设置数字输出变量

  • index DO索引（从0开始）

  • result DO状态查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_digital_output(IOType type, int index, BOOL *result);

获取模拟量输入变量的值

获取模拟量输入变量(AI)的值

• 参数说明

  • type AI的类型，可选类型参考设置数字输出变量

  • index AI索引（从0开始）

  • result 指定AI状态查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_analog_input(IOType type, int index, float *result);

获取模拟量输出变量的值

获取模拟量输出变量(AO)的值

• 参数说明

  • type AO的类型，可选类型参考设置数字输出变量

  • index AO索引（从0开始）

  • result 指定AO状态查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_analog_output(IOType type, int index, float *result);

查询扩展IO是否运行

查询扩展IO模块是否运行

• 参数说明

  • is_running 扩展IO模块运行状态查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_extio_running(BOOL *is_running);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//查询扩展IO状态
int main()
{
    BOOL is_running;
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    //查询TIO的状态
    demo.is_extio_running(&is_running);
    std::cout << "tio = " << is_running << std::endl;
    return 0;
}

机械臂负载设置

机械臂负载设置

• 参数说明

  • payload 负载质心、质量数据

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_payload(const PayLoad *payload);

获取机械臂负载数据

获取机械臂负载数据

• 参数说明

  • payload 负载查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_payload(PayLoad *payload);

代码示例：

 int example_payload()
 {
    //实例API对象demo
    JAKAZuRobot demo;
    PayLoad payloadret;
    PayLoad payload_set;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //查询当前负载数据
    demo.get_payload(&payloadret);
    std::cout << " payload mass is :" << payloadret.mass << " kg" << std::endl;
    std::cout << " payload center of mass is nx: " << payloadret.centroid.x<< "y: " << payloadret.centroid.y << "z: " << payloadret.centroid.z << std::endl;
    payload_set.mass = 1.0;
    //单位mm
    payload_set.centroid.x = 0; payload_set.centroid.y = 0; payload_set.centroid.z = 10;
    //设置当前负载数据
    demo.set_payload(&payload_set);
    //查询当前负载数据
    demo.get_payload(&payloadret);
    std::cout << " payload mass is :" << payloadret.mass << " kg" << std::endl;
    std::cout << " payload center of mass is nx: " << payloadret.centroid.x << "y: " << payloadret.centroid.y << "z: " << payloadret.centroid.z << std::endl;
    return 0;
}

设置TIOV3电压参数

设置tioV3电压参数

• 参数说明

  • vout_enable 电压使能，0:关，1开

  • vout_vol 电压大小 0:24v 1:12v

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_tio_vout_param(int vout_enable, int vout_vol);

获取TIOV3电压参数

获取tioV3电压参数

• 参数说明

  • vout_enable 电压使能，0:关，1开

  • vout_vol 电压大小 0:24v 1:12v

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_tio_vout_param(int* vout_enable, int* vout_vol);

TIO添加或修改信号量

添加或修改信号量

• 参数说明

  • sign_info 信号量参数

    • sig_name 信号量名称

    • chn_id 通道ID

    • sig_type 信号量类型

    • sig_addr 信号量地址

    • value 信号量初始值

    • frequency 信号量频率

• 返回值 ERR_SUCC 成功 其他失败

errno_t add_tio_rs_signal(SignInfo sign_info);

代码示例：

void example_add_tio_rs_signal()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();

    SignInfo sign_info {0};
    memcpy(sign_info.sig_name, "sign_tmp", sizeof("sign_tmp"));
    sign_info.chn_id = 0,
    sign_info.sig_type = 0,
    sign_info.value = 10,
    sign_info.frequency = 5;
    sign_info.sig_addr = 0x1;
    demo.add_tio_rs_signal(sign_info);
    demo.disable_robot();
    demo.power_off();
    demo.login_out();
}

TIO删除信号量

删除信号量

• 参数说明

  • sig_name 信号量名称

• 返回值 ERR_SUCC 成功 其他失败

errno_t del_tio_rs_signal(const char* sig_name);

代码示例：

void example_del_tio_rs_signal()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();

    const char* name = "sign_tmp";
    demo.del_tio_rs_signal(name);
    demo.disable_robot();
    demo.power_off();
    demo.login_out();
}

TIO RS485发送指令

RS485发送命令

• 参数说明

  • chn_id 通道号

  • data 数据字段

• 返回值 ERR_SUCC 成功 其他失败

errno_t send_tio_rs_command(int chn_id, uint8_t* data,int buffsize);

代码示例：

void example_send_tio_rs_command()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();

    uint8_t cmd[] = {'t', 'e', 's', 't', 'c', 'm', 'd'};
    demo.send_tio_rs_command(0, cmd, sizeof(cmd));

    demo.disable_robot();
    demo.power_off();
    demo.login_out();
}

TIO 刷新信号量信息

刷新信号量信息

• 参数说明

  • sign_info 信号量信息数组

    • sig_name 信号名称

    • frequency 信号频率

• 返回值 ERR_SUCC 成功 其他失败

errno_t update_tio_rs_signal(SignInfo_simple sign_info);

TIO 获取信号量信息

获取信号量信息, 建议在获取前先调用上面的刷新接口

• 参数说明

  • sign_info_array 信号量信息数组

  • array_len 信号量信息数组长度

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_rs485_signal_info(SignInfo* sign_info_array, int* array_len);

代码示例：

void example_get_rs485_signal_info()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();

    SignInfo sign_info[256];
    int array_len = 0;
    demo.get_rs485_signal_info(sign_info, &array_len);
    demo.disable_robot();
    demo.power_off();
    demo.login_out();
}

设置TIO模式

设置tio模式

• 参数说明

  • pin_type tio类型 0 for DI Pins，1 for DO Pins，2 for AI Pins

    • 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接口使能，模拟输入功能禁止。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_tio_pin_mode(int pin_type, int pin_mode);

获取TIO模式

获取tio模式

• 参数说明

  • pin_type tio类型 0 for DI Pins, 1 for DO Pins, 2 for AI Pins

    • 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接口使能，模拟输入功能禁止

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_tio_pin_mode(int pin_type, int* pin_mode);

TIO RS485通讯参数配置

RS485通讯参数配置

• 参数说明

  • mod_rtu_com 当通道模式设置为Modbus RTU时，需额外指定Modbus从站节点ID

    • chn_id RS485通道ID

    • slaveId Modbus从站节点ID

    • baudrate 波特率

    • databit 数据位

    • stopbit 停止位

    • parity 奇偶校验

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_rs485_chn_comm(ModRtuComm mod_rtu_com);

TIO RS485通讯参数查询

RS485通讯参数查询

• 参数说明

  • mod_rtu_com 用于接收获取的通道模式参数,查询时chn_id作为输入参数

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_rs485_chn_comm(ModRtuComm* mod_rtu_com);

TIO RS485通讯模式配置

RS485通讯模式配置

• 参数说明

  • chn_id 0: RS485H, channel 1; 1: RS485L, channel 2

  • chn_mode 0: Modbus RTU, 1: Raw RS485, 2, torque sensor

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_rs485_chn_mode(int chn_id, int chn_mode);

TIO RS485通讯模式查询

RS485通讯模式查询

• 参数说明

  • chn_id 输入参数 0: RS485H, channel 1。1: RS485L, channel 2

  • chn_mode 输出参数  0: Modbus RTU。1: Raw RS485。2：torque sensor

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_rs485_chn_mode(int chn_id, int* chn_mode);

获取机械臂安装角度

获取安装角度

• 参数说明

  • quat 安装角度四元数

  • appang 安装角度RPY角

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_installation_angle(Quaternion* quat, Rpy* appang);

设置机械臂安装角度

设置安装角度

• 参数说明

  • angleX 绕X轴旋转角度

  • angleZ 绕Z轴旋转角度

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_installation_angle(double angleX, double angleZ);

代码示例：

#include <JAKAZuRobot.h>
#include <iostream>
int main()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    errno_t ret = demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    if (ret != ERR_SUCC)
    {
        std::cerr << "login failed.";
        return -1;
    }
    ret = demo.set_installation_angle(3.14, 0);
    if (ret != ERR_SUCC)
    {
        std::cerr << "set installation angle failed.";
        return -1;
    }
    Quaternion quat;
    Rpy rpy;
    ret = demo.get_installation_angle(&quat, &rpy);
    if (ret != ERR_SUCC)
    {
        std::cerr << "get installation angle failed.";
        return -1;
    }
    std::cout << "quat: [" << quat.x << ", " << quat.y << ", " << quat.z << ", " << quat.s << "]";
    std::cout << "anglex: " << rpy.rx << ", anglez: " << rpy.rz << "";

    ret = demo.login_out();
    if (ret != ERR_SUCC)
    {
        std::cerr << "login out failed.";
        return -1;
    }
    return 0;
}

设置系统变量

设置系统变量

• 参数说明

  • v 系统变量

    •  id 系统变量ID

    •  value 系统变量值

    •  alias 系统变量名

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_user_var(UserVariable v);

获取机械臂状态

获取机械臂状态

• 参数说明

  • state 机械臂状态查询结果

    • estop 0：正常，1：急停

    • poweredOn 0: 未上电，1：上电

    • servoEnabled 0: 未使能，1：使能

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_robot_state(RobotState* state);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//获取机械臂状态(急停 上电 伺服使能)
int example_get_robstate()
{
    JAKAZuRobot demo;
    //声明机械臂状态结构体
    RobotState state;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    //查询机械臂状态
    demo.get_robot_state(&state);
    std::cout << "is e_stoped : " << state.estoped << std::endl;
    std::cout << "is powered : " << state.poweredOn << std::endl;
    std::cout << "is servoEnabled : " << state.servoEnabled << std::endl;
    return 0;
}

获取系统变量

获取系统变量

• 参数说明

  • vlist 系统变量查询结果列表

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_user_var(UserVariableList* vlist);

设置抖动抑制模式

设置抖动抑制模式

• 参数说明

  • mode 抖动抑制模式，0：关闭，1：模式1，2：模式2

  • robot_id 机械臂ID，默认值为 0

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_vibsuppress_mode(int mode, int robot_id = 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

开启抖动抑制设置

开启抖动抑制设置

• 参数说明

  • frequency 震动频率

  • damping 震动阻尼，默认值为 0.05

  • robot_id 机械臂ID，默认值为 0

• 返回值 ERR_SUCC 成功 其他失败

errno_t vibsuppress_on(double frequency, double damping = 0.05, int robot_id = 0);

关闭抖动抑制设置

关闭抖动抑制设置

• 参数说明

  • robot_id 机械臂ID，默认值为 0

• 返回值 ERR_SUCC 成功 其他失败

errno_t vibsuppress_off(int robot_id = 0);

机械臂安全状态设置与查询

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

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

• 参数说明

  • estop 查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_in_estop(BOOL *estop);

查询机械臂是否超出限位

查询机械臂是否超出软限位

• 参数说明

  • on_limit 查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_on_limit(BOOL *on_limit);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include <thread>
//查询是否超出限位
int example_is_on_limit()
{
    JAKAZuRobot demo;
    BOOL on_limit;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    while (1)
    {
        //查询是否超限
        demo.is_on_limit(&on_limit);
        std::cout << " on_limit is :" << on_limit << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    }
    return 0;
}

查询机械臂是否处于碰撞保护模式

查询机械臂是否处于碰撞保护模式

• 参数说明

  • in_collision 查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_in_collision(BOOL *in_collision);

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

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t  collision_recover();

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//碰撞保护状态查询，恢复
int example_collision_recover()
{
    JAKAZuRobot demo;
    BOOL in_collision;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    //查询是否处于碰撞保护状态
    demo.is_in_collision(&in_collision);
    std::cout << " in_collision is :" << in_collision << std::endl;
    if (in_collision)
    //如果处于碰撞保护模式，则从碰撞保护中恢复
        {demo.collision_recover();}
    else
        {std::cout << "robot is not collisio" << std::endl;}
    return 0;
}

设置机械臂碰撞等级

设置机械臂碰撞等级

• 参数说明

  • level  碰撞等级，取值范围[0,5] ，其中0为关闭碰撞，1为碰撞阈值25N，2为碰撞阈值50N，3为碰撞阈值75N，4为碰撞阈值100N，5为碰撞阈值125N

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_collision_level(const int level);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//碰撞等级查看，设置
int example_collision_level()
{
    //实例API对象demo
    JAKAZuRobot demo;
    int level;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //查询当前碰撞等级
    demo.get_collision_level(&level);
    std::cout << " collision level is :" << level << std::endl;
    //设置碰撞等级，[0,5]，0为关闭碰撞，1为碰撞阈值25N，2为碰撞阈值50N，3为碰撞阈值75N，4为碰撞阈值100N，5为碰撞阈值125N，
    demo.set_collision_level(2);
    //查询当前碰撞等级
    demo.get_collision_level(&level);
    std::cout << " collision level is :" << level << std::endl;
    return 0;
}

获取机器设置的碰撞等级

获取机械臂设置的碰撞等级

• 参数说明

  • level  碰撞等级，取值范围[0,5] ，其中0为关闭碰撞，1为碰撞阈值25N，2为碰撞阈值50N，3为碰撞阈值75N，4为碰撞阈值100N，5为碰撞阈值125N

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_collision_level(int *level);

设置网络异常时机械臂自动终止运动类型

设置网络异常控制句柄，SDK与机械臂控制器失去连接后多长时间机械臂控制器终止机械臂当前运动

• 参数说明

  • millisecond 时间参数，单位：ms，范围为500-30000ms，若设置超出该范围，则实际生效的时间为2s

  • mnt 网络异常时机械臂需要进行的动作类型，可选类型：MOT_KEEP(默认)，MOT_PAUSE，MOT_ABORT

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_network_exception_handle(float millisecond, ProcessType mnt);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//设置网络异常时机械臂自动终止运动类型
int example_set_network_exception_handle()
{
    float milisec = 100;
    errno_t ret;
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    //设置柔顺力矩条件
    ret = demo.set_network_exception_handle(milisec, MOT_KEEP);
    std::cout << ret << std::endl;
    return 0;
}

获取机械臂目前发生的最后一个错误码

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_last_error(ErrorCode *code);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//错误码查看
int example_get_last_errcode()
{
    errno_t ret;
    //初始化错误码文件存放路径
    JAKAZuRobot demo;
    ErrorCode Eret;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();

    ret = demo.program_load("not_exist999875");//故意加载一个不存在的程序，引发报错。
    std::cout << ret << std::endl;
    demo.get_last_error(&Eret);//查询最后一个报错信息
    std::cout << " error code is :" << Eret.code << " message: "<< Eret.message<< std::endl;
    demo.get_last_error(&Eret);//查询最后一个报错信息
    std::cout << " error code is :" << Eret.code << " message: " << Eret.message << std::endl;
    return 0;
}

错误状态清除

• 返回值 ERR_SUCC 成功 其他失败

errno_t  clear_error();

注册机械臂出错时的回调函数

警告

废弃接口

注册机械臂出现错误时的回调函数

• 参数说明

  • func 指向用户定义的函数的函数指针

  • error_code 机械臂的错误码

  errno_t set_error_handler(CallBackFuncType func);
  

  设置机械臂错误码文件存放路径

警告

废弃接口

设置错误码文件路径，需要使用get_last_error接口时需要设置错误码文件路径，如果不使用get_last_error接口，则不需要设置该接口

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_errorcode_file_path(char *path);

使用App脚本程序

运行当前加载的作业程序

运行当前加载的作业程序

• 返回值 ERR_SUCC 成功 其他失败

errno_t  program_run();

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include <windows.h>
//脚本加载，脚本运行控制，脚本过程查看
int example_program()
{
    char name[128];
    int cur_line;
    JAKAZuRobot demo;
    errno_t ret;
    ProgramState pstatus;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    if(ret==0){std::cout << "登陆成功" << std::endl;}
    else{
        std::cout << ret << std::endl;
        std::cout << "登陆失败" << std::endl;}
    demo.power_on();
    demo.enable_robot();
    //加载预先通过app编辑完成的example脚本
    demo.program_load("example");
    //获取已加载的程序名
    demo.get_loaded_program(name);
    std::cout<<"Pro_nameis:"<<name<<std::endl;
    //运行当前加载的程序
    demo.program_run();

    std::this_thread::sleep_for(std::chrono::milliseconds(1000));//让程序先运行1s
    //暂停当前运行的程序
    demo.program_pause();
    //获取当前执行程序的行号
    demo.get_current_line(&cur_line);
    std::cout<<"cur_lineis:"<<cur_line<<std::endl;
    //获取当前程序状态
    demo.get_program_state(&pstatus);
    std::cout<<"pro_statusis:"<<pstatus<<std::endl;
    //继续运行当前程序
    demo.program_resume();
    std::this_thread::sleep_for(std::chrono::milliseconds(10000));//需要window.h延时10s
    //终止当前程序
    demo.program_abort();
    return 0;
}

暂停当前运行的作业程序

暂停当前运行的作业程序

• 返回值 ERR_SUCC 成功 其他失败

errno_t  program_pause();

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

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t  program_resume();

终止当前执行的作业程序

终止当前执行的作业程序

• 返回值 ERR_SUCC 成功 其他失败

errno_t  program_abort();

加载指定的作业程序

加载指定的作业程序 程序名为app中的名称即可（加载轨迹复现数据，轨迹复现数据的加载需要在文件夹名字前加上track/）

• 参数说明

  • file 程序文件路径

• 返回值 ERR_SUCC 成功 其他失败

errno_t  program_load(const char *file);

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

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

• 参数说明

  • file 程序文件路径

  • size file 的长度，最大为100

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_loaded_program(char *file, uint8_t size);

获取当前机械臂作业程序的执行行号

获取当前机械臂作业程序的执行行号

• 参数说明

  • curr_line 当前行号查询结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_current_line(int *curr_line);

获取机械臂作业程序的执行状态

获取机械臂作业程序执行状态

• 参数说明

  • status 作业程序执行状态查询结果，PROGRAM_IDLE：停止状态，PROGRAM_RUNNING：运行状态，PROGRAM_PAUSED：暂停状态

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_program_state(ProgramState *status);

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

获取机械臂作业程序信息

• 参数说明

  • info 程序信息查询结果

    • logic_line 程序脚本执行行号

    • motion_line 正在执行的运动CMD id

    • file 当前程序文件

    • program_state 程序执行状态

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_program_info(ProgramInfo *info);

设置机械臂的运行倍率

设置机械臂运行倍率

• 参数说明

  • rapid_rate 是程序运行倍率，设置范围为[0,1]

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_rapidrate(double rapid_rate);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include "thread"
//机械臂速度查看及调整
int example_rapidrate()
{
    double rapid_rate;
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    //获取机械臂运动速率
    demo.get_rapidrate(&rapid_rate);
    std::cout << "rapid_rate is : " << rapid_rate << std::endl;
    //设置机械臂运动速率
    demo.set_rapidrate(0.4);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    demo.get_rapidrate(&rapid_rate);
    std::cout << "rapid_rate is : " << rapid_rate << std::endl;
    return 0;
}

获取机械臂的运行倍率

获取机械臂运行倍率

• 参数说明

  • rapid_rate当前控制系统倍率

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_rapidrate(double *rapid_rate);

机械臂轨迹复现

设置轨迹复现配置参数

设置轨迹复现配置参数

• 参数说明

  • para 轨迹复现配置参数

    • xyz_interval 轨迹复现的坐标精度

    • rpy_interval 轨迹复现的姿态精度

    • vel 轨迹复现的运行速度

    • acc 轨迹复现的运行加速度

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_traj_config(const TrajTrackPara *para);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//轨迹复现参数查看及设置
int example_traj_config()
{
    JAKAZuRobot demo;
    TrajTrackPara trajpar_read;
    TrajTrackPara trajpar_set;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //查询当前轨迹复现参数
    demo.get_traj_config(&trajpar_read);
    std::cout << " trajTrackPara is :n xyz interval:" << trajpar_read.xyz_interval << "  rpy interval is :" << trajpar_read.rpy_interval << std::endl;
    std::cout << " vel: " << trajpar_read.vel << "  acc: " << trajpar_read.acc << std::endl;
    //设置当前轨迹复现参数
    trajpar_set.xyz_interval = 0.01; trajpar_set.rpy_interval = 0.01; trajpar_set.vel = 10; trajpar_set.acc = 2;
    demo.set_traj_config(&trajpar_set);
    //查询当前轨迹复现参数
    demo.get_traj_config(&trajpar_read);
    std::cout << " trajTrackPara is :n xyz interval:" << trajpar_read.xyz_interval << "  rpy interval is :" << trajpar_read.rpy_interval << std::endl;
    std::cout << " vel: " << trajpar_read.vel << "  acc: " << trajpar_read.acc << std::endl;
    return 0;
}

获取轨迹复现配置参数

获取轨迹复现配置参数

• 参数说明

  • para 轨迹复现配置参数

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_traj_config(TrajTrackPara *para);

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

采集轨迹复现数据控制开关，该开关开启后需要启动 拖拽 才有轨迹文件生成。

• 参数说明

  • mode 选择TRUE时，开始数据采集，选择FALSE时，结束数据采集

  • filename 采集数据的存储文件名，当filename为空指针时，存储文件以当前日期命名

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_traj_sample_mode(const BOOL mode, char *filename);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#include "thread"
//轨迹采集开关与状态查询
int example_traj_sample()
{
    BOOL samp_stu;
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    char name[20] = "testxx";
    //开启轨迹复现数据采集开关
    ret = demo.set_traj_sample_mode(TRUE, name);
    //查询轨迹复现采集状态
    demo.get_traj_sample_status(&samp_stu);
    std::this_thread::sleep_for(std::chrono::milliseconds(10000));
    demo.set_traj_sample_mode(FALSE, name);
    return 0;
}

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

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

• 参数说明

  • mode 为TRUE时，数据正在采集，为FALSE时，数据采集结束，在数据采集状态时不允许再次开启数据采集开关

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_traj_sample_status(BOOL* sample_status);

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

警告

废弃接口

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

• 参数说明

  • filename 控制器中已经存在的轨迹复现数据的文件名

• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_exist_traj_file_name(MultStrStorType *filename);

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

警告

废弃接口

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

• 参数说明

  • src 原文件名

  • dest 目标文件名，文件名长度不能超过100个字符，文件名不能为空，目标文件名不支持中文

• 返回值 ERR_SUCC 成功 其他失败

errno_t  rename_traj_file_name(const char *src,const char *dest);

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

警告

废弃接口

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

• 参数说明

  • filename 要删除的文件的文件名，文件名为数据文件名字

• 返回值 ERR_SUCC 成功 其他失败

errno_t  remove_traj_file(const char *filename);

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

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

• 参数说明

  • filename 数据文件的文件名，文件名为数据文件名字，不带后缀

• 返回值 ERR_SUCC 成功 其他失败

errno_t  generate_traj_exe_file(const char *filename);

机械臂伺服运动模式

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

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

• 参数说明

  • in_servo TRUE为处于伺服运动状态，FALSE为非伺服运动状态

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_in_servomove(BOOL *in_servo, int robot_id = 0);

机械臂伺服位置控制模式使能

机械臂伺服位置控制模式使能。

• 参数说明

  • enable  TRUE为进入伺服位置控制模式，FALSE表示退出该模式

  • is_block  TRUE为阻塞模式，FALSE为非阻塞模式，默认为阻塞模式

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

• Ps:v19及之前的版本该接口为非阻塞指令，V20之后该指令变为为阻塞指令。

errno_t  servo_move_enable(BOOL enable, BOOL is_block = true, int robot_id = 0);

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

机械臂关节空间位置控制模式

• 参数说明

  • joint_pos 机械臂关节运动目标位置

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

• 返回值 ERR_SUCC成功 其他失败

errno_t  servo_j(const JointValue *joint_pos, MoveMode move_mode);

代码示例：

//机械臂伺服关节运动
//使用该接口时，不可处于edg_servo模式，可使用edg_init(FALSE)关闭
//使用该接口时需要先调用servo_move_enable(TRUE)开启伺服控制
//控制器的发送周期为8ms，建议用户发送周期也为8ms，网络环境较差的情况可以适当减小周期
//关节速度上限180rad/s
//本指令与joint_move有较大差别，joint_move的插补由控制器进行，servo_j需要预先进行轨迹规划。
#include <iostream>
#include "JAKAZuRobot.h"
int main()
{
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //TRUE为进入伺服模式
    demo.servo_move_enable(TRUE);
    //定义并初始化关JointValue变量
    JointValue joint_pos = {-0.001, 0, 0, 0, 0, -0.001};
    for (int i = 0; i < 100; i++)
    {
        //关节空间伺服运动，其中INCR代表增量运动
        demo.servo_j(&joint_pos, INCR);
    }
    //FALSE为退出伺服模式
    demo.servo_move_enable(FALSE);
    return 0;
}

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

机械臂关节空间位置控制模式，增加了周期的调节性可以将周期调整为8ms的倍数。（非阻塞伺服模式下控制器的队列长度不能超过100）

• 参数说明

  • joint_pos 机械臂关节运动目标位置

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

  • step_num 倍分周期，servo_j运动周期为step_num*8ms，其中step_num>=1

  • queue_num 输出指针，返回当前指令的队列长度，默认为nullptr

  • do_info 指定DO信息，默认认为nullptr

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC成功 其他失败

errno_t  servo_j(const JointValue *joint_pos, MoveMode move_mode, unsigned int step_num = 1, int *queue_num = nullptr, DOInfo *do_info = nullptr, int robot_id = 0);

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

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

• 参数说明

  • cartesian_pose 机械臂笛卡尔空间运动目标位置

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

• 返回值 ERR_SUCC 成功 其他失败

errno_t  servo_p(const CartesianPose *cartesian_pose, MoveMode move_mode);

代码示例：

//机械臂伺服笛卡尔空间运动
//使用该接口时，不可处于edg_servo模式，可使用edg_init(FALSE)关闭
//使用该接口时需要先调用servo_move_enable(TRUE)开启伺服控制
//控制器的发送周期为8ms，建议用户发送周期也为8ms，网络环境较差的情况可以适当减小周期
//关节速度上限180 rad/s，笛卡尔空间没有相对直观的限制，但应满足该关节速度限制
//本指令与linear_move有较大差别，linear_move的插补由控制器进行，servo_p需要预先进行轨迹规划。
#include <iostream>
#include "JAKAZuRobot.h"
int main()//机械臂伺服笛卡尔空间运动
{
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //TRUE为进入伺服模式
    demo.servo_move_enable(TRUE);
    //定义并初始化关CartesianPose变量
    CartesianPose cart;
    cart.tran.x = 0; cart.tran.y = 1; cart.tran.z = 0;
    cart.rpy.rx = 0; cart.rpy.ry = 0; cart.rpy.rz = 0;
    for (int i = 0; i < 100; i++)
    {
        //笛卡尔空间伺服运动，其中INCR代表增量运动
        demo.servo_p(&cart, INCR);
    }
    //FALSE为退出伺服模式
    demo.servo_move_enable(FALSE);
    return 0;
}

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

机械臂笛卡尔空间位置控制模式，增加了周期的调节性可以将周期调整为8ms的倍数（非阻塞伺服模式下控制器的队列长度不能超过100）

• 参数说明

  • cartesian_pose 机械臂笛卡尔空间运动目标位置

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

  • step_num 倍分周期，servo_p运动周期为step_num*8ms，其中step_num>=1

  • queue_num 输出指针，返回当前指令的队列长度，默认为nullptr

  • do_info 指定DO信息，默认认为nullptr

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t servo_p(const CartesianPose *cartesian_pose, MoveMode move_mode, unsigned int step_num = 1, int *queue_num = nullptr, DOInfo *do_info = nullptr, int robot_id = 0);

机械臂SERVO模式下禁用滤波器

SERVO模式下不使用滤波器,该指令在SERVO模式下不可设置，退出SERVO后可设置

• 参数说明

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t  servo_move_use_none_filter(int robot_id = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//servo模式禁用滤波器
int example_servo_use_none_filter()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    ret = demo.servo_move_use_none_filter();
    std::cout << ret << std::endl;
    return 0;
}

机械臂SERVO模式下关节空间一阶低通滤波

SERVO模式下切换到关节空间一阶低通滤波，该指令在SERVO模式下不可设置，退出SERVO后可设置

• 参数说明

  • cutoffFreq 一阶低通滤波器截止频率

  • robot_id 机械臂ID，默认为0

  errno_t  servo_move_use_joint_LPF(double cutoffFreq, int robot_id = 0);
  

• 参数说明

  • cutoffFreq 一阶低通滤波器截止频率

• 返回值 ERR_SUCC 成功 其他失败  代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//servo模式下关节空间一阶低通滤波
int example_servo_use_joint_LPF()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //servo模式下关节空间一阶低通滤波,截止频率0.5Hz
    ret = demo.servo_move_use_joint_LPF(0.5);
    std::cout << ret << std::endl;
    return 0;
}

机械臂SERVO模式下关节空间非线性滤波

SERVO模式下切换到关节空间非线性滤波，该指令在SERVO模式下不可设置，退出SERVO后可设置

• 参数说明

  • max_vr 笛卡尔空间姿态变化速度的速度上限值（绝对值）°/s

  • max_ar 笛卡尔空间姿态变化速度的加速度上限值（绝对值）°/s²

  • max_jr 笛卡尔空间姿态变化速度的加加速度上限值（绝对值）°/s³

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t  servo_move_use_joint_NLF(double max_vr, double max_ar, double max_jr, int robot_id = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//servo模式下关节空间非线性滤波
int example_servo_use_joint_NLF()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //servo模式下关节空间非线性滤波
    ret = demo.servo_move_use_joint_NLF(2,2,4);
    std::cout << ret << std::endl;
    return 0;
}

机械臂SERVO模式下笛卡尔空间非线性滤波

SERVO模式下切换到笛卡尔空间非线性滤波,该指令在SERVO模式下不可设置，退出SERVO后可设置

• 参数说明

  • max_vp 笛卡尔空间下移动指令速度的上限值（绝对值）。单位：mm/s

  • max_ap 笛卡尔空间下移动指令加速度的上限值（绝对值）。单位：mm/s²

  • max_jp 笛卡尔空间下移动指令加加速度的上限值（绝对值）单位：mm/s³

  • max_vr 笛卡尔空间姿态变化速度的速度上限值（绝对值）°/s

  • max_ar 笛卡尔空间姿态变化速度的加速度上限值（绝对值）°/s²

  • max_jr 笛卡尔空间姿态变化速度的加加速度上限值（绝对值）°/s³

  • ori_quat 可选参数，指定描述笛卡尔空间姿态的表示方式。0表示使用欧拉角描述，1表示使用四元数描述

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t  servo_move_use_carte_NLF(double max_vp, double max_ap, double max_jp, double max_vr, double max_ar, double max_jr, int ori_quat = 0, int robot_id = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//servo模式下笛卡尔空间非线性滤波
int example_servo_use_carte_NLF()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //servo模式下笛卡尔空间非线性滤波
    ret = demo.servo_move_use_carte_NLF(2, 2, 4, 2, 2, 4);
    std::cout << ret << std::endl;
    return 0;
}

机械臂SERVO模式下关节空间多阶均值滤波

SERVO模式下切换到关节空间多阶均值滤波器,该指令在SERVO模式下不可设置，退出SERVO后可设置

• 参数说明

  • max_buf 均值滤波器缓冲区的大小

  • kp 加速度滤波系数

  • kv 速度滤波系数

  • ka 位置滤波系数

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t  servo_move_use_joint_MMF(int max_buf, double kp, double kv, double ka, int robot_id = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
#define PI 3.14159265358979323846
//servo模式下关节空间多阶均值滤波
int example_servo_use_joint_MMF()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //servo模式下关节空间多阶均值滤波
    ret = demo.servo_move_use_joint_MMF(20, 0.2, 0.4, 0.2);
    std::cout << ret << std::endl;
    return 0;
}

机械臂SERVO模式下速度前瞻参数设置

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

• 参数说明

  • max_buf 均值滤波器缓冲区的大小

  • kp 比例增益，值越大，响应越快、越精准，但易抖动；值越小，越平滑稳定，但响应延迟、精度降低。

  • ori_quat 可选参数，指定描述笛卡尔空间姿态的表示方式。0表示使用欧拉角描述，1表示使用四元数描述

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t servo_speed_foresight(int max_buf, double kp, int ori_quat = 0, int robot_id = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//servo模式下速度前瞻参数设置
int example_speed_foresight()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //servo模式下关节空间多阶均值滤波
    ret = demo.servo_speed_foresight(200, 2);
    std::cout << ret << std::endl;
    return 0;
}

机械臂SERVO模式下对关节空间滤波

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

• 参数说明

  • max_buf 滤波器缓冲区大小，建议取值范围[1,50]

  • kp 比例增益，取值范围为[0.05,0.4]，值越大，响应越快、越精准，但易抖动；值越小，越平滑稳定，但响应延迟、精度降低

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败

errno_t servo_move_use_joint_PCM(int max_buf, double kp, int robot_id = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//servo模式下速度前瞻参数设置
int example_speed_foresight()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //servo模式下关节空间多阶均值滤波
    ret = demo.servo_move_use_joint_PCM(10, 0.1);
    std::cout << ret << std::endl;
    return 0;
}

机械臂SERVO模式下对笛卡尔空间滤波

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

• 参数说明

  • max_buf 滤波器缓冲区大小，建议取值范围[1,50]

  • kp 比例增益，取值范围为[0.05,0.4]，值越大，响应越快、越精准，但易抖动；值越小，越平滑稳定，但响应延迟、精度降低

  • robot_id 机械臂ID，默认为0

• 返回值 ERR_SUCC 成功 其他失败 *Ps：笛卡尔空间PCM滤波相比于关节空间PCM滤波，精度更高，但对指令点位的质量要求较高，如果所给规划点位质量差，可能会使机械臂掉使能。

errno_t servo_move_use_carte_PCM(int max_buf, double kp, int robot_id = 0);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//servo模式下速度前瞻参数设置
int example_speed_foresight()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //机械臂上电
    demo.power_on();
    //机械臂上使能
    demo.enable_robot();
    //servo模式下关节空间多阶均值滤波
    ret = demo.servo_move_use_carte_PCM(10, 0.1);
    std::cout << ret << std::endl;
    return 0;
}

机械臂EDG（External Data Guider）功能

目前只能通过C++语言和Python语言使用该功能，该功能使用UDP（User Datagram Protocol）通讯

机械臂EDG使能

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

• 参数说明

  • en  使能开关，true为开启EDG功能，false表示退出该功能

  • edg_stat_ip  sdk客户端IP地址

  • edg_port  sdk客户端端口号

  • edg_mode  EDG模式，默认值为0，0表示所有与EDG相关的接口都可以调用，1表示除edg_servo_j和edg_servo_p外，所有接口都可以调用

• 返回值 ERR_SUCC 成功 其他失败

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

errno_t edg_init(BOOL en = true, const char* edg_stat_ip = "0.0.0.0", int edg_port = 10010, int edg_mode = 0);

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

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

• 参数说明

  • edg_state EDG反馈数据（包括关节位置、速度、力矩、笛卡尔位置、传感器数据）

  • robot_index 默认值为0，使用默认值时无须传参

• 返回值 ERR_SUCC成功 其他失败

errno_t edg_get_stat(EDGState *edg_state, unsigned char robot_index = 0);

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

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

• 参数说明

  • details 时间戳

    • details[0]秒

    • details[1]纳秒

    • details[3]时间戳计数

• 返回值 ERR_SUCC成功 其他失败

errno_t edg_stat_details(unsigned long int details[3]);

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

机械臂EDG关节空间位置控制模式

• 参数说明

  • joint_pos 机械臂关节运动目标位置

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

  • step_num 倍分周期，edg_servo_j运动周期为step_num*8ms，其中step_num>=1，默认值为1

  • robot_index 默认值为0，使用默认值时无须传参

• 返回值 ERR_SUCC成功 其他失败

• Ps: 该接口相比于原先的servo_j接口，实时控制的性能更好，但需要严格按照8ms的周期发送

errno_t edg_servo_j(const JointValue *joint_pos, MoveMode move_mode, unsigned int step_num = 1, unsigned char robot_index = 0);

代码示例：

#include <iostream>
#include <chrono>
#include <thread>
#include <math.h>
#include "JAKAZuRobot.h"

#define rad2deg(x) ((x)*180.0/M_PI)
#define deg2rad(x) ((x)*M_PI/180.0)
JAKAZuRobot demo;
JointValue jpos = {0, deg2rad(90), deg2rad(-90), deg2rad(90), deg2rad(90), 0};
errno_t ret;
void check_return(int ret, const std::string& func_name) {
    if (ret != 0) {
        std::cout << func_name << " failed, return value: " << ret << std::endl;
    }
}
void edg_servo_j_test() {
    const std::chrono::milliseconds interval(8);
    for(int i = 0;i<2000;i++)
    {
        auto start = std::chrono::steady_clock::now();
        static JointValue jpos_cmd;
        EDGState edgdata;
        CartesianPose cpos;
        double t = (i - 0)/5000.0;
        double kk = 32;
        jpos_cmd.jVal[0] = sin(kk*t)*deg2rad(30.0) + jpos.jVal[0];
        jpos_cmd.jVal[1] = -sin(kk*t)*deg2rad(20.0) + jpos.jVal[1];
        jpos_cmd.jVal[2] = jpos.jVal[2];
        jpos_cmd.jVal[3] = -sin(kk*t)*deg2rad(10.0) + jpos.jVal[3];
        jpos_cmd.jVal[4] = jpos.jVal[4];
        jpos_cmd.jVal[5] = jpos.jVal[5];
        ret = demo.edg_servo_j(&jpos_cmd,MoveMode::ABS);
        check_return(ret, "edg_servo_j");
        ret = demo.edg_get_stat(&edgdata);
        check_return(ret, "edg_get_stat");
        std::cout << "jointVal:" << edgdata.jointVal.jVal[0] << "," << edgdata.jointVal.jVal[1] << "," << edgdata.jointVal.jVal[2]
        << "," << edgdata.jointVal.jVal[3] << "," << edgdata.jointVal.jVal[4] << "," << edgdata.jointVal.jVal[5] << std::endl;
        std::cout << "jvel:" << edgdata.jointVel.jVel[0] << "," << edgdata.jointVel.jVel[1] << "," << edgdata.jointVel.jVel[2]
        << "," << edgdata.jointVel.jVel[3] << "," << edgdata.jointVel.jVel[4] << "," << edgdata.jointVel.jVel[5] << std::endl;
        std::cout << "jtorque:" << edgdata.jointTorq.jtorq[0] << "," << edgdata.jointTorq.jtorq[1] << "," << edgdata.jointTorq.jtorq[2]
        << "," << edgdata.jointTorq.jtorq[3] << "," << edgdata.jointTorq.jtorq[4] << "," << edgdata.jointTorq.jtorq[5] << std::endl;
        std::cout << "cpos:" << edgdata.cartpose.tran.x << "," << edgdata.cartpose.tran.y << "," << edgdata.cartpose.tran.z
        << "," << edgdata.cartpose.rpy.rx << "," << edgdata.cartpose.rpy.ry << "," << edgdata.cartpose.rpy.rz << std::endl;
        std::cout << "sensor:" << edgdata.torqSensor.fx << "," << edgdata.torqSensor.fy << "," << edgdata.torqSensor.fz
        << "," << edgdata.torqSensor.tx << "," << edgdata.torqSensor.ty << "," << edgdata.torqSensor.tz << std::endl;
        unsigned long int detail[3];
        ret = demo.edg_stat_details(detail);
        check_return(ret, "edg_stat_details");
        std::cout << "detail:" << detail[0] << "," << detail[1] << "," << detail[2] << std::endl;

        auto end = std::chrono::steady_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
        if (elapsed < interval) {
            std::this_thread::sleep_for(interval - elapsed);//等待下一个周期
        }
    }
}

int main() {
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    ret = demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    if(ret==0){std::cout << "登陆成功" << std::endl;}
    demo.power_on();
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    demo.enable_robot();
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    demo.clear_error();
    ret = demo.servo_move_enable(0);
    check_return(ret, "servo_move_enable");
    ret = demo.edg_init(false);
    check_return(ret, "edg_init");
    ret = demo.servo_move_use_none_filter();
    check_return(ret, "servo_move_use_none_filter");

    ret = demo.joint_move(&jpos, ABS, TRUE, 10);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    ret = demo.edg_init(true,"192.168.2.194",10020,0);
    check_return(ret, "edg_init");
    ret = demo.servo_move_enable(1,1); //必须先调用edg_init后再调用servo_move_enable
    check_return(ret, "servo_move_enable");
    edg_servo_j_test();

    return 0;
}

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

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

• 参数说明

  • cartesian_pose 机械臂笛卡尔空间运动目标位置

  • move_mode 机械臂运动模式，可选类型有绝对运动(ABS)、增量运动(INCR)

  • step_num 倍分周期，edg_servo_p运动周期为step_num*8ms，其中step_num>=1

  • robot_index 使用默认值，无须传参

• 返回值 ERR_SUCC 成功 其他失败

• Ps: 该接口相比于原先的servo_p接口，实时控制的性能更好，但需要严格按照8ms的周期发送

errno_t edg_servo_p(const CartesianPose *cartesian_pose, MoveMode move_mode, unsigned int step_num = 1, unsigned char robot_index = 0);

代码示例：

#include <iostream>
#include <chrono>
#include <thread>
#include <math.h>
#include "JAKAZuRobot.h"

#define rad2deg(x) ((x)*180.0/M_PI)
#define deg2rad(x) ((x)*M_PI/180.0)
JAKAZuRobot demo;
CartesianPose cpos_init;
JointValue jpos = {0, deg2rad(90), deg2rad(-90), deg2rad(90), deg2rad(90), 0};
errno_t ret;
void check_return(int ret, const std::string& func_name) {
    if (ret != 0) {
        std::cout << func_name << " failed, return value: " << ret << std::endl;
    }
}
void edg_servo_p_test() {
    const std::chrono::milliseconds interval(8);
    for(int i = 0;i<2000;i++)
    {
        auto start = std::chrono::steady_clock::now();

        static CartesianPose cpos_cmd;

        double coefficient = sin(i/200.0);
        double ori_step = deg2rad(20.0) * coefficient;
        double y_step = 100.0 * coefficient;
        double x_step = 100.0 * coefficient;
        cpos_cmd.tran.x = cpos_init.tran.x + x_step;
        cpos_cmd.tran.y = cpos_init.tran.y + y_step;
        cpos_cmd.tran.z = cpos_init.tran.z;
        cpos_cmd.rpy.rx = cpos_init.rpy.rx + ori_step;
        cpos_cmd.rpy.ry = cpos_init.rpy.ry + ori_step;
        cpos_cmd.rpy.rz = cpos_init.rpy.rz + ori_step;
        ret = demo.edg_servo_p(&cpos_cmd,MoveMode::ABS);
        check_return(ret, "edg_servo_p");

        auto end = std::chrono::steady_clock::now();
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
        if (elapsed < interval) {
            std::this_thread::sleep_for(interval - elapsed);//等待下一个周期
        }
    }
}

int main() {
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    ret = demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    if(ret==0){std::cout << "登陆成功" << std::endl;}
    demo.power_on();
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    demo.enable_robot();
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    demo.clear_error();
    ret = demo.servo_move_enable(0);
    check_return(ret, "servo_move_enable");
    ret = demo.edg_init(false);
    check_return(ret, "edg_init");
    ret = demo.servo_move_use_none_filter();
    check_return(ret, "servo_move_use_none_filter");

    ret = demo.joint_move(&jpos, ABS, TRUE, 10);
    demo.kine_forward(&jpos,&cpos_init);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    ret = demo.edg_init(true,"192.168.2.194",10020,0);
    check_return(ret, "edg_init");
    ret = demo.servo_move_enable(1,1); //必须先调用edg_init后再调用servo_move_enable
    check_return(ret, "servo_move_enable");
    edg_servo_p_test();

    return 0;
}

机械臂运动学

机械臂求解逆解

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

• 参数说明

  • ref_pos 逆解计算用的参考关节空间位置

  • cartesian_pose 笛卡尔空间位姿值

  • joint_pos 计算成功时关节空间位置计算结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  kine_inverse(const JointValue *ref_pos, const CartesianPose *cartesian_pose, JointValue *joint_pos);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
// 机械臂逆解 已知tcp_pos,求joint_pos
int example_kine_inverse()
{
    errno_t ret;
    JAKAZuRobot demo;
    //初始化参考点
    JointValue ref_jpos = { 2*PI/180, 90*PI/180, 90*PI/180 , 90*PI/180, -90*PI/180, 0*PI/180 };
    //初始化笛卡尔空间点坐标
    CartesianPose tcp_pos;
    tcp_pos.tran.x = -350; tcp_pos.tran.y = 100; tcp_pos.tran.z = 300;
    tcp_pos.rpy.rx = -180*PI/180; tcp_pos.rpy.ry = 0;  tcp_pos.rpy.rz = 90*PI/180;
    //初始化返回值
    JointValue joint_pos = { 0,0,0,0,0,0 }; ;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //求逆解
    ret = demo.kine_inverse(&ref_jpos, &tcp_pos, &joint_pos);
    std::cout << ret << std::endl;
    for (int i = 0; i < 6; i++)
    {
        std::cout << "joint [" << i + 1 << "] is :" << joint_pos.jVal[i]*180/PI << std::endl;
    }
    return 0;
}

机械臂求解逆解拓展

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

• 参数说明

  • ref_pos 逆解计算用的参考关节空间位置

  • cartesian_pose 笛卡尔空间位姿值

  • joint_pos 计算成功时关节空间位置计算结果

  • tool 指定的工具坐标系，未指定则使用当前默认工具坐标系

  • userFrame 指定的用户坐标系，未指定则使用当前默认的用户坐标系

• 返回值 ERR_SUCC 成功 其他失败

errno_t kine_inverse(const JointValue *ref_pos, const CartesianPose *cartesian_pose, JointValue *joint_pos, const CartesianPose* tool, const CartesianPose* userFrame);

机械臂求解正解

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

• 参数说明

  • joint_pos 关节空间位置

  • cartesian_pose 笛卡尔空间位姿计算结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  kine_forward(const JointValue *joint_pos, CartesianPose *cartesian_pose);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
// 4.55机械臂正解 已知joint_pos,求tcp_pos
int example_kine_forward()
{
    errno_t ret;
    JAKAZuRobot demo;
    //初始化返回值
    CartesianPose tcp_pos;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //初始化关节矩阵
    JointValue joint_pos = { 0.558, 0.872, 0.872 , 0.349, 0.191, 0.191 };
    //求正解
    ret = demo.kine_forward(&joint_pos, &tcp_pos);
    std::cout << ret << std::endl;
    std::cout << "tcp_pos is :\n x: " << tcp_pos.tran.x << "  y: " << tcp_pos.tran.y << "  z: " << tcp_pos.tran.z << std::endl;
    std::cout << "rx: " << tcp_pos.rpy.rx << "  ry: " << tcp_pos.rpy.ry << "  rz: " << tcp_pos.rpy.rz << std::endl;
    return 0;
}

机械臂求解正解拓展

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

• 参数说明

  • joint_pos 关节空间位置

  • cartesian_pose 笛卡尔空间位姿计算结果

  • tool 指定的工具坐标系，未指定则使用当前默认工具坐标系

  • userFrame 指定的用户坐标系，未指定则使用当前默认的用户坐标系

• 返回值 ERR_SUCC 成功 其他失败

errno_t kine_forward(const JointValue *joint_pos, CartesianPose *cartesian_pose, const CartesianPose* tool, const CartesianPose* userFrame);

欧拉角到旋转矩阵的转换

欧拉角到旋转矩阵的转换

• 参数说明

  • rpy 待转换的欧拉角数据

  • rot_matrix 转换后的旋转矩阵

• 返回值 ERR_SUCC 成功 其他失败

errno_t  rpy_to_rot_matrix(const Rpy *rpy, RotMatrix *rot_matrix);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
// 4.56欧拉角到旋转矩阵
int example_rpy_to_rot_matrix()
{
    errno_t ret;
    JAKAZuRobot demo;
    //初始化旋转矩阵
    Rpy rpy;
    rpy.rx = -1.81826; rpy.ry = -0.834253;  rpy.rz = -2.30243;
    //初始化返回值
    RotMatrix rot_matrix;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    //欧拉角变换成旋转矩阵
    ret = demo.rpy_to_rot_matrix(&rpy, &rot_matrix);
    std::cout << ret << "eul2rotm" << std::endl;
    std::cout << rot_matrix.x.x << " " << rot_matrix.y.x << " " << rot_matrix.z.x << std::endl;
    std::cout << rot_matrix.x.y << " " << rot_matrix.y.y << " " << rot_matrix.z.y << std::endl;
    std::cout << rot_matrix.x.z << " " << rot_matrix.y.z << " " << rot_matrix.z.z << std::endl;
    return 0;
}

旋转矩阵到欧拉角的转换

旋转矩阵到欧拉角的转换

• 参数说明

  • rot_matrix 待转换的旋转矩阵数据

  • rpy 转换后的RPY欧拉角结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  rot_matrix_to_rpy(const RotMatrix *rot_matrix, Rpy *rpy);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
// 4.57旋转矩阵--->欧拉角
int example_rot_matrix_to_rpy()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //初始化欧拉角
    Rpy rpy;
    //初始化旋转矩阵
    RotMatrix rot_matrix;
    rot_matrix.x.x = -0.4488, rot_matrix.y.x = -0.4998, rot_matrix.z.x = 0.7408;
    rot_matrix.x.y = -0.6621, rot_matrix.y.y = -0.3708, rot_matrix.z.y = -0.6513;
    rot_matrix.x.z = 0.6002, rot_matrix.y.z = -0.7828, rot_matrix.z.z = -0.1645;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    ret = demo.rot_matrix_to_rpy(&rot_matrix, &rpy);
    std::cout << ret << "rotm2eul:" << std::endl;
    std::cout << rpy.rx << " " << rpy.ry << " " << rpy.rz << std::endl;
    return 0;
}

四元数到旋转矩阵的转换

四元数到旋转矩阵的转换

errno_t quaternion_to_rot_matrix(const Quaternion *quaternion, RotMatrix *rot_matrix);

• 参数说明

  • quaternion 待转换的四元数数据

  • rot_matrix 转换后的旋转矩阵结果

• 返回值 ERR_SUCC 成功 其他失败  代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
// 4.58四元数-->旋转矩阵
int example_quaternion_to_rot_matrix()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //初始化四元数
    Quaternion quat;
    quat.s = 0.0629;  quat.x = 0.522886; quat.y = -0.5592;  quat.z = 0.6453;
    //初始化旋转矩阵
    RotMatrix rot_matrix;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    ret = demo.quaternion_to_rot_matrix(&quat, &rot_matrix);
    std::cout << ret << "quatl2rotm:" << std::endl;
    std::cout << rot_matrix.x.x << " " << rot_matrix.y.x << " " << rot_matrix.z.x << std::endl;
    std::cout << rot_matrix.x.y << " " << rot_matrix.y.y << " " << rot_matrix.z.y << std::endl;
    std::cout << rot_matrix.x.z << " " << rot_matrix.y.z << " " << rot_matrix.z.z << std::endl;
    return 0;
}

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

获取机械臂DH参数

• 参数说明

  • dhParam DH参数：alpha、a、d、theta

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_dh_param(DHParam* dh_param);

旋转矩阵到四元数的转换

旋转矩阵到四元数的转换

• 参数说明

  • rot_matrix 待转换的旋转矩阵

  • quaternion 转换后的四元数结果

• 返回值 ERR_SUCC 成功 其他失败

errno_t  rot_matrix_to_quaternion(const RotMatrix *rot_matrix, Quaternion *quaternion);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
// 4.59旋转矩阵--->四元数
int example_rot_matrix_to_quaternion()
{
    errno_t ret;
    //实例API对象demo
    JAKAZuRobot demo;
    //初始化四元数
    Quaternion quat;
    //初始化旋转矩阵
    RotMatrix rot_matrix;
    rot_matrix.x.x = -0.4488774, rot_matrix.y.x = -0.499824, rot_matrix.z.x = 0.740795;
    rot_matrix.x.y = -0.662098, rot_matrix.y.y = -0.370777, rot_matrix.z.y = -0.651268;
    rot_matrix.x.z = 0.600190, rot_matrix.y.z = -0.782751, rot_matrix.z.z = -0.164538;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    ret = demo.rot_matrix_to_quaternion(&rot_matrix, &quat);
    std::cout << ret << "rotm2quat:" << std::endl;
    printf("%lf %lf %lf %lf \n", quat.s, quat.x, quat.y, quat.z);
    return 0;
}

机械臂力控接口

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

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

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

设置末端力传感器型号

设置末端力传感器型号

• 参数说明

  • sensor_brand 传感器型号，取值范围为1-6或10，需要与传感器硬件外壳铭刻的型号数字相匹配。其中10特指已经内置与机械臂法兰内部的传感器，此型传感器由系统自动管理，无需调用此接口进行配置

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_torsenosr_brand(int sensor_brand);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//设置末端力传感器型号
int example_set_torsensor_brand()
{
    errno_t ret;
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    //设置末端力传感器型号
    ret = demo.set_torsenosr_brand(2);
    std::cout << ret << std::endl;
    return 0;
}

获取末端力传感器型号

获取末端力传感器型号

• 参数说明

  • sensor_brand 传感器型号，

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_torsenosr_brand(int* sensor_brand);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//获取末端力传感器型号
int example_get_torsensor_brand()
{
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    errno_t ret;
    int cur_sensor;
    //获取末端力传感器型号
    ret = demo.get_torsenosr_brand(&cur_sensor);
    std::cout << ret << std::endl;
    std::cout << "末端传感器型号为：" << cur_sensor << std::endl;
    return 0;
}

开启或关闭末端力传感器

开启或关闭末端力传感器

• 参数说明

  • sensor_mode 0代表关闭传感器，1代表开启传感器

• 返回值 ERR_SUCC 成功 其他失败

• 注意末端法兰已内置传感器的机械臂型号（如S系列）传感器已默认开启，除特殊需求外一般无需调用此接口

errno_t set_torque_sensor_mode(int sensor_mode);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//开启或关闭末端力传感器
int example_set_torque_sensor_mode()
{
    errno_t ret;
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    demo.servo_move_enable(TRUE);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    //开启或关闭末端力传感器，1打开，0关闭
    ret = demo.set_torque_sensor_mode(1);
    std::cout << ret << std::endl;
    return 0;
}

设置传感器末端负载

设置传感器末端负载

警告

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

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

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

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

• 参数说明

  • payload 末端负载，单位为kg、mm

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_torq_sensor_tool_payload(const PayLoad* payload);

获取传感器末端负载

获取传感器末端负载

• 参数说明

  • payload 末端负载，单位为kg、mm

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_torq_sensor_tool_payload(PayLoad *payload);

代码示例：

#include <iostream>
#include "JAKAZuRobot.h"
//辨识传感器负载和获取负载辨识状态，设置与获取传感器末端负载
int example_sensor_payload()
{
    JointValue joint_pos;
    PayLoad pl,pl_ret;
    errno_t ret;
    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");
    demo.power_on();
    demo.enable_robot();
    //结束位置需要根据实际设置，此处仅为示例，请勿直接使用
    joint_pos.jVal[0] = 0;
    joint_pos.jVal[1] = 0;
    joint_pos.jVal[2] = 0;
    joint_pos.jVal[3] = 0;
    joint_pos.jVal[4] = 0;
    joint_pos.jVal[5] = 0;
    //开始辨识传感器负载
    ret = demo.start_torq_sensor_payload_identify(&joint_pos);
    do
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        //查询传感器负载状态
        demo.get_torq_sensor_identify_staus(&ret);
        std::cout << ret << std::endl;
    } while (1 == ret);
    //获取辨识结果
    if(ret == 0) ret = demo.get_torq_sensor_payload_identify_result(&pl);
    std::cout << ret << std::endl;
    //设置传感器末端负载
    ret = demo.set_torq_sensor_tool_payload(&pl);
    //获取当前设置的传感器末端负载
    ret = demo.get_torq_sensor_tool_payload(&pl_ret);
    return 0;
}

获取传感器末端负载辨识状态

获取传感器末端负载辨识状态

• 参数说明

  • identify_status 0代表辨识完成结果已可以读取，1代表暂无可以读取的辨识结果，2代表辨识失败。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_torq_sensor_identify_staus(int *identify_status);

开始辨识传感器末端负载

开始辨识传感器末端负载 注意：这是一条会触发运动的指令，会使机械臂运动到jointposition指定的位置，辨识过程可能需要1-3分钟。

• 参数说明

  • joint_pos 负载辨识终点，关于终点点位设置的注意事项，请参考力控产品使用手册中对相关功能的说明。

• 返回值 ERR_SUCC 成功 其他失败

errno_t start_torq_sensor_payload_identify(const JointValue *joint_pos);

获取传感器末端负载辨识结果

获取传感器末端负载辨识结果

• 参数说明

  • payload 末端负载，单位为kg、mm

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_torq_sensor_payload_identify_result(PayLoad *payload);

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

警告

废弃接口

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

• 参数说明

  • type：0为使用网口或USB，1为使用TIO。

  • ip_addr为使用网口时传感器ip地址。

  • port为使用网口时力控传感器端口号。

  • 设置为1或使用USB时ip_addr和port不起作用，给定如示例所示的默认参数即可

• 返回值 ERR_SUCC 成功 其他失败

• 末端法兰已内置传感器的机器人型号（如S系列）系统内部已经自动指定，无需进行此项配置。

errno_t set_torque_sensor_comm(const int type, const char *ip_addr, const int port);

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

警告

废弃接口

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

• 参数说明

  • type：0为使用网口或USB，1为使用TIO。

  • ip_addr为使用网口时传感器ip地址。

  • port为使用网口时力控传感器端口号。

  • 使用TIO或USB时ip_addr和port为无效参数，返回值无实际意义

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_torque_sensor_comm(int *type, char *ip_addr,int *port);

关闭力柔顺控制

警告

废弃接口

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t disable_force_control();

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

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

• 参数说明

  • torque_sensor_filter 低通滤波器截止频率，单位：Hz

  errno_t set_torque_sensor_filter(const float torque_sensor_filter);
  

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

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

• 参数说明

  • torque_sensor_filter 低通滤波器截止频率，单位：Hz

  errno_t get_torque_sensor_filter(float *torque_sensor_filter);
  

  设置末端力传感器软限位

  设置末端力传感器软限位

• 参数说明

  • torque_sensor_soft_limit 各方向上允许的最大力或力矩数值，超过此数值将触发碰撞保护。力限位：fx, fy, fz 单位：N；力矩限位 tx, ty, tz 单位：Nm

  errno_t set_torque_sensor_soft_limit( const FTxyz torque_sensor_soft_limit);
  

  获取末端力传感器软限位

  获取末端力传感器软限位

• 参数说明

  • torque_sensor_soft_limit 各方向上允许的最大力或力矩数值，超过此数值将触发碰撞保护。力限位：fx, fy, fz 单位：N；力矩限位 tx, ty, tz 单位：Nm

  errno_t get_torque_sensor_soft_limit(FTxyz *torque_sensor_soft_limit);
  

开启或关闭工具拖拽

警告

废弃接口

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

• 参数说明

  • enable_flag 0为关闭工具拖拽，1为开启

• 返回值 ERR_SUCC 成功 其他失败

errno_t enable_admittance_ctrl(const int enable_flag);

设置力控类型和校零(初始化)选项

警告

废弃接口

设置力控类型和校零(初始化)选项

• 参数说明

  • sensor_compensation：1代表立即进行一次传感器校零，并将APP的实时力曲线显示以及torq_sensor_monitor_data.actTorque切换为实际外力；0代表不做校零操作，并将不处于力控状态下时APP的实时力曲线显示以及torq_sensor_monitor_data.actTorque切换为传感器原始读数（若处于力控状态下则仍为实际外力）。

  • compliance_type：0代表不使用任何一种柔顺控制方法，1代表开启恒力柔顺控制，2代表开启速度柔顺控制。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_compliant_type(int sensor_compensation, int compliance_type);

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

警告

废弃接口

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

• 参数说明

  • sensor_compensation 是否开启传感器补偿，1代表APP的实时力曲线显示以及torq_sensor_monitor_data.actTorque为实际外力；0代表不处于力控状态下时APP的实时力曲线显示以及torq_sensor_monitor_data.actTorque为传感器原始读数（若处于力控状态下则仍为实际外力）。

  • compliance_type 0 代表不使用任何一种柔顺控制方法 1 代表恒力柔顺控制，2 代表速度柔顺控制

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_compliant_type(int *sensor_compensation, int *compliance_type);

设置力柔顺控制参数

警告

废弃接口

设置力柔顺控制参数

• 参数说明

  • 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/(π·rad)(对于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以确保正常运作。

  • 关于对上述各参数的理解，请进一步参考171力控产品使用手册中的相关说明。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_admit_ctrl_config(int axis, int opt, double ftUser, double ftConstant, int ftNnormalTrack, double ftReboundFK);

获取力柔顺控制参数

警告

废弃接口

获取力柔顺控制参数

• 参数说明

  • admit_ctrl_cfg 机械臂力柔顺控制参数存储地址，6个AdmitCtrlType组成的数组，分别对应x,y,z,rx,ry,rz方向的力柔顺控制参数

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_admit_ctrl_config(RobotAdmitCtrl *admit_ctrl_cfg);

设置速度柔顺控制参数

警告

废弃接口

设置速度柔顺控制参数

• 参数说明

  • vel_cfg为速度柔顺控制参数

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_vel_compliant_ctrl(const VelCom *vel_cfg);

设置柔顺控制力条件

警告

废弃接口

设置柔顺控制力条件

• 参数说明

  • ft为柔顺控制力矩限制，超过限制值会减速直至停止

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_compliance_condition(const FTxyz *ft);

传感器校零

警告

废弃接口

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

errno_t zero_end_sensor();

传感器硬件级标定

警告

废弃接口

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

• 参数说明

  • type: 0：无作用。1： 进行标定。2：查询当前标定数值。

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

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

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

errno_t tio_sensor_calib(int type);

获取传感器运行状态

获取传感器运行状态

• 参数说明

  • sensor_mode: 传感器处于开启或关闭状态，0为关闭；1为开启

  errno_t get_torque_sensor_mode(int* sensor_mode);
  

获取传感器状态和数据

获取传感器运行状态

• 参数说明

  • type: 获取数据的类型，1：与torq_sensor_monitor_data.actTorque相同；2：与torq_sensor_monitor_data.torque相同，传感器原始读数；3：与torq_sensor_monitor_data.realTorque相同，减去负载重力补偿和传感器偏置后的实际受力；

  • TorqSensorData：包含传感器状态、错误码以及读数的结构体

• 注意：type为1为针对1.7.1及以下版本的兼容性接口，在1.7.2及以上版本中，此参数给定1和3获取的数值相同，但建议使用3

errno_t get_torque_sensor_data(int type, TorqSensorData* data);

设置恒力柔顺控制参数

设置恒力柔顺控制参数

• 参数说明

  • 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/(π·rad)(对于rx/ry/rz)

  • ftReboundFK：回弹，表示机械臂柔顺控制过程中与指令轨迹（或初始位置）之间的弹性系数，单位为N/mm(对于x/y/z)、Nm/rad(对于rx/ry/rz)。

  • ftConstant：代表目标力，单位为N(对于x/y/z)、Nm(对于rx/ry/rz)。

  • 关于对上述各参数的理解，请进一步参考172APP编程指令帮助172APP使用手册中的相关说明。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_ctrl_config(AdmitCtrlType admit_ctrl_cfg);

获取恒力柔顺控制参数

获取恒力柔顺控制参数

• 参数说明

  • cfg 机械臂力控柔顺控制参数存储地址，6个AdmitCtrlType组成的数组，分别对应x,y,z,rx,ry,rz方向的力柔顺控制参数

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_ctrl_config(RobotAdmitCtrl* cfg);

设置恒力柔顺控制坐标系

设置恒力柔顺控制坐标系

• 参数说明

  • ftFrame 0：力控坐标系的方向轴将实时保持与当前生效的工具坐标系平行；1：力控坐标系的方向轴将实时保持与当前生效的用户坐标系平行

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_ctrl_frame(FTFrameType ftFrame);

获取恒力柔顺控制坐标系

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

• 参数说明

  • ftFrame 0：力控坐标系的方向轴将实时保持与当前生效的工具坐标系平行；1：力控坐标系的方向轴将实时保持与当前生效的用户坐标系平行

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_ctrl_frame(FTFrameType* ftFrame);

设置力控拖拽手感参数

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

• 参数说明

  • cfg Configuration for the tool drive

  • 关于对上述各参数的理解，请进一步参考172APP使用手册172力控产品使用手册中的相关说明。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_tool_drive_config(ToolDriveConfig cfg);

获取工具拖拽参数

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

• 参数说明

  • cfg 机械臂力控柔顺控制参数存储地址，6个AdmitCtrlType组成的数组，分别对应x,y,z,rx,ry,rz方向的力柔顺控制参数

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_tool_drive_config(RobotToolDriveCtrl* cfg);

开启工具拖拽

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

• 参数说明

  • enable_flag 0 为关闭工具拖拽，1 为开启

• 返回值 ERR_SUCC 成功 其他失败

errno_t enable_tool_drive(const int enable_flag);

开启或关闭恒力柔顺控制

开启或关闭恒力柔顺控制

• 参数说明

  • enable_flag 0 为关闭，1 为开启，需要开启传感器并设置合理的柔顺控制参数，此外，推荐进行至少一次力控传感器校零后再开启恒力柔顺控制。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_ctrl_mode(BOOL enable);

设置力控终止条件

设置力控终止条件，与APP图形化编程同名指令含义相同，请参考172APP编程指令帮助172APP使用手册中的相关说明。

• 参数说明

  • condition: 6维ForceStopCondition数组：

    • axis 方向，0-5分别对用x,y,z,rx,ry,rz

    • opt 是否开启力控终止条件，0 代表没有勾选, 非 0 值代表勾选

    • lower_limit_opt 0 代表不设置下限，非 0 值代表设置

    • lower_limit 下限数值

    • upper_limit_opt 0 代表不设置下限，非 0 值代表设置

    • upper_limit 下限数值

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_force_stop_condition(ForceStopConditionList condition);

获取恒力柔顺开启状态

获取恒力柔顺开启状态

• 参数说明

  • enable，0 代表未开启，1代表开启，2代表速度模式（1.7.2及以上控制器版本中已不再支持速度模式，2仅会出现在兼容性代码中）

  errno_t get_ft_ctrl_mode(BOOL* enable);
  

  设置进近限速

  设置进近限速

• 参数说明

  • vel 线速度限制，mm/s

  • angularVel 角速度限制，rad/s

• 关于此项设置的具体含义，请参考172APP使用手册中的相关说明。

errno_t set_approach_speed_limit(double vel, double angularVel);

获取进近限速

获取进近限速

• 参数说明

  • speed_limit 线速度限制，mm/s

• 参数说明 angular_speed_limit 角速度限制，rad/s

errno_t get_approach_speed_limit(double *vel, double *angularVel);

设置恒力控制容差

设置恒力控制容差

• 参数说明

  • force 力容差，N

  • torque 力矩容差，Nm

  errno_t set_ft_tolerance(double force, double torque);
  

  获取恒力控制容差

  设置恒力控制容差

• 参数说明

  • force 力容差，N

  • torque 力矩容差，Nm

  errno_t get_ft_tolerance(double *force, double *torque);
  

  获取工具拖拽开启状态

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

• 参数说明

  • enable: 0 为关闭，1 为开启

  • state：是拖拽当前状态是否运动限制预警，其中0代表无预警，其他代表触发预警，转换为二进制后有效位数16位，从低位到高位代表的预警触发类型依次为：1-6号奇异点触发、1-9关节软限位触发、速度限制触发

• 返回值 ERR_SUCC ERR_SUCC 成功 其他失败

errno_t get_tool_drive_state(int *enable, int *state);

备注

注： state返回值仅S系列机械臂支持，其他机型此返回值无意义。 对于S系列构型，1-3号奇异点分别为肘部奇异、腕部奇异、肩部奇异，4-6号奇异点以及7-9关节的标志位无意义。

获取工具拖拽坐标系

获取工具拖拽坐标系。

• 参数说明

  • toolDragFrame 0：拖拽坐标系的方向轴将实时保持与当前生效的工具坐标系平行；1：拖拽坐标系的方向轴将实时保持与当前生效的用户坐标系平行

• 返回值 ERR_SUCC Success Other failures

errno_t get_tool_drive_frame(FTFrameType *ftFrame);

设置工具拖拽坐标系

设置工具拖拽坐标系。

• 参数说明

  • toolDragFrame 0：拖拽坐标系的方向轴将实时保持与当前生效的工具坐标系平行；1：拖拽坐标系的方向轴将实时保持与当前生效的用户坐标系平行

• 返回值 ERR_SUCC

errno_t set_tool_drive_frame(FTFrameType ftFrame);

备注

注： 以下融合拖拽、运动限制（奇异点和关节限位）预警范围相关接口仅用于S系列机械臂。 关于这些设置的具体含义，请参考APP使用手册中的相关说明。

获取融合拖拽灵敏度

获取融合拖拽灵敏度。

• 参数说明

  • level 灵敏度等级，0-5，0代表关闭，越小越不灵敏

  errno_t get_fusion_drive_sensitivity_level(int *level);
  

  设置融合拖拽灵敏度

  设置融合拖拽灵敏度。

• 参数说明

  • level 灵敏度等级，0-5，0代表关闭，越小越不灵敏

• 关于此项设置的具体含义，请参考APP使用手册中的相关说明。

errno_t set_fusion_drive_sensitivity_level(int level);

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

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

• 参数说明

  • warningRange 范围等级，1-5，越小代表预警范围越大

  errno_t get_motion_limit_warning_range(int *warningRange);
  

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

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

• 参数说明

  • warningRange 范围等级，1-5，越小代表预警范围越大

• 关于此项设置的具体含义，请参考APP使用手册中的相关说明。

errno_t set_motion_limit_warning_range(int warningRange);

获取力控限速

获取力控限速。

errno_t get_compliant_speed_limit(double *vel, double *angularVel);

设置力控限速

设置力控限速。

• 参数说明

  • speed_limit 线速度限制，mm/s

  • angular_speed_limit 角速度限制，rad/s

• 关于此项设置的具体含义，请参考APP使用手册中的相关说明。

errno_t set_compliant_speed_limit(double vel, double angularVel);

获取力矩参考中心

获取力矩参考中心。

• 参数说明

  • refPoint 0代表末端法兰中心（或传感器中心），1代表当前生效的工具坐标系中心。

  errno_t get_torque_ref_point(int *refPoint);
  

  设置力矩参考中心

  设置力矩参考中心。

• 参数说明

  • refPoint 0代表末端法兰中心（或传感器中心），1代表当前生效的工具坐标系中心。

• 关于此项设置的具体含义，请参考APP使用手册中的相关说明。

errno_t set_torque_ref_point(int refPoint);

设置传感器灵敏度

设置传感器灵敏度。

• 参数说明

  • threshold 6维数组，数值范围0~1，越大传感器越不灵敏，对于外力干扰进行响应的阈值越高

  errno_t set_end_sensor_sensitivity_threshold(FTxyz threshold);
  

获取传感器灵敏度

获取传感器灵敏度。

• 参数说明

  • threshold 6维数组，用户设置的百分比灵敏度

• 关于此项设置的具体含义，请参考APP使用手册中的相关说明。

errno_t get_end_sensor_sensitivity_threshold(FTxyz *threshold);

• 关于此项设置的具体含义，请参考APP使用手册中的相关说明。

代码示例：

 int main()
 {
    std::cout << "Hello World!";

    JAKAZuRobot demo;
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP,password替换为自己在app上设置的jaka_sdk密码
    demo.login_in("192.168.2.194",1,"jaka_sdk","password");

    std::cout << "power on: " << demo.power_on() << std::endl;
    std::cout << "enable: " << demo.enable_robot() << std::endl;

    std::cout << "enable tool drive: " << demo.enable_tool_drive(1) << std::endl;

    //set tool_drive_frame
    FTFrameType tool_drive_frame;
    demo.set_tool_drive_frame(FTFrameType::FTFrame_World);
    demo.get_tool_drive_frame(&tool_drive_frame);
    std::cout << tool_drive_frame << std::endl;

    //set torque_ref_point
    CartesianTran ref_point,ret_point;
    ref_point.x = 1;
    ref_point.y = 2;
    ref_point.z = 2;
    demo.set_ft_sensor_ref_point(&ref_point); //set to follow the TCP
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    ret = demo.get_ft_sensor_ref_point(&ret_point);
    std::cout << ret_point.x << ", " << ret_point.y << ", " << ret_point.z << std::endl;

    //compliant_speed_limit
    double vel, angvel;
    demo.set_compliant_speed_limit(500, 60);
    demo.get_compliant_speed_limit(&vel, &angvel);
    std::cout << vel << ", " << angvel << std::endl; //should be: 500, 60

    //torque_sensor_sensitivity_threshold
    FTxyz ft;
    ft.fx = 0.3;
    ft.fy = 0.3;
    ft.fz = 0.3;
    ft.tx = 0.3;
    ft.ty = 0.3;
    ft.tz = 0.3;
    demo.set_end_sensor_sensitivity_threshold(ft);
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    demo.get_end_sensor_sensitivity_threshold(&ft);
    std::cout << ft.fx << ", " << ft.fy << ", " << ft.fz << ", " << ft.tx << ", " << ft.ty << ", " << ft.tz << ", " << std::endl; //should be: 0.3, 0.3, 0.3, 0.3, 0.3, 0.3
    //lock all other directions, only open z direction
    ToolDriveConfig toolDriveCfg{};
    RobotToolDriveCtrl robToolCfg;
    for (int i = 0; i < 6; i++)
    {
        toolDriveCfg.axis = i;
        if(i == 2){
            toolDriveCfg.opt = 1;
        }
        else{
            toolDriveCfg.opt = 0;
        }
        toolDriveCfg.rigidity = 0.3;
        toolDriveCfg.rebound = 0;
        demo.set_tool_drive_config(toolDriveCfg);
    }

    demo.get_tool_drive_config(&robToolCfg);
    for (int i = 0; i < 6; i++)
    {
        std::cout << robToolCfg.config[i].axis << ", " << robToolCfg.config[i].opt << ", " << robToolCfg.config[i].rigidity << ", " << robToolCfg.config[i].rebound << std::endl;
    }

    //zero_end_sensor
    std::cout << "zero: " << demo.zero_end_sensor() << std::endl;

    //open tool drive
    demo.enable_tool_drive(1);
    int enable, state;
    demo.get_tool_drive_state(&enable, &state);
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    demo.enable_tool_drive(0);

    //退出登录
    demo.login_out();
    std::cout << "end" << std::endl;
    return 0;

}

获取传感器基本信息

• 参数说明

  • infos 指向FTSensorBasicInfoStr的指针，用于存储获取到的数据。

  • robot_id 目标机械臂的ID，如果未指定，则默认值为0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_sensor_basic_info(FTSensorBasicInfoStr *infos, int robot_id = 0);

获取传感器软限位规则

• 参数说明

  • rules 指向FTSensorSoftLimitRuleStr的指针，用于存储获取到的数据。

  • robot_id 待查询机械臂的 ID，默认为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_sensor_soft_limit_rules(FTSensorSoftLimitRuleStr *rules, int robot_id = 0);

设置传感器软限位规则

• 参数说明

  • rules 指向FTSensorSoftLimitRuleStr的指针，用于定义规则。

  • robot_id 机械臂的 ID，默认为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_sensor_soft_limit_rules(const FTSensorSoftLimitRuleStr *rules, int robot_id = 0);

设置传感器过滤参数

• 参数说明

  • sensor_id 所设置的传感器。

  • filter 指向过滤参数的指针。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_sensor_filter(int sensor_id, const double *filter);

获取传感器过滤参数

• 参数说明

  • sensor_id 传感器id。

  • filter 指向一个数组的指针，用于存储参数。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_sensor_filter(int sensor_id, double *filter);

获取传感器模式

• 参数说明

  • sensor_id 待查询的传感器ID

  • mode 指向整数的指针，用于存储模式：1 表示开启，0 表示关闭。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_sensor_mode(int sensor_id, int *mode);

校零传感器

• 参数说明

  • sensor_id 校零的传感器ID。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_sensor_zero(int sensor_id);

设置传感器阈值

• 参数说明

  • sensor_id 目标传感器ID。

  • threshold 指向包含阈值的 FTSensorThresholdStr 结构体的指针。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_contact_force_threshold(int sensor_id, const FTSensorThresholdStr *threshold);

获取传感器阈值

• 参数说明

  • sensor_id 目标传感器ID。

  • threshold 指向 FTSensorThresholdStr 的指针，用于存储阈值。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_contact_force_threshold(int sensor_id, FTSensorThresholdStr *threshold);

设置传感器参考点

• 参数说明

  • ref_point：指向 CartesianTran 的指针，包含以米为单位的 [x, y, z] 偏移量。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_sensor_ref_point(const CartesianTran *ref_point, int robot_id = 0);

获取传感器参考点

• 参数说明

  • ref_point：指向 CartesianTran 的指针，用于接收以米为单位的 [x, y, z] 偏移量。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_sensor_ref_point(CartesianTran *ref_point, int robot_id = 0);

获取传感器数据

• 参数说明

  • sensor_id：传感器的 ID。

  • type：要获取的数据类型：

    • 1 表示执行力矩（兼容接口），

    • 2 表示原始数据，

    • 3 表示去除重力和偏差后的实际数据。

  • data：指向 FTSensorDataStr 的指针，用于接收结果。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_sensor_data(int sensor_id, int type, FTSensorDataStr *data);

获取传感器负载

• 参数说明

  • sensor_id：传感器的 ID。

  • payload: 指向 PayLoad 结构体的指针，用于存储结果。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_sensor_payload(int sensor_id, PayLoad * payload);

设置传感器负载

• 参数说明

  • sensor_id：传感器的 ID。

  • payload_id：要分配的负载配置 ID。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_ft_sensor_payload(int sensor_id, int payload_id);

获取当前连接至机械臂的传感器ID

• 参数说明

  • sensor_ids：指向 FTLinkedSensorIDStr 的指针，用于接收结果。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_linked_ft_sensor_id(FTLinkedSensorIDStr *sensor_ids, int robot_id = 0);

添加传感器

• 参数说明

  • config：指向 FTSensorConfigStr 的指针，包含传感器配置信息。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t add_ft_sensor(const FTSensorConfigStr *config, int robot_id = 0);

删除传感器

• 参数说明

  • sensor_id 将要删除的传感器ID。

  • robot_id 机械臂ID，默认值为0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t remove_ft_sensor(int sensor_id, int robot_id = 0);

设置力控模式下的速度限制

• 参数说明

  • limit：指向 VelocityLimit 结构体的指针，用于指定线速度和角速度的限制。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_force_ctrl_vel_limit(const VelocityLimit *limit, int robot_id = 0);

获取力控模式下的速度限制

• 参数说明

  • limit：指向 VelocityLimit 的指针，用于接收速度限制参数。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_force_ctrl_vel_limit(VelocityLimit *limit, int robot_id = 0);

设置进近限速

备注

进近限速指：设置恒力柔顺控制开启后，机械臂末端接触到物体产生力之前那一段运动的速度限制。

• 参数说明

  • limit：指向 VelocityLimit 结构体的指针，用于指定速度限制参数。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_approaching_vel_limit(const VelocityLimit *limit, int robot_id = 0);

获取进近限速

• 参数说明

  • limit：指向 VelocityLimit 结构体的指针，用于接收速度限制参数。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_approaching_vel_limit(VelocityLimit *limit, int robot_id = 0);

设置恒力柔顺控制模式参数

• 参数说明

  • 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/(π·rad)(对于rx/ry/rz)

  • ftReboundFK：回弹，表示机械臂柔顺控制过程中与指令轨迹（或初始位置）之间的弹性系数，单位为N/mm(对于x/y/z)、Nm/rad(对于rx/ry/rz)。

  • ftConstant：代表目标力，单位为N(对于x/y/z)、Nm(对于rx/ry/rz)。

  • 关于对上述各参数的理解，请进一步参考172APP编程指令帮助172APP使用手册中的相关说明。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_cst_force_ctrl_config(const AdmitCtrlType *config, int robot_id = 0);

获取恒力柔顺控制模式参数

• 参数说明

  • config：指向 AdmitCtrlType 的指针，用于接收柔顺控制配置。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_cst_force_ctrl_config(AdmitCtrlType *config, int robot_id = 0);

设置恒力柔顺控制容差

• 参数说明

  • tol：指向 FTxyz 结构体的指针，用于指定容差值。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_cst_force_ctrl_tol(const FTxyz *tol, int robot_id = 0);

获取恒力柔顺控制容差

• 参数说明

  • tol：指向 FTxyz 结构体的指针，用于接收容差值。

  • robot_id：机械臂的 ID，默认值为 0。

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_cst_force_ctrl_tol(FTxyz *tol, int robot_id = 0);

FTP 服务

初始化FTP客户端

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t init_ftp_client();

FTP上传

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

• 参数说明

  • remote 上传到控制器内部文件名绝对路径，若为文件夹需要以“或“/”结尾

  • local 本地文件名绝对路径，若为文件夹需要以“或“/”结尾

  • opt 1单个文件 2文件夹

• 返回值 ERR_SUCC 成功 其他失败

• @note Windows C++/ Windows C#，传入参数编码为GBK；Linux为UTF-8

errno_t upload_file(char *local, char *remote, int opt);

FTP下载

从控制器下载指定类型和名称的文件到本地

• 参数说明

  • remote 控制器内部文件名绝对路径，若为文件夹需要以“或“/”结尾

  • local 下载到本地文件名绝对路径，若为文件夹需要以“或“/”结尾

  • opt 1单个文件 2文件夹

• 返回值 ERR_SUCC 成功 其他失败

• Windows C++/ Windows C#，传入参数编码为GBK；Linux为UTF-8

errno_t download_file(char *local, char *remote, int opt);

FTP目录查询

查询FTP目录

• 参数说明

  • remote 控制器内部文件名原名称，查询轨迹“/track/”,查询脚本程序“/program/”

  • opt 0文件名和子目录名 1文件名 2子目录名

  • ret 返回的查询结果

• 返回值 ERR_SUCC 成功 其他失败

• Windows C++/ Windows C#，传入参数编码为GBK；Linux为UTF-8

errno_t get_ftp_dir(const char *remotedir, int type, char *ret);

FTP删除

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

• 参数说明

  • remote 控制器内部文件名

  • opt 1单个文件 2文件夹

• 返回值 ERR_SUCC 成功 其他失败

• Windows C++/ Windows C#，传入参数编码为GBK；Linux为UTF-8

errno_t del_ftp_file(char *remote, int opt);

FTP重命名

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

• 参数说明

  • remote 控制器内部文件名原名称

  • des 重命名的目标名

  • opt 1单个文件 2文件夹

• 返回值 ERR_SUCC 成功 其他失败

• Windows C++/ Windows C#，传入参数编码为GBK；Linux为UTF-8

errno_t rename_ftp_file(char *remote, char *des, int opt);

关闭FTP客户端

断开与控制器ftp链接

• 返回值 ERR_SUCC 成功 其他失败

errno_t close_ftp_client();

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

错误代码	描述	处理建议
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 ，我们将尽快给您回复。