C++

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

接口列表

机械臂基础

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

机械臂控制类构造函数

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

JAKAZuRobot();  

机械臂登录

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

• 参数说明
  • ip  控制器ip地址
• 返回值 ERR_SUCC 成功 其他失败

errno_t  login_in(const char *ip);  

机械臂注销

断开控制器连接，该接口调用成功后，除了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"  
#include <windows.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;
}  

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

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

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

errno_t set_drag_friction_compensation_gain(int joint, int gain);

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
int example_drag()  
{
    //实例API对象demo   
    JAKAZuRobot demo; 
    BOOL in_drag;  

    demo.set_drag_friction_compensation_gain(0 , 100);
    demo.set_drag_friction_compensation_gain(1 , 100);
    demo.set_drag_friction_compensation_gain(2 , 100);
    demo.set_drag_friction_compensation_gain(3 , 100);
    demo.set_drag_friction_compensation_gain(4 , 100);
    demo.set_drag_friction_compensation_gain(5 , 100);

    return 0;
}  

获取关节摩擦补偿系数（拖拽手感参数）

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

• 参数说明
  • list 各关节摩擦力补偿系数
• 返回值 ERR_SUCC 成功 其他失败  各个机型每个关节默认值：（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

errno_t get_drag_friction_compensation_gain(DragFrictionCompensationGainList* list);

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.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"  
#include <windows.h>  
   
 //获取sdk版本号  
 int example_getsdk_version()  
 {  
    //实例API对象demo   
    JAKAZuRobot demo; 
    char ver[100];  
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //查询当前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日志路径

• 参数说明
  • filepath SDK日志路径
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_SDK_filepath(char *filepath);  

设置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(char *filepath);

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
   
 //设置SDK日志路径  
int example_set_SDK_filepath()  
{  
    //设置SDK日志路径  
    char path[20] = "D://test.log";  
    int ret  
    JAKAZuRobot demo; 
    ret = demo.set_SDK_filepath(path);//设置SDK文件路径  
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    std::cout << ret << std::endl;  
    return 0;  
} 

设置SDK是否开启调试模式

1.7.2废弃接口

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_debug_mode(BOOL mode);  

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
   
 //设置SDK是否开启调试模式  
int example_set_debug_mode()  
 {  
    BOOL mode;   
    JAKAZuRobot demo; 
    //设置调试模式，将在终端上打印调试信息  
    demo.set_debug_mode(TRUE);  
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    return 0;  
}  

获取控制器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"  
#include <windows.h>  
  
 //获取控制器ip  
int example_get_controller_ip()  
{  
    int 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 机械臂运动模式，增量运动、者绝对运动(即持续jog运动)和连续运动，参考2.13选择合适类型 ，可选类型有INCR ABS
  • coord_type 机械臂运动坐标系，工具坐标系，基坐标系（当前的世界/用户坐标系）或关节空间，参考2.12选择合适类型
  • vel_cmd 指令速度，旋转轴或关节运动单位为rad/s，移动轴单位为mm/s
  • pos_cmd 指令位置，旋转轴或关节运动单位为rad，移动轴单位为mm 当move_mode是连续时，参数可忽略
• 返回值 ERR_SUCC 成功 其他失败

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

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
  
//机械臂手动运动  
int main()  
{  
   //实例API对象demo   
   JAKAZuRobot demo; 
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.152");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //手动运动，其中INCR代表增量运动，0.5代表速度为0.5rad/s 
    demo.jog(1, INCR, COORD_JOINT , 0.5, 30);  
    Sleep(5000);  
   //手动运动停止  
    demo.jog_stop(0);  
    //机械臂去使能  
    demo.disable_robot();  
    //机械臂下电  
    demo.power_off();  
    return 0;  
}  

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

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

• 参数说明
  • num  机械臂轴号0-5，num为-1时，停止所有轴
• 返回值 ERR_SUCC 成功 其他失败

errno_t  jog_stop();  

机械臂关节运动

机械臂关节运动

• 参数说明
  • joint_pos 机械臂关节运动目标位置
  • move_mode 指定运动模式：增量运动、绝对运动
  • is_block 设置接口是否为阻塞接口，TRUE为阻塞接口 FALSE为非阻塞接口，阻塞时默认30s超时
  • speed 机械臂关节运动速度，单位：rad/s
  • acc 机械臂关节运动角加速度
  • tol 机械臂关节运动终点误差，该参数使得两段运动之间更平滑，使用该参数时需要连续多段运动，且为非阻塞状态。
  • option_cond 机械臂关节可选参数，如果不需要，该值可不赋值，填入空指针就可
• 返回值 ERR_SUCC 成功 其他失败

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

机械臂末端直线运动

机械臂末端直线运动

• 参数说明
  • end_pos 机械臂末端运动目标位置
  • move_mode 指定运动模式：增量运动、绝对运动
  • is_block 设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口，阻塞时默认30s超时
  • speed 机械臂直线运动速度，单位：mm/s
  • acc 机械臂直线运动线加速度
  • tol 机械臂直线运动终点误差.该参数使得两段运动之间更平滑，使用该参数时需要连续多段运动，且为非阻塞状态。
  • option_cond 机械臂直线运动可选参数，如果不需要，该值可不赋值，填入空指针就可
  • ori_vel 姿态速度，单位rad/s
  • ori_acc 姿态加速度，单位rad/s^2
• 返回值 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 = 50, double tol = 0, const  OptionalCond *option_cond = nullptr, double ori_vel = 3.14, double ori_acc = 12.56); 

代码示例：

int example_linear_move()  
{  

   int ret  
   //实例API对象demo   
   JAKAZuRobot demo; 
   RobotStatus status;  
   //登录控制器，需要将192.168.2.229替换为自己控制器的IP  
   demo.login_in("192.168.2.160");  
   //机械臂上电  
    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     
    printf("rx=%f , ry=%f, rz=%f", cart.rpy.rx, cart.rpy.ry, cart.rpy.rz);  
   demo.linear_move(&cart, ABS, FALSE, 200, 10 ,1,NULL);  
    for (int i = 10; 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);  
       Sleep(3000);  
    }  
    demo.login_out();  
    return 0;  
} 

机械臂圆弧运动

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

• 参数说明
  • end_pos 机械臂末端运动目标位置
  • mid_pos 机械臂末端运中间点
  • move_mode 指定运动模式：增量运动、绝对运动
  • is_block 设置接口是否为阻塞接口，TRUE 为阻塞接口 FALSE 为非阻塞接口
  • speed 机械臂直线运动速度，单位：mm/s
  • acc 机械臂笛卡尔空间加速度, 单位：mm/s^2
  • tol 机械臂笛卡尔空间运动终点误差
  • option_cond 机械臂关节可选参数，如果不需要，该值可不赋值,填入空指针就可
  • circle_cnt 指定机器人圆弧运动圈数。为0时等价于circular_move
  • circle_mode 指定机器人圆弧运动模式，参数解释如下：
    • 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, int circle_cnt = 0, int circle_mode = 0); 

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
define PI = 3.14
//机械臂圆弧运动 ，关节速度上限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  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //定义并初始化关JointValue变量  
    JointValue joint_pos = { 85.76 , -6.207 , 111.269 , 74.938 , 94.24 , 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.1415926)
#define PI_2 (1.5707963)
int example_circular_move()  
{  
    JAKAZuRobot robot;  
    robot.login_in("192.168.20.138");  
    robot.power_on();  
    robot.enable_robot();  
  
    CartesianPose start_pos {-251.054, -48.360, 374.000, 3.14, 0, 1.57};  // 开始点
    CartesianPose mid_pos = {-555.050, 116.250, 374.000, 3.14, 0, 1.57};  // 中间点
    CartesianPose end_pos = {-295.050, 267.450, 374.000, 3.14, 0, 1.57};  // 结束点
  
    robot.jog_stop(-1); // 停止当前关节运动  
      
    JointValue ref_jv {0, 90, 90, 90, -90, 0};  // 先移动到到开始点附近
    robot.joint_move(&ref_jv, MoveMode::ABS, true, 20);  
  
    JointValue start_jv;
    robot.get_joint_position(&ref_jv);  // 获取当前关节角
    robot.kine_inverse(&ref_jv, &start_pos, &start_jv); // 以当前关节角为参考，计算开始关节角 
    robot.joint_move(&start_jv, MoveMode::ABS, true, 80);  // 移动到开始关节角位置
  
    // 指定旋转3圈
    robot.circular_move(&end_pos, &mid_pos, MoveMode::ABS, true, 120, 100, 0.1, &opt, 3);  
      
    robot.disable_robot();  
    robot.power_off();  
    robot.login_out();  
}  

机械臂运动终止

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t  motion_abort();  

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
  
//机械臂运动终止  
int example_motion_abort()  
{  
   //实例API对象demo   
   JAKAZuRobot demo; 
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //定义并初始化关JointValue变量  
    printf("start_move");  
    JointValue joint_pos = { 0 , 0 , 50 , 0 , 0 , 0  };  
    //关节空间运动，其中ABS代表绝对运动，TRUE代表指令是阻塞的，1代表速度为1rad/s    
    demo.joint_move(&joint_pos, ABS, FALSE, 1);  
    Sleep(500);  
    //运动0.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 <windows.h>  
  #define PI 3.1415926 
 //查询机械臂运动是否停止  
 int example_is_in_pos()  
 {  
    //实例API对象demo   
    JAKAZuRobot demo; 
    BOOL in_pos;  
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.152");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    while (1)  
    {  
        //查询是否运动停止  
        demo.is_in_pos(&in_pos);  
        std::cout << " in_pos is :" << in_pos << std::endl;  
        Sleep(200);  
    }  
    return 0;  
}  

查询机械臂运动状态

查询机械臂运动状态. 其中1.7.1和1.7.2版本控制器非阻塞运动队列最大值为30。

• 参数说明
  • status 机械臂运动状态

errno_t get_motion_status(MotionStatus *status);

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

设置机器人阻塞等待超时时间

• 参数说明
  • seconds 时间参数，单位秒 大于0.5
• 返回值 ERR_SUCC 成功 其他失败

errno_t set_block_wait_timeout(float seconds);

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

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

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

• 参数说明
  • status 机械臂状态
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_robot_status(RobotStatus *status);  

代码示例：

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

获取当前机械臂关节角度（simple）

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

• 参数说明
  • joint_position 关节角度查询结果
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_joint_position(JointValue *joint_position); 

获取当前机械臂关节角度

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

• 参数说明
  • joint_position 关节角度查询结果
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_joint_position(JointValue *joint_position); 

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //获取当前机械臂关节角  
 int example_get_joint_position()  
 {  
    //实例API对象demo   
    JAKAZuRobot demo; 
    JointValue jot_pos;  
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    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;  
}  

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

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

• 参数说明
  • millisecond 时间参数，单位：ms
• 返回值 ERR_SUCC 成功 其他失败

errno_t set_status_data_update_time_interval(float millisecond);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //设置状态自动更新时间  
 int example_set_status_data_updata_interval()  
 {  
    float milisec = 100;  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //设置状态自动更新时间  
    ret = demo.set_status_data_update_time_interval(milisec);  
    std::cout << ret << std::endl;  
    return 0;  
} 

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

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

• 参数说明
  • tcp_position 工具末端位置查询结果
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_tcp_position(CartesianPose *tcp_position);  

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
  
//获取工具末端位姿  
int example_get_tcp_position()  
{  
   //实例API对象demo   
   JAKAZuRobot demo; 
    CartesianPose tcp_pos;  
    //登录控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    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"  
 #include <windows.h>  
   
 //用户坐标系查看及调整  
 int example_user_frame()  
 { 
    int id_ret, id_set;  
    id_set = 2;  
    CartesianPose tcp_ret, tcp_set;  
    char name[50] = "test";  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    //查询当前使用的用户坐标系ID  
    demo.get_user_frame_id(&id_ret);  
    //获取当前使用的用户坐标系信息  
    demo.get_user_frame_data(id_ret, &tcp_ret);  
    printf("id_using=%d nx=%f, y=%f, z=%f", id_ret, tcp_ret.tran.x, tcp_ret.tran.y, tcp_ret.tran.y);  
    printf("rx=%f, ry=%f, rz=%f", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
    //初始化用户坐标系坐标  
    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);  
    printf("id_using=%d nx=%f, y=%f, z=%f", id_ret, tcp_ret.tran.x, tcp_ret.tran.y, tcp_ret.tran.y);  
    printf("rx=%f, ry=%f, rz=%f", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
    return 0;  
 } 

获取用户坐标系信息

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

• 参数说明
  • id 用户坐标系ID
  • tcp 用户坐标系偏置值
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_user_frame_data(int id, CartesianPose *tcp);  

设置当前使用的用户坐标系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"  
 #include <windows.h>  
   
 //工具坐标系查看及调整  
 int example_tool()  
 {  
    int id_ret,id_set;  
    id_set = 2;  
    CartesianPose tcp_ret,tcp_set;  
    char name[50] = "test";  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    //查询当前使用的工具ID  
    demo.get_tool_id(&id_ret);  
    //获取当前使用的工具信息  
    demo.get_tool_data(id_ret,&tcp_ret);  
    printf("id_using=%d nx=%f, y=%f, z=%f", id_ret, tcp_ret.tran.x, tcp_ret.tran.y, tcp_ret.tran.y);  
    printf("rx=%f, ry=%f, rz=%f", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
    //初始化工具坐标  
    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);  
    printf("id_using=%d nx=%f, y=%f, z=%f", id_ret, tcp_ret.tran.x, tcp_ret.tran.y, tcp_ret.tran.y);  
    printf("rx=%f, ry=%f, rz=%f", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
    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类型
  • index DO索引（从0开始）
  • value DO设置值
• 返回值 ERR_SUCC 成功 其他失败

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

代码示例：

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

设置模拟输出变量

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

• 参数说明
  • type AO类型 ; 做modbus从站IO时，索引为4
  • index AO索引 （从0开始）
  • value AO设置值
• 返回值 ERR_SUCC 成功 其他失败

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

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
//设置与查询模拟输出  
int main()  
{  
   JAKAZuRobot demo; 
   demo.login_in("192.168.2.152");  
   demo.power_on();  
   float AO35;  
    //查询Ao的状态  
    demo.get_analog_output(IO_CABINET, 0, &AO35);  
    printf("A035 = %f", AO35);  
   //io_cabinet是控制柜面板IO，2代表DO3，1.5对应要设置的DO值。  
   demo.set_analog_output(IO_CABINET, 0, 1.5);  
   Sleep(1000);//需要window.h延时1s  
   //查询Ao的状态  
   demo.get_analog_output(IO_CABINET, 0, &AO35);  
   printf("A035 = %f", AO35);  
   return 0;  
} 

运动中设置数字输出变量

只适配控制器版本1.7.2 运动中设置数字输出变量(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);

运动中设置模拟输出变量

只适配控制器版本1.7.2 运动中设置模拟输出变量(AO)的值

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

errno_t set_motion_digital_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; 
   demo.login_in("192.168.2.194");  
   demo.power_on();  
    //查询TIO的状态  
    demo.is_extio_running(&is_running);  
    printf("tio = %d", is_running);     
   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  
   demo.login_in("192.168.2.194");  
   //查询当前负载数据  
    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 信号量参数
• 返回值 ERR_SUCC 成功 其他失败

errno_t add_tio_rs_signal(SignInfo sign_info);  

代码示例：

 void example_add_tio_rs_signal()  
 {  
    JAKAZuRobot robot;  
    robot.login_in("192.168.20.138");  
    robot.power_on();  
    robot.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;  
  
    robot.add_tio_rs_signal(sign_info);  
      
    robot.disable_robot();  
    robot.power_off();  
    robot.login_out();  
}  

TIO删除信号量

删除信号量

• 参数说明
  • sig_name 信号量名称
• 返回值 ERR_SUCC 成功 其他失败

errno_t del_tio_rs_signal(const char *sig_name);

代码示例：

 void example_del_tio_rs_signal()  
 {  
    JAKAZuRobot robot;  
    robot.login_in("192.168.20.138");  
    robot.power_on();  
    robot.enable_robot();  
   
    const char* name = "sign_tmp";  
    robot.del_tio_rs_signal(name);   
    robot.disable_robot();  
    robot.power_off();  
    robot.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 robot;  
    robot.login_in("192.168.20.138");  
    robot.power_on();  
    robot.enable_robot();  
   
    uint8_t cmd[] = {'t', 'e', 's', 't', 'c', 'm', 'd'};  
    robot.send_tio_rs_command(0, cmd, sizeof(cmd));  
      
    robot.disable_robot();  
    robot.power_off();  
    robot.login_out();     
}  

TIO 刷新信号量信息

刷新信号量信息

• 参数说明
  • SignInfo 信号量信息数组
• 返回值 ERR_SUCC 成功 其他失败

errno_t update_tio_rs_signal(SignInfo_simple sign_info);  

TIO 获取信号量信息

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

• 参数说明
  • SignInfo* 信号量信息数组
• 返回值 ERR_SUCC 成功 其他失败

errno_t get_rs485_signal_info(SignInfo *sign_info);  

代码示例：

void example_get_rs485_signal_info()  
{  
   JAKAZuRobot robot;  
   robot.login_in("192.168.20.138");  
   robot.power_on();  
   robot.enable_robot();  
  
   SignInfo sign_info[256];  
   robot.get_rs485_signal_info(sign_info);  
      
    robot.disable_robot();  
    robot.power_off();  
    robot.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通讯参数配置

• 参数说明
  • ModRtuComm 当通道模式设置为Modbus RTU时，需额外指定Modbus从站节点ID
• 返回值 ERR_SUCC 成功 其他失败

errno_t set_rs485_chn_comm(ModRtuComm mod_rtu_com);  

TIO RS485通讯参数查询

RS485通讯参数查询

• 参数说明
  • ModRtuComm 查询时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);  

代码示例：

 #include <JAKAZuRobot.h>    
 #include <iostream>    
     
 int main()    
 {    
     JAKAZuRobot robot;    
     errno_t ret = robot.login_in("192.168.137.152");    
     if (ret != ERR_SUCC)    
     {    
        std::cerr << "login failed.";    
         return -1;    
     }    
     
     ret = robot.set_installation_angle(3.14, 0);    
     if (ret != ERR_SUCC)    
     {    
         std::cerr << "set installation angle failed.";    
         return -1;    
     }    
     
     Quaternion quat;    
     Rpy rpy;    
     ret = robot.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 = robot.login_out();    
     if (ret != ERR_SUCC)    
     {    
         std::cerr << "login out failed.";    
         return -1;    
     }    
     
     return 0;    
 }    

设置机器人安装角度

设置安装角度

• 参数说明
  • angleX 绕X轴旋转角度
  • angleZ 绕Z轴旋转角度
• 返回值 ERR_SUCC 成功 其他失败

errno_t set_installation_angle(double angleX, double angleZ);  

代码示例：

#include <JAKAZuRobot.h>    
#include <iostream>    
    
int main()    
{    
    JAKAZuRobot robot;    
    errno_t ret = robot.login_in("192.168.137.152");    
    if (ret != ERR_SUCC)    
    {    
        std::cerr << "login failed.";    
        return -1;    
    }    
    
    ret = robot.set_installation_angle(3.14, 0);    
    if (ret != ERR_SUCC)    
    {    
        std::cerr << "set installation angle failed.";    
        return -1;    
    }    
    
    Quaternion quat;    
    Rpy rpy;    
    ret = robot.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 = robot.login_out();    
    if (ret != ERR_SUCC)    
    {    
        std::cerr << "login out failed.";    
        return -1;    
    }    
    
    return 0;    
}    

设置系统变量

设置系统变量

errno_t set_user_var(UserVariable v);

获取机械臂状态

获取机械臂状态

• 参数说明
  • state 机械臂状态查询结果
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_robot_state(RobotState *state);  

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
  
//获取机械臂状态(急停 上电 伺服使能)  
int example_get_robstate()  
{  
   JAKAZuRobot demo; 
   //声明机械臂状态结构体  
    RobotState state;  
    demo.login_in("192.168.2.152");  
    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;  
}  

获取系统变量

获取系统变量

errno_t get_user_var(UserVariableList *vlist);

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

查询机械臂是否超出限位

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

• 参数说明
  • on_limit 查询结果
• 返回值 ERR_SUCC 成功 其他失败

errno_t  is_on_limit(BOOL *on_limit);  

代码示例：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
  
//查询是否超出限位  
int example_is_on_limit()  
{  
   JAKAZuRobot demo; 
   BOOL on_limit;  
    demo.login_in("192.168.2.152");  
    demo.power_on();  
    demo.enable_robot();  
    while (1)  
    {  
        //查询是否超限  
        demo.is_on_limit(&on_limit);  
        std::cout << " on_limit is :" << on_limit << std::endl;  
        Sleep(200);  
    }  
    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"  
 #include <windows.h>  
   
 //碰撞保护状态查询，恢复  
 int example_collision_recover()  
 {  
    JAKAZuRobot demo; 
    BOOL in_collision;  
    demo.login_in("192.168.2.152");  
    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"  
#include <windows.h>  
  
//碰撞等级查看，设置  
int example_collision_level()  
{  
   //实例API对象demo   
   JAKAZuRobot demo; 
    int level;  
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.152");  
    //机械臂上电  
    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;  
}  

获取机器设置的碰撞等级

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t get_collision_level(int *level);  

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

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

• 参数说明
  • millisecond 时间参数，单位：ms，范围为500-30000ms，若设置超出该范围，则实际生效的时间为2s
  • mnt 网络异常时机械臂需要进行的动作类型
• 返回值 ERR_SUCC 成功 其他失败

errno_t set_network_exception_handle(float millisecond, ProcessType mnt);

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //设置网络异常时机械臂自动终止运动类型  
 int example_set_network_exception_handle()  
 {  
    float milisec = 100;  
    int ret  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    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);

错误状态清除

• 返回值 ERR_SUCC 成功 其他失败

errno_t  clear_error();

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

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

• 参数说明
  • func 指向用户定义的函数的函数指针
  • error_code 机械臂的错误码

errno_t set_error_handler(CallBackFuncType func);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //注册机械臂出错函数 错误处理，类中断  
 void user_error_handle(int error_code)  
 {  
     std::cout << error_code << std::endl;  
 }  
int example_set_err_handle()  
{  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.229");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //设置用户异常回调函数  
    demo.set_error_handler(user_error_handle);  
    return 0;  
} 

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

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t set_errorcode_file_path(char *path);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //错误码查看  
 int example_get_last_errcode()  
 {  
    int ret  
    //初始化错误码文件存放路径  
    char path[100] = "E:JAKA_ERROR_CODE.csv";   
    JAKAZuRobot demo; 
    ErrorCode Eret;  
    demo.login_in("192.168.2.194");  
    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.set_errorcode_file_path(path);//设置错误码说明文件  
    demo.get_last_error(&Eret);//查询最后一个报错信息  
    std::cout << " error code is :" << Eret.code << " message: " << Eret.message << std::endl;  
    return 0;  
}  

使用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; 
    ProgramState pstatus;  
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    //加载预先通过app编辑完成的example脚本  
    demo.program_load("example");  
    //获取已加载的程序名  
    demo.get_loaded_program(name);  
    std::cout <<"Pro_name is :"<< name << std::endl;  
    //运行当前加载的程序  
    demo.program_run();  
    Sleep(1000);//让程序先运行1s  
    //暂停当前运行的程序  
    demo.program_pause();  
    //获取当前执行程序的行号  
    demo.get_current_line(&cur_line);  
    std::cout << "cur_line is :" << cur_line << std::endl;  
    //获取当前程序状态  
    demo.get_program_state(&pstatus);  
    std::cout <<  "pro_status is : " << pstatus << std::endl;  
    //继续运行当前程序  
    demo.program_resume();  
    Sleep(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 程序文件路径
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_loaded_program(char *file);  

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

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

• 参数说明
  • curr_line 当前行号查询结果
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_current_line(int *curr_line);  

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

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

• 参数说明
  • status 作业程序执行状态查询结果
• 返回值 ERR_SUCC 成功 其他失败

errno_t  get_program_state(ProgramState *status);  

设置机械臂的运行倍率

设置机械臂运行倍率

• 参数说明
  • rapid_rate 是程序运行倍率，设置范围为[0,1]
• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_rapidrate(double rapid_rate);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //机械臂速度查看及调整  
 int example_rapidrate()  
 {  
    double rapid_rate;  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.152");  
    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);  
    Sleep(100);  
    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 轨迹复现配置参数
• 返回值 ERR_SUCC 成功 其他失败

errno_t  set_traj_config(const TrajTrackPara *para);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //轨迹复现参数查看及设置  
 int example_traj_config()  
 {  
    JAKAZuRobot demo; 
    TrajTrackPara trajpar_read;  
    TrajTrackPara trajpar_set;  
    demo.login_in("192.168.2.194");  
    //查询当前轨迹复现参数  
    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 <windows.h>  
   
 //轨迹采集开关与状态查询  
 int example_traj_sample()  
 {  
    BOOL samp_stu;  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    char name[20] = "testxx";  
    //开启轨迹复现数据采集开关  
    demo.set_traj_sample_mode(TRUE, name);  
    //查询轨迹复现采集状态  
    demo.get_traj_sample_status(&samp_stu);  
    Sleep(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);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //查询控制器中已经存在的轨迹复现数据的文件名  
 int example_get_traj_existed_filename()  
 {  
    JAKAZuRobot demo; 
    MultStrStorType traj_file;  
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //查询当前轨迹文件名。  
    demo.get_exist_traj_file_name(&traj_file);  
    std::cout << "file nums :" << traj_file.len << std::endl;  
    for(int i=0; i<traj_file.len;i++)  
        std::cout << traj_file.name[i] << std::endl;  
    return 0;  
}  

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

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

• 参数说明
  • src 原文件名
  • dest 目标文件名，文件名长度不能超过100个字符，文件名不能为空，目标文件名不支持中文
• 返回值 ERR_SUCC 成功 其他失败

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

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //重命名轨迹复现的数据文件名  
 int example_rename_traj_file_name()  
 {  
    JAKAZuRobot demo; 
    MultStrStorType traj_file;  
    char name_new[20] = "555";  
    demo.login_in("192.168.2.194");  
    //查询当前轨迹文件名。  
    demo.get_exist_traj_file_name(&traj_file);  
    std::cout << "file nums :" << traj_file.len << std::endl;  
    for (int i = 0; i < traj_file.len; i++)
    {
        std::cout << traj_file.name[i] << std::endl;  
    }
    //重命名轨迹复现的数据文件名  
    demo.rename_traj_file_name(traj_file.name[0], name_new);  
    //查询当前轨迹文件名。  
    demo.get_exist_traj_file_name(&traj_file);  
    std::cout << "file nums :" << traj_file.len << std::endl;  
    for (int i = 0; i < traj_file.len; i++)
    {
        std::cout << traj_file.name[i] << std::endl;  
    }
    return 0;  
}  

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

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

• 参数说明
  • filename 要删除的文件的文件名，文件名为数据文件名字
• 返回值 ERR_SUCC 成功 其他失败

errno_t  remove_traj_file(const char *filename);  

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

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

• 参数说明
  • filename 数据文件的文件名，文件名为数据文件名字，不带后缀
• 返回值 ERR_SUCC 成功 其他失败

errno_t  generate_traj_exe_file(const char *filename);  

机械臂伺服运动模式

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

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

• 参数说明
  • enable  TRUE为进入伺服位置控制模式，FALSE表示退出该模式
• 返回值 ERR_SUCC 成功 其他失败
• Ps:v19及之前的版本该接口为非阻塞指令，V20之后该指令变为为阻塞指令。

errno_t  servo_move_enable(BOOL enable);  

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

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

• 参数说明
  • joint_pos 机械臂关节运动目标位置
  • move_mode 指定运动模式：增量运动、绝对运动和连续运动
• 返回值 ERR_SUCC成功 其他失败

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

代码示例：

 //机械臂伺服关节运动  
 //使用该接口时需要先调用servo_move_enable(TRUE)开启伺服控制  
 //控制器的发送周期为8ms，建议用户发送周期也为8ms，网络环境较差的情况可以适当减小周期  
 //关节速度上限180rad/s  
 //本指令与joint_move有较大差别，joint_move的插补由控制器进行，servo_j需要预先进行轨迹规划。  
 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
int main()  
{  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.152");  
    //机械臂上电  
    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的倍数

• 参数说明
  • joint_pos 机械臂关节运动目标位置
  • move_mode 指定运动模式：增量运动、绝对运动
• • step_num 倍分周期，servo_j运动周期为step_num*8ms，其中step_num>=1
• 返回值 ERR_SUCC成功 其他失败

errno_t  servo_j(const JointValue *joint_pos, MoveMode move_mode, unsigned int step_num); 
``` 
### 机械臂笛卡尔空间伺服模式运动
机械臂笛卡尔空间位置控制模式  
* 参数说明 
    * cartesian_pose 机械臂笛卡尔空间运动目标位置 
    * move_mode 指定运动模式：增量运动、绝对运动和连续运动 
* 返回值 ERR_SUCC 成功 其他失败 
```c++
errno_t  servo_p(const CartesianPose *cartesian_pose, MoveMode move_mode);

代码示例：

 //机械臂伺服笛卡尔空间运动  
 //使用该接口时需要先调用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  
    demo.login_in("192.168.2.152");  
    //机械臂上电  
    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的倍数

• 参数说明
  • cartesian_pose 机械臂笛卡尔空间运动目标位置
  • move_mode 指定运动模式：增量运动、绝对运动
  • step_num 倍分周期，servo_p运动周期为step_num*8ms，其中step_num>=1
• 返回值 ERR_SUCC 成功 其他失败

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

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

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t  servo_move_use_none_filter();  

代码示例：

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

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

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

errno_t  servo_move_use_joint_LPF(double cutoffFreq);  

• 参数说明
  • cutoffFreq 一阶低通滤波器截止频率
• 返回值 ERR_SUCC 成功 其他失败

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //servo模式下关节空间一阶低通滤波  
 int example_servo_use_joint_LPF()  
 {  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    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^2
  • max_jr 笛卡尔空间姿态变化速度的加加速度上限值（绝对值）°/s^3
• 返回值 ERR_SUCC 成功 其他失败

errno_t  servo_move_use_joint_NLF(double max_vr, double max_ar, double max_jr); 
``` 
**代码示例：**

```c++
 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //servo模式下关节空间非线性滤波  
 int example_servo_use_joint_NLF()  
 {  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    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^2
  • max_jp 笛卡尔空间下移动指令加加速度的上限值（绝对值）单位：mm/s^3
  • max_vr 笛卡尔空间姿态变化速度的速度上限值（绝对值）°/s
  • max_ar 笛卡尔空间姿态变化速度的加速度上限值（绝对值）°/s^2
  • max_jr 笛卡尔空间姿态变化速度的加加速度上限值（绝对值）°/s^3
• 返回值 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);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //servo模式下笛卡尔空间非线性滤波  
 int example_servo_use_carte_NLF()  
 {  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    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 位置滤波系数
• 返回值 ERR_SUCC 成功 其他失败

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

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
 #define PI 3.1415926 
 //servo模式下关节空间多阶均值滤波  
 int example_servo_use_joint_MMF()  
 {  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    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 加速度滤波系数
  • kv 速度滤波系数
  • ka 位置滤波系数
• 返回值 ERR_SUCC 成功 其他失败

errno_t servo_speed_foresight(int max_buf, double kp);

代码示例：

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

机械臂EDG（External Data Guider）功能

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

机械臂EDG使能

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

• 参数说明
  • en  使能开关，true为开启EDG功能，false表示退出该功能
  • edg_stat_ip  sdk客户端IP地址
• 返回值 ERR_SUCC 成功 其他失败  Ps: 使能后不能调用servo_j和servo_p;必须调用edg_init(false)关闭EDG功能后才能调用servo_j和servo_p

errno_t edg_init(BOOL en = true, std::string edg_stat_ip = "0.0.0.0");

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

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

• 参数说明
  • edg_state EDG反馈数据（包括关节位置、速度、力矩、笛卡尔位置、传感器数据）
  • robot_index 使用默认值，无须传参
• 返回值 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 指定运动模式：增量运动、绝对运动
  • step_num 倍分周期，edg_servo_j运动周期为step_num*8ms，其中step_num>=1
  • robot_index 使用默认值，无须传参
• 返回值 ERR_SUCC成功 其他失败    Ps: 该接口相比于原先的servo_j接口，实时控制的性能更好

errno_t edg_servo_j(const JointValue *joint_pos, MoveMode move_mode, unsigned int step_num = 1, unsigned char robot_index = 0);
``` 
**代码示例：**

```c++
#include "JAKAZuRobot.h"
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <pthread.h>
#include "timespec.h"
#include <iostream>  
#include "JAKAZuRobot.h"  
#include <time.h>  
#include <thread>
#include <chrono>
   
using namespace std;
#define rad2deg(x) ((x)*180.0/M_PI)
#define deg2rad(x) ((x)*M_PI/180.0)
JAKAZuRobot robot;  
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_stat_time_test()
{
    robot.clear_error();
    ret = robot.servo_move_enable(0);
    check_return(ret, "servo_move_enable");
    ret = robot.edg_init(false);
    check_return(ret, "edg_init");
    ret = robot.servo_move_use_none_filter();
    check_return(ret, "servo_move_use_none_filter");
    JointValue jpos = {0, deg2rad(90), deg2rad(-90), deg2rad(90), deg2rad(90), 0};  
    ret = robot.joint_move(&jpos, ABS, TRUE, 10);  
    check_return(ret, "joint_move");
    JointValue jpos_cmd;
    memset(&jpos_cmd,0,sizeof(jpos_cmd));
    sched_param sch;
    sch.sched_priority = 90;
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &sch);
    timespec next;
    ret = robot.edg_init(true,"192.168.75.141");
    check_return(ret, "edg_init");
    ret = robot.servo_move_enable(1); //必须先调用edg_init后再调用servo_move_enable
    check_return(ret, "servo_move_enable");
    clock_gettime(CLOCK_REALTIME, &next);
    for(int i = 0;i<2000;i++)
    {
        timespec cc;
        timespec max_wkup_time;
        clock_gettime(CLOCK_REALTIME, &cc);
        EDGState edgdata;
        CartesianPose cpos;
        int64_t recv_time = 0;
        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 = robot.edg_servo_j(&jpos_cmd,MoveMode::ABS);
        check_return(ret, "edg_servo_j");
        ret = robot.edg_get_stat(&edgdata);
        check_return(ret, "edg_get_stat");
        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] << endl;
        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] << endl;
        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] << endl;
        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 << endl;
        cout << "sensor:" << edgdata.torqSensor.fx << "," << edgdata.torqSensor.fy << "," << edgdata.torqSensor.fz
        << "," << edgdata.torqSensor.tx << "," << edgdata.torqSensor.ty << "," << edgdata.torqSensor.tz << endl;
        unsigned long int detail[3];
        ret = robot.edg_stat_details(detail);
        check_return(ret, "edg_stat_details");
        cout << "detail:" << detail[0] << "," << detail[1] << "," << detail[2] << endl;
        //等待下一个周期
        timespec dt;
        dt.tv_nsec = 8000000;
        dt.tv_sec = 0;
        next = timespec_add(next, dt);
        clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &next, NULL);
    }
    ret = robot.edg_init(false);
    check_return(ret, "edg_init");
    ret = robot.servo_move_enable(0);
    check_return(ret, "servo_move_enable");
}

int main()
{
    robot.login_in("172.30.95.84",false);
    robot.power_on();
    robot.enable_robot();
    std::this_thread::sleep_for(std::chrono::seconds(3));
    edg_servoj_test();
    robot.edg_init(false);
    robot.servo_move_enable(0);
    robot.servo_move_use_none_filter();
    robot.login_out();
    return 0;
}

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

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

• 参数说明
  • cartesian_pose 机械臂笛卡尔空间运动目标位置
  • move_mode 指定运动模式：增量运动、绝对运动和连续运动
  • step_num 倍分周期，edg_servo_p运动周期为step_num*8ms，其中step_num>=1
  • robot_index 使用默认值，无须传参
• 返回值 ERR_SUCC 成功 其他失败  Ps: 该接口相比于原先的servo_p接口，实时控制的性能更好

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

代码示例：

#include "JAKAZuRobot.h"
#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <pthread.h>
#include "timespec.h"
#include <iostream>  
#include "JAKAZuRobot.h"  
#include <time.h>  
#include <thread>
#include <chrono>
   
using namespace std;
#define rad2deg(x) ((x)*180.0/M_PI)
#define deg2rad(x) ((x)*M_PI/180.0)
JAKAZuRobot robot;  
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_servop_test()
{
    robot.clear_error();
    ret = robot.servo_move_enable(0);
    check_return(ret, "servo_move_enable");
    ret = robot.edg_init(false);
    check_return(ret, "edg_init");
    ret = robot.servo_move_use_none_filter();
    check_return(ret, "servo_move_use_none_filter");
    JointValue jpos = {0, deg2rad(90), deg2rad(-90), deg2rad(90), deg2rad(90), 0};  
    ret = robot.joint_move(&jpos, ABS, TRUE, 10);  
    check_return(ret, "joint_move");
    CartesianPose cpos_init, cpos_cmd;
    robot.kine_forward(&jpos,&cpos_init);
    sched_param sch;
    sch.sched_priority = 90;
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &sch);
    ret = robot.edg_init(true,"192.168.75.141");
    check_return(ret, "edg_init");
    ret = robot.servo_move_enable(1);
    check_return(ret, "servo_move_enable");
    timespec next;
    clock_gettime(CLOCK_REALTIME, &next);

    for(int i=0;i<4000;i++)
    {
        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 = robot.edg_servo_p(&cpos_cmd,MoveMode::ABS);
        check_return(ret, "edg_servo_p");
        timespec dt;
        dt.tv_nsec = 8000000;
        dt.tv_sec = 0;
        next = timespec_add(next, dt);
        clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &next, NULL);
    }
    ret = robot.edg_init(false);
    check_return(ret, "edg_init");
    ret = robot.servo_move_enable(0);
    check_return(ret, "servo_move_enable");
}

int main()
{
    robot.login_in("172.30.95.84",false);
    robot.power_on();
    robot.enable_robot();
    std::this_thread::sleep_for(std::chrono::seconds(3));
    edg_servop_test();
    robot.edg_init(false);
    robot.servo_move_enable(0);
    robot.servo_move_use_none_filter();
    robot.login_out();
    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"  
 #include <windows.h>  
   
 // 机械臂逆解 已知tcp_pos,求joint_pos  
 int example_kine_inverse()  
 {  
    int ret  
    JAKAZuRobot demo; 
    //初始化参考点  
    JointValue ref_jpos = { 0.558, 0.872, 0.872 , 0.349, 0.191, 0.191 };  
    //初始化笛卡尔空间点坐标  
    CartesianPose tcp_pos;  
    tcp_pos.tran.x = 243.568; tcp_pos.tran.y = 164.064; tcp_pos.tran.z = 742.002;  
    tcp_pos.rpy.rx = -1.81826; tcp_pos.rpy.ry = -0.834253;  tcp_pos.rpy.rz = -2.30243;  
    //初始化返回值  
    JointValue joint_pos = { 0,0,0,0,0,0 }; ;  
    demo.login_in("192.168.2.194");  
    //求逆解  
    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] << std::endl;  
    }  
    return 0;  
}  

机械臂求解逆解拓展

只适配控制器版本1.7.2 计算指定位姿在指定工具、当前安装角度以及指定用户坐标系设置下的逆解

• 参数说明
  • 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"  
 #include <windows.h>  
   
 // 4.55机械臂正解 已知joint_pos,求tcp_pos  
 int example_kine_forward()  
 {  
    int ret  
    JAKAZuRobot demo; 
    //初始化返回值  
    CartesianPose tcp_pos;  
    demo.login_in("192.168.2.194");  
    //初始化关节矩阵  
    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;  
}   

机械臂求解正解拓展

只适配控制器版本1.7.2 计算指定关节位置在指定工具、当前安装角度以及指定用户坐标系设置下的位姿值

• 参数说明
  • 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"  
 #include <windows.h>  
   
 // 4.56欧拉角到旋转矩阵  
 int example_rpy_to_rot_matrix()  
 {  
    int ret   
    JAKAZuRobot demo; 
    //初始化旋转矩阵  
    Rpy rpy;  
    rpy.rx = -1.81826; rpy.ry = -0.834253;  rpy.rz = -2.30243;  
    //初始化返回值  
    RotMatrix rot_matrix;  
    demo.login_in("192.168.2.194");  
    //欧拉角变换成旋转矩阵  
    ret = demo.rpy_to_rot_matrix(&rpy, &rot_matrix);  
    std::cout << ret << "eul2rotm" << std::endl;  
    printf("%f %f %f", rot_matrix.x.x, rot_matrix.y.x, rot_matrix.z.x);  
    printf("%f %f %f", rot_matrix.x.y, rot_matrix.y.y, rot_matrix.z.y);  
    printf("%f %f %f", rot_matrix.x.z, rot_matrix.y.z, rot_matrix.z.z);  
    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"  
 #include <windows.h>  
   
 // 4.57旋转矩阵--->欧拉角  
 int example_rot_matrix_to_rpy()  
 {  
    int 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  
    demo.login_in("192.168.2.194");  
    ret = demo.rot_matrix_to_rpy(&rot_matrix, &rpy);  
    std::cout << ret << "rotm2eul:" << std::endl;  
    printf("%f %f %f ", rpy.rx, rpy.ry, rpy.rz);  
    return 0;  
}  

四元数到旋转矩阵的转换

四元数到旋转矩阵的转换

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

• 参数说明
  • quaternion 待转换的四元数数据
  • rot_matrix 转换后的旋转矩阵结果
• 返回值 ERR_SUCC 成功 其他失败

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 // 4.58四元数-->旋转矩阵  
 int example_quaternion_to_rot_matrix()  
 {  
    int 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  
    demo.login_in("192.168.2.194");  
    ret = demo.quaternion_to_rot_matrix(&quat, &rot_matrix);  
    std::cout << ret << "quatl2rotm:" << std::endl;  
    printf("%f %f %f\n", rot_matrix.x.x, rot_matrix.y.x, rot_matrix.z.x);  
    printf("%f %f %f\n", rot_matrix.x.y, rot_matrix.y.y, rot_matrix.z.y);  
    printf("%f %f %f\n", rot_matrix.x.z, rot_matrix.y.z, rot_matrix.z.z);  
    return 0;  
} 

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

获取机器人DH参数

• 参数说明
  • dhParam DH参数
• 返回值 ERR_SUCC 成功 其他失败

errno_t get_dh_param(const JKHD *handle, DHParam *dhParam);  

旋转矩阵到四元数的转换

旋转矩阵到四元数的转换

• 参数说明
  • rot_matrix 待转换的旋转矩阵
  • quaternion 转换后的四元数结果
• 返回值 ERR_SUCC 成功 其他失败

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

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 // 4.59旋转矩阵--->四元数  
 int example_rot_matrix_to_quaternion()  
 {  
    int 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  
    demo.login_in("192.168.2.194");  
    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"  
 #include <windows.h>  
   
 //设置末端力传感器型号
 int example_set_torsensor_brand()  
 {  
    int ret  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    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"  
 #include <windows.h>  
   
 //获取末端力传感器型号
 int example_get_torsensor_brand()  
 {  
    int ret,cur_sensor;  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    //获取末端力传感器型号
    ret = demo.get_torsenosr_brand(&cur_sensor);  
    std::cout << ret << 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"  
 #include <windows.h>  
   
 //开启或关闭末端力传感器
 int example_set_torque_sensor_mode()  
 {  
    int ret  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    demo.servo_move_enable(TRUE);  
    Sleep(200);  
    //开启或关闭末端力传感器，1打开，0关闭  
    ret = demo.set_torque_sensor_mode(1);  
    std::cout << ret << std::endl;  
    return 0;  
}  
::: warning 注意： 请仔细区分set_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"  
 #include <windows.h>  
   
 //辨识传感器负载和获取负载辨识状态，设置与获取传感器末端负载  
 int example_sensor_payload()  
 {  
    JointValue joint_pos;  
    PayLoad pl,pl_ret;  
    int ret  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    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  
    {  
        Sleep(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);  

代码示例：

 int example_torque_sensor_comm()  
 {  
    char ip_set[30]="192.168.2.108";  
    int ret=2;  
    int type_set = 0,port_set = 4008;  
    char ip_ret[30]="1";  
    int type_ret = 0, port_ret = 0;  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.105替换为自己控制器的IP  
    printf("logining!");  
    demo.login_in("192.168.2.106");  
    //机械臂上电  
    printf("powering");  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //设置传感器型号
    ret = demo.set_torsenosr_brand(4);  
    //获取传感器通讯参数  
    ret = demo.get_torque_sensor_comm(&type_ret, ip_ret, &port_ret);  
    std::cout << ret << std::endl;  
    std::cout << ip_ret << std::endl;  
    std::cout << port_ret << std::endl;  
    std::cin >> type_ret;  
    //设置传感器通信参数  
    ret = demo.set_torque_sensor_comm(type_set, ip_set, port_set);  
    std::cout << ret << std::endl;  
    std::cout << ip_set << std::endl;  
    std::cout << port_set << std::endl;  
    std::cin >> type_set;  
    return 0;  
}  

兼容性接口保留。

适配1.7.1控制器，1.7.2请调用set_ft_ctrl_mode接口。

关闭力柔顺控制

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

• 返回值 ERR_SUCC 成功 其他失败

errno_t disable_force_control(); 

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //关闭力柔顺控制
 int example_disable_force_control()  
 {  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //关闭力矩控制  
    ret = demo.disable_force_control();  
    std::cout << ret << std::endl;  
    return 0;  
}  

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

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

• 参数说明
  • 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);

开启或关闭工具拖拽

兼容性接口保留。

适配1.7.1控制器，1.7.2为对应替代接口。

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

• 参数说明
  • enable_flag 0为关闭工具拖拽，1为开启
• 返回值 ERR_SUCC 成功 其他失败

errno_t enable_admittance_ctrl(const int enable_flag); 

代码示例：

 #include <iostream>    
 #include "JAKAZuRobot.h"    
 #include <windows.h>    
     
 //开启或关闭工具拖拽
 int example_enable_admittance_ctrl()  
 {  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要替换为自己控制器的IP  
    demo.login_in("10.5.5.100");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //开启力传感器  
    demo.set_torque_sensor_mode(1);  
    //校零传感器  
    demo.set_compliant_type(1, 0);  
    printf("inint sensor comple");  
    //设置柔顺控制参数，此处仅开启z方向
    ret = demo.set_admit_ctrl_config(0, 0, 30, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(1, 0, 30, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(2, 1, 30, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(3, 0, 3, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(4, 0, 3, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(5, 0, 3, 0, 0, 0);  
    //开启工具拖拽  
    ret = demo.enable_admittance_ctrl(1);  
    printf("enable_admittance_ctrl open！");  
    std::cout << ret << std::endl;  
    printf("input any word to quit:");  
    std::cin >> ret; 
    //关闭工具拖拽  
    ret = demo.enable_admittance_ctrl(0);  
    printf("close");  
    return 0;  
}  

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

兼容性接口保留。

适配1.7.1控制器，1.7.2拆分为多个对应替代接口。1.7.2控制器调用此接口时仅实现触发校零及设置力控类型功能，torq_sensor_monitor_data.actTorque将固定为实际外力，且需要注意在sensor_compensation给1时compliance_type参数必须给0，且必须等待1秒后才能再次调用此接口设置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 set_compliant_type(int sensor_compensation, int compliance_type);  

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

兼容性接口保留。

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

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

• 参数说明
  • 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);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //设置与获取力控类型和传感器初始化状态  
 int example_set_compliant_type()  
 {  
    int ret,sensor_compensation,compliance_type;  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    demo.servo_move_enable(TRUE);  
    //设置力控类型和校零（初始化）选项
    ret = demo.set_compliant_type(1,0);  
    std::cout << ret << std::endl;  
    //获取力控类型和读数显示（初始化）状态
    ret = demo.get_compliant_type(&sensor_compensation, &compliance_type);  
    std::cout << ret << std::endl;  
    return 0;  
}  

设置力柔顺控制参数

兼容性接口保留。

适配1.7.1控制器，1.7.2针对工具拖拽和恒力柔顺控制两种功能分别拆分为独立的接口，仅对相应的功能生效。1.7.2控制器调用此接口时将调用全部的替代接口并设置为相同参数。

设置力柔顺控制参数

• 参数说明
  • 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);  

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //设置力柔顺控制参数
 int example_set_admit_ctrl_config()  
 {  
    int ret  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    //设置力柔顺控制参数
    ret = demo.set_admit_ctrl_config(0, 0, 30, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(1, 0, 30, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(2, 1, 30, 5, 0, 0);  
    ret = demo.set_admit_ctrl_config(3, 0, 3, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(4, 0, 3, 0, 0, 0);  
    ret = demo.set_admit_ctrl_config(5, 0, 3, 0, 0, 0);  
    std::cout << ret << std::endl;  
    return 0;  
}  

获取力柔顺控制参数

兼容性接口保留。

适配1.7.1控制器，1.7.2针对工具拖拽和恒力柔顺控制两种功能分别拆分为独立的接口，仅对相应的功能生效。1.7.2控制器调用此接口时将返回恒力柔顺控制功能对应的柔顺参数。

获取力控柔顺控制参数

• 参数说明
  • admit_ctrl_cfg 机械臂力柔顺控制参数存储地址，6个AdmitCtrlType组成的数组，分别对应x,y,z,rx,ry,rz方向的力柔顺控制参数
• 返回值 ERR_SUCC 成功 其他失败

errno_t get_admit_ctrl_config(RobotAdmitCtrl *admit_ctrl_cfg);

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //获取力柔顺控制参数
 int example_get_admit_ctrl_config()  
 {  
    RobotAdmitCtrl adm_ctr_cfg;  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo; 
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //获取力控柔顺控制参数  
    ret = demo.get_admit_ctrl_config(&adm_ctr_cfg);  
    std::cout << ret << std::endl;  
    return 0;  
}  

设置速度柔顺控制参数

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

设置速度柔顺控制参数

• 参数说明
  • vel_cfg为速度柔顺控制参数
• 返回值 ERR_SUCC 成功 其他失败

errno_t set_vel_compliant_ctrl(const VelCom *vel_cfg);

设置速度柔顺控制力条件

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

设置柔顺控制力条件

• 参数说明
  • ft为柔顺控制力矩限制，超过限制值会减速直至停止
• 返回值 ERR_SUCC 成功 其他失败

errno_t set_compliance_condition(const FTxyz *ft);

代码示例：

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //设置速度柔顺控制力条件
 int example_set_compliance_condition()  
 {  
    FTxyz ft;  
    ft.fx = 10; ft.fy = 10; ft.fz = 10;  
    ft.tx = 10; ft.ty = 10; ft.tz = 10;  
    int ret  
    //实例API对象demo   
    JAKAZuRobot demo;  
    //登陆控制器，需要将192.168.2.194替换为自己控制器的IP  
    demo.login_in("192.168.2.194");  
    //机械臂上电  
    demo.power_on();  
    //机械臂上使能  
    demo.enable_robot();  
    //设置速度柔顺控制力条件
    ret = demo.set_compliance_condition(&ft);  
    std::cout << ret << std::endl;  
    return 0;  
}  

注：

以下接口仅用于控制器1.7.2版本。

传感器校零

触发传感器校零，并且阻塞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);

获取恒力柔顺控制参数

获取恒力柔顺控制参数

• 参数说明
  • admit_ctrl_cfg 机械臂力控柔顺控制参数存储地址，6个AdmitCtrlType组成的数组，分别对应x,y,z,rx,ry,rz方向的力柔顺控制参数
• 返回值 ERR_SUCC 成功 其他失败

errno_t get_ft_ctrl_config(RobotAdmitCtrl *admit_ctrl_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(RobotAdmitCtrl *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);

设置进近限速

设置进近限速

• 参数说明
  • speed_limit 线速度限制，mm/s
  • angular_speed_limit 角速度限制，rad/s
• 关于此项设置的具体含义，请参考172APP使用手册中的相关说明。

errno_t set_approach_speed_limit(double vel, double angularVelt);

获取进近限速

获取进近限速

• 参数说明
  • 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);

获取力矩参考中心

获取力矩参考中心。

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

errno_t get_torque_ref_point(int *ref_point);

设置力矩参考中心

设置力矩参考中心。

• 参数说明
  • ref_point 0代表末端法兰中心（或传感器中心），1代表当前生效的工具坐标系中心。
• 关于此项设置的具体含义，请参考APP使用手册中的相关说明。

errno_t set_torque_ref_point(int ref_point);

设置传感器灵敏度

设置传感器灵敏度。

• 参数说明
  • 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使用手册中的相关说明。

提示

该示例为上述1.7.2及以上控制器版本的接口示例。

示例代码：

 int main()
 {
    std::cout << "Hello World!";
 
    JAKAZuRobot demo;
    demo.login_in("10.5.5.100");
 
    cout << "power on: " << demo.power_on() << endl;
    cout << "enable: " << demo.enable_robot() << endl;
    
    cout << "enable tool drive: " << demo.enable_tool_drive(1) << endl;
    
    //set tool_drive_frame
    FTFrameType tool_drive_frame;
    demo.set_tool_drive_frame(FTFrameType::FTFrame_Tool);
    demo.get_tool_drive_frame(&tool_drive_frame);
    std::cout << tool_drive_frame << std::endl;
    
    //set torque_ref_point
    int ref_point;
    demo.set_torque_ref_point(1); //set to follow the TCP
    demo.get_torque_ref_point(&ref_point);
    std::cout << ref_point << 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);
    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);
    
    //zero_end_sensor
    cout << "zero: " << demo.zero_end_sensor() << endl;
    
    //open tool drive
    demo.enable_tool_drive(1);
    int enable, state;
    demo.get_tool_drive_state(&enable, &state);
    Sleep(2000);
    demo.enable_tool_drive(0);
    
    //退出登录
    demo.login_out();
    
    cout << "end" << endl;
    return 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接口
-60	set io timeout	设置IO超时

问题反馈

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