C++

This document introduces the data types and APIs defined in the JAKA SDK (C++). It is primarily intended for software developers creating robotic applications that communicate with virtual or real controllers using C++/C. It can also be helpful for users who want to understand JAKA robot controller applications.

API

Basic operation of the robot

The following example includes the necessary header files by default, such as "JAKAZuRobot.h" and native C++ header files.

Robot control constructor

Robotic arm control constructor.

JAKAZuRobot();  

Robot log in

Connect the robot controller.

• Parameters
  • ip  Controller's ip address
• Return value ERR_SUCC Error or Success

errno_t  login_in(const char *ip);  

Robot log out

Disconnect the controller,After a successful call of this interface, no functions other than login_in can be called.

• Return value  ERR_SUCC Error or Success

errno_t  login_out(); 

Power on robot

Power on the robot.

• Return value  ERR_SUCC Error or Success

errno_t  power_on();  

Power off robot

Power off the robot.

• Return value  ERR_SUCC Error or Success

errno_t  power_off();  

Shutdown the control cabinet

Shutdown the control cabinet.

• Return value  ERR_SUCC Error or Success

errno_t  shut_down();  

Enable robot

Enable the robot.

• Return value  ERR_SUCC Error or Success

errno_t  enable_robot();  

Disable robot

Disable the robot.

• Return value  ERR_SUCC Error or Success

errno_t  disable_robot();  

Enable or disable drag mode

Enable drag mode.

• Parameters
  • enable TRUE means to enter the drag mode, FALSE means to quit the drag mode.
• Return value  ERR_SUCC Error or Success

errno_t  drag_mode_enable(BOOL enable);  

Sample Code:

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
 #define PI 3.1415926  
 //drag mode  

int  example_drag()
{
    BOOL in_drag;  
    JAKAZuRobot demo;  
    demo.login_in("192.168.2.152");  
    demo.power_on();  
    demo.enable_robot();  
    //Confirm the robot whether in drag mode  
    demo.is_in_drag_mode(&in_drag);  
    std::cout << "in_drag is : " << in_drag << std::endl;  
    //Enable the drag mode  
    demo.drag_mode_enable(TRUE);  
    Sleep(10000);  
    demo.is_in_drag_mode(&in_drag);  
    std::cout << "in_drag is : " << in_drag << std::endl;  
    //Disable the drag mode  
    demo.drag_mode_enable(FALSE);  
    Sleep(100);  
    demo.is_in_drag_mode(&in_drag);  
    std::cout << "in_drag is : " << in_drag << std::endl;  
    while (1)  
    {  
      demo.is_in_drag_mode(&in_drag);  
      std::cout << "in_drag is : " << in_drag << std::endl;  
      Sleep(100);  
    }
    return 0;  
 }  

Interrogate whether in drag mode

Interrogate whether in drag mode.

• Parameters
  • in_drag Interrogate results
• Return value  ERR_SUCC Error or Success

errno_t  is_in_drag_mode(BOOL *in_drag);  

Get SDK version

Get the controller version number.

• Parameters
  • version SDK version number
• Return value  ERR_SUCC Error or Success

errno_t  get_sdk_version(char *version);  

Sample Code:

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
 #define PI 3.1415926  
 //Get SDK version  
int example_getsdk_version()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  char ver[100];  
  //Login the controller, you need to replace 192.168.2.194 with the IP of your own   controller 
  demo.login_in("192.168.2.194");  
  //Get current SDK version  
  demo.get_sdk_version(ver);  
  std::cout << " SDK version is :" << ver << std::endl;  
  return 0;  
 }  

Get SDK file path

Get SDK file path

• Parameters
  • filepath SDK file path
• Return value ERR_SUCC Error or Success

errno_t  get_SDK_filepath(char *filepath);  

Set SDK file path

Set SDK file path.

• Parameters
  • filepath SDK file path
• Return value  ERR_SUCC Error or Success

errno_t  set_SDK_filepath(char *filepath);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set SDK file path  
int example_set_SDK_filepath()  
{  
  //Set SDK file path  
  char path[20] = "D://";  
  int ret;  
  JAKAZuRobot demo;  
  ret = demo.set_SDK_filepath(path);//Set SDK file path  
  demo.login_in("192.168.2.194");  
  demo.power_on();  
  demo.enable_robot();  
  std::cout << ret << std::endl;  
  return 0;  
 } 

Set SDK debug mode

Set whether enter the debug mode.

• Parameters
  • mode Select TRUE to enter the debug mode. At this time, debugging information will be output in the standard output stream. When selecting FALSE, debugging information will not be output.
• Return value  ERR_SUCC Error or Success

errno_t  set_debug_mode(BOOL mode);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set whether to open SDK debug mode  
int example_set_debug_mode()  
{  
  BOOL mode;   
  JAKAZuRobot demo;  
  //Set debug mode, which will print debug information on the terminal  
  demo.set_debug_mode(TRUE);  
  demo.login_in("192.168.2.194");  
  demo.power_on();  
  demo.enable_robot();  
  return 0;  
 }  

Get controller IP

Get controller ip.

• Parameters
  • controller_name Controller name
  • ip_list Controller ip list, when the controller name is a specific value, the corresponding controller IP address will be returned, when the controller name is empty, all controller IP addresses in the network segment class will be returned
• Return value  ERR_SUCC Error or Success
• This function is invalid when the app is initiated

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Get controller IP  
int example_get_controller_ip()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  char ip_list[2000] = { 0 };  
  char  controller_name1[50] = "";  
  
  //Get controller IP  
  ret = demo.get_controller_ip( controller_name1, ip_list);  
  std::cout << ret << std::endl;  
  std::cout << " ip_list is :n" << ip_list << std::endl;  
  return 0;  
 }  

Robot Move

Manual mode move

Control the robot's jog move in manual mode.

• Parameters
  • aj_num Represent joint number [0-5] in joint space, and x, y, z, rx, ry, rz-axis in Cartesian space.
  • move_mode Robot move mode, incremental move or absolute move (i.e. continuous jog move) and continuous move, refer to 2.13 to select the right move mode, optional types are INCR ABS.
  • coord_type Robot move coordinate frame, tool coordinate frame, base coordinate frame (current world/user coordinate frame) or joint space, refer to 2.12 to select the right coordinate frame.
  • vel_cmd Command velocity, unit of rotation axis or joint move is rad/s, move axis unit is mm/s.
  • pos_cmd Command position, unit of rotation axis or joint move is rad, move axis unit is mm.
• Return value  ERR_SUCC Error or Success

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

Sample Code：

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Manual mode move  
int main()
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.   
  demo.login_in("192.168.2.152");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Manual motion, where INCR stands for incremental motion, 0.5 means the speed is 0.5rad/s ,30*PI/180 means te the line command to move 30*PI/180rad.  
  demo.jog(1, INCR, COORD_JOINT , 0.5, 30*PI/180);  
  Sleep(5000);  
  //Stop manual mode  
  demo.jog_stop(0);  
  //Power off the robot  
  demo.disable_robot();  
  //Disable the robot  
  demo.power_off();  
  return 0;  
} 

Manual mode stop

Stop the robot in manual mode.

• Parameters
  • num Robot axis number 0-5, when number is -1, stop all axes
• Return value  ERR_SUCC Error or Success

errno_t  jog_stop(int num);  

Robot joint move

Robot joint move

• Parameters
  • joint_pos Joint move position.
  • move_mode Specify move mode: Incremental move (relative move) or absolute move.
  • is_block Set whether the interface is a block interface, TRUE represents a block interface and FALSE represents a non-block interface.
  • speed Robot joint move speed, unit: rad/s.
  • acc Angular acceleration of robot joint move, unit: rad/s².
  • tol The robot joint move end error, this parameter makes a smoother interface between two move segments, and it requires consecutive multiple move segments with non-block interfaces to use this parameter.
  • option_cond Optional parameters for robot joints, if not needed, the value can be left unassigned, just fill in a null pointer.
• Return value  ERR_SUCC Error or Success

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

Robot end linear move

Robot end linear move

• Parameters
  • end_pos Robot end move position
  • move_mode Specify move mode: Incremental move (relative move) or absolute move
  • is_block Set whether the interface is a block interface, TRUE represents a block interface and FALSE represents a non-block interface.
  • speed Robot linear move speed, unit: mm/s
  • acc Robot linear move acceleration, unit: mm/s²
  • tol Tolerance of robot joint move end, unit: mm
  • option_cond Optional parameters for robot joints, if not needed, the value can be left unassigned, just fill in a null pointer.
  • ori_vel Orientation speed, unit radian/s.
  • ori_acc Orientation acceleration, unit radian/s^2.
• Return value  ERR_SUCC Error or Success
• When singularity might appear:
  • The robot end position is ant the plane made by axis Z1 and Z2;
  • Axis Z2, Z3, Z4 is on the same plane;
  • The angle of joint 5 is 0 or 180, meaning that Z4 and Z6 is parallel.

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);

Sample Code:

int example_linear_move() 
{ 
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  RobotStatus status;  
  //login controller, you need to replace 192.168.2.229 with the IP of your own controller.   
  demo.login_in("192.168.2.160");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  ///Define and initialize the CartesianPose variable with the rotation angle in radians.  
  CartesianPose cart;  
  cart.tran.x = 300; cart.tran.y = 300; cart.tran.z = 100;  
  cart.rpy.rx = 180 * PI / 180; cart.rpy.ry = 0 * PI / 180; cart.rpy.rz = 0 * PI / 180; 
  //Cartesian space motion, where ABS stands for absolute motion, TRUE means the command  is blocked, and 10 s for a speed of 10mm/s     
  printf("rx=%f , ry=%f, rz=%f\n", 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;  
      //Cartesian space extended motion, where ABS stands for absolute motion, FALSE    stands   for non-blocking nd, 20 stands for maximum velocity of 20mm/s, 10 stands for     acceleration of 10mm/s², 5 stands for arc over s of 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;  
}  

Robot circular move

Arc move at the end of the robot. The interface uses the current point and two points entered to plan a circular trajectory.

• Parameters
  • end_pos Robot end move position.
  • mid_pos The middle point of robot end move.
  • move_mode Specify move mode: Incremental move, absolute move.
  • is_block Set whether the interface is a block interface, TRUE represents a block interface and FALSE represents a non-block interface.
  • speed Robot linear move speed, unit: mm/s.
  • acc Robot Cartesian space acceleration.
  • tol End point error of robot Cartesian space motion.
  • option_cond Optional parameters for robot joints, if not needed, the value can be left unassigned, just fill in a null pointer.
  • circle_cnt The circle number of the specified arc movement. 0 equals circular_move.
  • circle_mode The mode of the specified arc movement. Its parameters mean:
    • 0: to perform an orientation change using a fixed axis angle that is less than 180°between the start orientation and the end orientation (the current approach);
    • 1: to perform an orientation change using a fixed axis angle that is larger than 180°between the start orientation and the end orientation;
    • 2: using the orientation of the intermediate point to decide which axis angle should be used, less than 180°or larger than 180°.
    • 3: the orientation angle should always be in consistent with the arc axis (the current full circle movement).
• Return value  ERR_SUCC Error or Success

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, int circle_cnt = 0, int circle_mode = 0);
```  

**Sample Code:**

```c++

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//The upper limit of joint speed is 180rad/s in circular move  
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 = -90 * PI/ 180; end_p.rpy.ry = 0 * PI / 180; end_p.rpy.rz =0 * PI / 180;  
  mid_p.tran.x = -300; mid_p.tran.y = 400; mid_p.tran.z = 500;  
  mid_p.rpy.rx = -90 * PI / 180; mid_p.rpy.ry = 0 * PI / 180; mid_p.rpy.rz =0 * PI/180;    
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Define and initialize JointValue variables  
  JointValue joint_pos = { 85.76, -6.207, 111.269, 74.938, 94.24, 0};  
  //Joint space motion, where ABS stands for absolute motion, TRUE means the command is  blocked, and 1 stands for a speed of 1 rad/s    
  demo.joint_move(&joint_pos, ABS, TRUE, 1);  
  //Circular motion, where ABS stands for absolute motion, TRUE means the command is  blocked, 20 stands for linear speed of 20mm/s, 1 stands for acceleration, 0.1 stands for   robot arm endpoint error, and OPT is an optional parameter.   
  demo.circular_move(&end_p, &mid_p, ABS, TRUE, 20, 1, 0.1,&opt);  
  return 0;  
 }

Motion abort

Terminate the current robotic arm move.

• Return value  ERR_SUCC Error or Success

errno_t  motion_abort();  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Motion abort  
int example_motion_abort()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Define and initialize JointValue variables  
  printf("start_move");  
  JointValue joint_pos = { 0, 0, 50, 0, 0, 0 };  
  //Joint space motion, where ABS stands for absolute motion, TRUE means the command is  blocked, and 1 stands for a speed of 1 rad/s   
  demo.joint_move(&joint_pos, ABS, FALSE, 1);  
  Sleep(500);  
  //Terminate after 0.5s of move  
  demo.motion_abort();  
  printf("stop_move");  
  return 0;  
 }  

Interrogate whether the robot has stopped

Interrogate whether in position.

• Parameters
  • in_pos Interrogate results
• Return value  ERR_SUCC Error or Success

errno_t  is_in_pos(BOOL *in_pos);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Check if the robot movement has stopped  
int example_is_in_pos()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  BOOL in_pos;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.152");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  while (1)  
  {  
    //Check if the robot movement has stopped  
    demo.is_in_pos(&in_pos);  
    std::cout << " in_pos is :" << in_pos << std::endl;  
    Sleep(200);  
  }  
 return 0;  
 }  

Get motion status

Get motion status.

• Parameters
  • status struct of motion status

errno_t get_motion_status(MotionStatus *status);

Set block wait timeout

Set robot block wait timeout.

• Parameters
  • seconds time parameters, unit: second, must＞0.5
• Return value ERR_SUCC Success, otherwise failed

errno_t set_block_wait_timeout(float seconds);

Set and Obtain Robot Operation Information

Get robot status monitoring data (the only multi-thread safe interface)

Get robot status data, multi-thread safe.

• Parameters
  • status Interrogate result of robot status
• Return value  ERR_SUCC Error or Success

errno_t  get_robot_status(RobotStatus *status);   

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Get robot status monitoring data  
int example_get_robot_status()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  RobotStatus robstatus;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Get robot status monitoring data  
  demo.get_robot_status(&robstatus);  
  demo.login_out();  
  return 0;  
 }  

Get joint position (Simple)

Get te current joint position, and save it in joint_position.

• Parameters
  • joint_position joint position query result
• Return value ERR_SUCC Success, otherwise fail

errno_t get_joint_position(JointValue *joint_position);

Get joint angle

Get the current joint angle of the robot arm and save the joint angle matrix in the input parameter joint_position.

• Parameters
  • joint_position Interrogate results of joint angle
• Return value  ERR_SUCC Error or Success

errno_t  get_joint_position(JointValue *joint_position);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Get joint angle  
int example_get_joint_position()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  JointValue jot_pos;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Get joint angle  
  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;  
 }  

Set status data update time interval

Set robot status data update time interval, specify get_robot_status().

• Parameters
  • millisecond time parameter，unit：ms
• Return value ERR_SUCC Success other failed

errno_t set_status_data_update_time_interval(float millisecond);

Sample Code:

#include <iostream>
#include "JAKAZuRobot.h"
#include <windows.h>

//Set status update time
int example_set_status_data_updata_interval()
{
  float milisec = 100;
  int ret;
  //Real API targetdemo
  JAKAZuRobot demo;
  //Log in the controller，replace 192.168.2.194 as the IP address of your own controller
  demo.login_in("192.168.2.194");
  //robot powered on
  demo.power_on();
  //robot enabled
  demo.enable_robot();
  //set compliant torque requirement
  ret = demo.set_status_data_update_time_interval(milisec);
  std::cout << ret << std::endl;
  return 0;
}

Get TCP position

Get TCP pose.

• Parameters
  • tcp_position Interrogate result of tool end position
• Return value  ERR_SUCC Error or Success

errno_t  get_tcp_position(CartesianPose *tcp_position);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Get tcp pose  
int example_get_tcp_position()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  CartesianPose tcp_pos;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Get tcp pose  
  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;  
 }  

Set user coordinate system parameter

Set the parameter of specified user coordinate system.

• Parameters
  • id The value range of the user coordinate system number is [1,15]
  • user_frame Offset value of user coordinate system
  • name Alias of user coordinate system
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//View and adjust user coordinate system  
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();  
  //Interrogate the currently used user coordinate system ID  
  demo.get_user_frame_id(&id_ret);  
  //Get the currently used user coordinate system information  
  demo.get_user_frame_data(id_ret, &tcp_ret);  
  printf("id_using=%d nx=%f, y=%f, z=%f\n", id_ret, tcp_ret.tran.x, tcp_ret.tran.y,  tcp_ret.tran.y);  
  printf("rx=%f, ry=%f, rz=%f\n", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
  //Initialize user coordinate system coordinates  
  tcp_set.tran.x = 0; tcp_set.tran.y = 0; tcp_set.tran.z = 10;  
  tcp_set.rpy.rx = 120 * PI / 180; tcp_set.rpy.ry = 90 * PI / 180; tcp_set.rpy.  rz = -90 * PI / 180;  
  //Set user coordinate system information  
  demo.set_user_frame_data(id_set, &tcp_set, name);  
  //Switch coordinats of user coordinate system currently use  
  demo.set_user_frame_id(id_set);  
  //Interrogate the currently used user coordinate system ID  
  demo.get_user_frame_id(&id_ret);  
  //Get the set user coordinate system information  
  demo.get_user_frame_data(id_ret, &tcp_ret);  
  printf("id_using=%d nx=%f, y=%f, z=%f\n", id_ret, tcp_ret.tran.x, tcp_ret.tran.y,  tcp_ret.tran.y);  
  printf("rx=%f, ry=%f, rz=%f\n", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
  return 0;  
 }  

Get user coordinate system information

Interrogate user coordinate system information that is currently in use.

• Parameters
  • id  The value range of the user coordinate frame ID is [0,15]
  • tcp  Offset value of user coordinate system
• Return value ERR_SUCC Error or Success

errno_t  get_user_frame_data(int id, CartesianPose *tcp);  

Set user coordinate system ID

Set user coordinate system ID.

• Parameters
  • id The value range of the user coordinate frame ID is [0,15], where 0 represents the world coordinate frame .
• Return value  ERR_SUCC Error or Success

errno_t  set_user_frame_id(const int id);  

Get user coordinate system ID currently in use

Get user coordinate system ID currently use.

• Parameters
  • id Result
• Return value  ERR_SUCC Error or Success

errno_t  get_user_frame_id(int *id);  

Set tool data

Set the specified tool.

• Parameters
  • id The range of tool number is [1,15], where 0 represents the tool coordinate frame,cannot be changed.
  • tcp Tool coordinate frame is offset relative to flange coordinate frame
  • name Specify the alias of the tool
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Tool coordinate system view and adjustment  
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();  
  //Interrogate the currently used tool ID  
  demo.get_tool_id(&id_ret);  
  //Get information about the currently used tool  
  demo.get_tool_data(id_ret,&tcp_ret);  
  printf("id_using=%d nx=%f, y=%f, z=%f\n", id_ret, tcp_ret.tran.x, tcp_ret.tran.y,  tcp_ret.tran.y);  
  printf("rx=%f, ry=%f, rz=%f\n", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
  //Initialize tool coordinates  
  tcp_set.tran.x = 0; tcp_set.tran.y = 0; tcp_set.tran.z = 10;  
  tcp_set.rpy.rx = 120 * PI / 180; tcp_set.rpy.ry = 90 * PI / 180; tcp_set.rpy.  rz = -90 * PI / 180;  
  //Set tool information  
  demo.set_tool_data(id_set, &tcp_set, name);  
  //Switch the coordinates of the currently used tool  
  demo.set_tool_id(id_set);  
  //Interrogate the currently used tool ID  
  demo.get_tool_id(&id_ret);  
  //Get information about the set tools  
  demo.get_tool_data(id_ret, &tcp_ret);  
  printf("id_using=%d nx=%f, y=%f, z=%f\n", id_ret, tcp_ret.tran.x, tcp_ret.tran.y,  tcp_ret.tran.y);  
  printf("rx=%f, ry=%f, rz=%f\n", tcp_ret.rpy.rx, tcp_ret.rpy.ry, tcp_ret.rpy.rz);  
  return 0;  
 }  

Get tool information

Interrogate the information of the tool currently used.

• Parameters
  • id Interrogate result of tool ID
  • tcp Tool coordinate system is offset relative to flange coordinate system
• Return value ERR_SUCC Error or Success

errno_t  get_tool_data(int *id, CartesianPose *tcp);  

Get the tool ID currently in use

Get the tool ID currently in use

• Parameters
  • id Interrogate result of tool ID
• Return value  ERR_SUCC Error or Success

errno_t  get_tool_id(int *id);  

Set tool ID currently in use

Set the ID of the currently used tool. When the network fluctuates, it takes a certain delay to take effect after switching the ID.

• Parameters
  • id The value range of tool coordinate frame ID is [0,15], 0 means no tools, flange center.
• Return value  ERR_SUCC Error or Success

errno_t  set_tool_id(const int id);  

Set digital output variables

Set DO Value.

• Parameters
  • type DO Type
  • index DO Index (starting from 0)
  • value DO Value
• Return value  ERR_SUCC Error or Success

errno_t  set_digital_output (IO Type, int index, BOOL value);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
// Set and interrogate digital outputs  
int main()  
{  
  BOOL DO3;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.  
  demo.login_in("192.168.2.152");  
  //Power on the robot  
  demo.power_on();      
  //Get do3 status  
  demo.get_digital_output(IO_CABINET, 2, &DO3);  
  printf("D03 = %d\n", DO3);  
  //io_cabinet is the controller panel IO, 2 represents DO2, and 1 corresponds to the DO   value to be set.  
  demo.set_digital_output(IO_CABINET, 2, 1);  
  Sleep(1000);//Requires window.h delay of 1s  
  //Get do3 status  
  demo.get_digital_output(IO_CABINET, 2, &DO3);  
  printf("D03 = %d\n", DO3);    
  return 0;  
 }  

Set analog output variables

Set analog output (AO) value.

• Parameters
  • type AO Type
  • index AO Index (starting from 0)
  • value AO Settings
• Return value  ERR_SUCC Error or Success

errno_t  set_analog_output (IO Type, int index, float value); 
``` 

**Sample Code:**

```c++

#include <iostream>  
#include "JAKAZuRobot.h"  
//Set and interrogate analog output  
int main()  
{  
  JAKAZuRobot demo;  
  demo.login_in("192.168.2.152");  
  demo.power_on();  
  float AO35;  
  //Get Ao status  
  demo.get_analog_output(IO_CABINET, 34, &AO35);  
  printf("A035 = %f\n", AO35);  
  /io_cabinet is the controller panel IO, 2 represents DO3, and 1.5 corresponds to the DO  value to be set.  
  demo.set_analog_output(IO_CABINET, 34, 1.5);  
  Sleep(1000);//Requires window.h delay of 1s  
  //Get Ao status  
  demo.get_analog_output(IO_CABINET, 34, &AO35);  
  printf("A035 = %f\n", AO35);  
  return 0;  
 }  

Get digital input status

Interrogate DI status.

• Parameters
  • type DI Type
  • index DI Index (starting from 0)
  • result DI Status Interrogate result
• Return value  ERR_SUCC Error or Success

errno_t  get_digital_input (IO Type, int index, BOOL *result);  

Get digital output status

Interrogate DO status.

• Parameters
  • type DO Type
  • index DO Index (starting from 0)
  • result DO Status Interrogate result
• Return value  ERR_SUCC Error or Success

errno_t  get_digital_output (IO Type, int index, BOOL *result);  

Get analog input variables

Get the type of AI value.

• Parameters
  • type AI Type
  • index AI Index (starting from 0)
  • result Interrogate result of AI status
• Return value  ERR_SUCC Error or Success

errno_t  get_analog_input(IO Type, int index, float *result);  

Get analog output variables

Get AO value.

• Parameters
  • type AO Type
  • index AO Index (starting from 0)
  • result Interrogate result of AO status
• Return value  ERR_SUCC Error or Success

errno_t  get_analog_output (IO Type, int index, float *result);  

Interrogate whether extension IO in running status

Interrogate whether the extension IO module is running.

• Parameters
  • is_running Interrogate results of extension IO module running status.
• Return value  ERR_SUCC Error or Success

errno_t  is_extio_running (BOOL *is_running); 
``` 

**Sample Code:**

```c++

#include <iostream>  
#include "JAKAZuRobot.h"  
//Interrogate status of extension IO  
int main()  
{  
  BOOL is_running;  
  JAKAZuRobot demo;  
  demo.login_in("192.168.2.194");  
  demo.power_on();  
  //Get TIO status  
  demo.is_extio_running(&is_running);  
  printf("tio = %d\n", is_running);     
  return 0;  
 }  

Set payload

Set payload.

• Parameters
  • payload Centroid and mass data of payload
• Return value  ERR_SUCC Error or Success

errno_t  set_payload(const PayLoad *payload);  

Get payload data

Get payload data.

• Parameters
  • payload Load Interrogate results
• Return value  ERR_SUCC Error or Success

errno_t  get_payload(PayLoad *payload);  

Sample Code:

int example_payload()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  PayLoad payloadret;  
  PayLoad payload_set;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.   
  demo.login_in("192.168.2.194");  
  //Get current payload data  
  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.roid.y << "z: " << payloadret.centroid.z << std::endl;  
  payload_set.mass = 1.0;  
  //unit: mm  
  payload_set.centroid.x = 0; payload_set.centroid.y = 0; payload_set.centroid.z = 10;  
  // Set current payload data  
  demo.set_payload(&payload_set);  
  // Get current payload data  
  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;  
 }  

Set TIO V3 voltage parameters

Set TIO V3 voltage parameters.

• Parameters
  • vout_enable Voltage enable, 0:off, 1 on
  • vout_vol Voltage 0:24v 1:12v
• Return value ERR_SUCC Error or Success

errno_t set_tio_vout_param(int vout_enable, int vout_vol);  

Get TIO V3 voltage parameters

Get TIO V3 voltage parameters.

• Parameters
  • vout_enable Voltage enable, 0:off, 1 on
  • vout_vol Voltage 0:24v 1:12v
• Return value ERR_SUCC Error or Success

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

TIO add or modify semaphore

Add or modify a semaphore.

• Parameters
  • sign_info Semaphore parameters
• Return value ERR_SUCC Success, other values indicate failure

errno_t add_tio_rs_signal(SignInfo sign_info);

Sample Code:

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 delete semaphore

Delete a semaphore.

• Parameters
  • sig_name Semaphore name
• Return value ERR_SUCC Success, other values indicate failure

errno_t del_tio_rs_signal(const char *sig_name);

Sample Code:

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 send command

Send command via RS485.

• Parameters
  • chn_id Channel number
  • data Data field
• Return value ERR_SUCC Success, other values indicate failure

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

Sample Code:

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 get semaphore information

Get semaphore information.

• Parameters
  • sign_info Pointer to an array of semaphore information
• Return value ERR_SUCC Success, other values indicate failure

errno_t get_RS485_signal_info(SignInfo *sign_info);

Sample Code:

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 set TIO mode

Set TIO mode.

• Parameters
  • pin_type TIO type (0 for DI Pins, 1 for DO Pins, 2 for AI Pins)
  • pin_mode TIO mode
    • DI Pins:
      • 0:0x00 DI2 is NPN, DI1 is NPN;
      • 1:0x01 DI2 is NPN, DI1 is PNP;
      • 2:0x10 DI2 is PNP, DI1 is NPN; 3:0x11 DI2 is PNP, DI1 is PNP
    • DO Pins: The high four bits in the low 8 bits are used to configure DO2, and the low four bits are used to configure DO1.
      • 0x0: DO is NPN output,
      • 0x1: DO is PNP output,
      • 0x2: DO is push-pull output, 0xF: RS485H
    • AI Pins:
      • 0: Enable analog input, RS485L disabled;
      • 1: RS485L interface enabled, analog input disabled
• Return value ERR_SUCC Success, other values indicate failure

errno_t set_tio_pin_mode(int pin_type, int pin_mode);

TIO get TIO mode

Get TIO mode

• Parameters pin_type TIO type (0 for DI Pins, 1 for DO Pins, 2 for AI Pins)
• Parameters pin_mode TIO mode
  • DI Pins:
    • 0:0x00 DI2 is NPN, DI1 is NPN;
    • 1:0x01 DI2 is NPN, DI1 is PNP;
    • 2:0x10 DI2 is PNP, DI1 is NPN;
    • 3:0x11 DI2 is PNP, DI1 is PNP
• DO Pins: The high four bits in the low 8 bits are used to configure DO2, and the low four bits are used to configure DO1.
  • 0x0: DO is NPN output,
  • 0x1: DO is PNP output,
  • 0x2: DO is push-pull output, 0xF: RS485H
• AI Pins:
  • 0: Analog input enabled, RS485L disabled;
  • 1: RS485L interface enabled, analog input disabled
• Return value ERR_SUCC Success, other values indicate failure

errno_t get_tio_pin_mode(int pin_type, int *pin_mode);

TIO RS485 communication parameter configuration

Configure RS485 communication parameters.

• Parameters
  • mod_rtu_com When the channel mode is set to Modbus RTU, specify the Modbus slave ID additionally
• Return value ERR_SUCC Success, other values indicate failure

errno_t set_RS485_chn_comm(ModRtuComm mod_rtu_com);

TIO RS485 communication parameter query

Query RS485 communication parameters.

• Parameters
  • mod_rtu_com When querying, chn_id serves as an input parameter
• Return value ERR_SUCC Success, other values indicate failure

errno_t get_RS485_chn_comm(ModRtuComm *mod_rtu_com);

TIO RS485 communication mode configuration

Configure RS485 communication mode.

• Parameters
  • chn_id 0: RS485H, channel 1; 1: RS485L, channel 2
  • chn_mode 0: Modbus RTU, 1: Raw RS485, 2: Torque Sensor
• Return value ERR_SUCC Success, other values indicate failure

errno_t set_RS485_chn_mode(int chn_id, int chn_mode);

TIO RS485 communication mode query

Query RS485 communication mode.

• Parameters
  • chn_id Input parameter: 0 for RS485H, channel 1; 1 for RS485L, channel 2
  • chn_mode Output parameter: 0 for Modbus RTU, 1 for Raw RS485, 2 for Torque Sensor
• Return value ERR_SUCC Success, other values indicate failure

errno_t get_RS485_chn_mode(int chn_id, int *chn_mode);

Get robot installation angle

Get the installation angle.

• Parameters
  • quat Quaternion representing the installation angle
  • appang Installation angles in Roll-Pitch-Yaw (RPY) format
• Return value ERR_SUCC Success, other values indicate failure

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

Sample Code:

#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.\n";
    return -1;
  }
    ret = robot.set_installation_angle(3.14, 0);
  if (ret != ERR_SUCC)
  {
    std::cerr << "set installation angle failed.\n";
    return -1;
  }
  Quaternion quat;
  Rpy rpy;
  ret = robot.get_installation_angle(&quat, &rpy);
  if (ret != ERR_SUCC)
  {
    std::cerr << "get installation angle failed.\n";
    return -1;
  }
  std::cout << "quat: [" << quat.x << ", " << quat.y << ", " << quat.z << ", " << quat.s
  "]\n";
  std::cout << "anglex: " << rpy.rx << ", anglez: " << rpy.rz << "\n";
  ret = robot.login_out();
  if (ret != ERR_SUCC)
  {
    std::cerr << "login out failed.\n";
    return -1;
  }
  return 0;
 }

Set robot installation angle

Set the installation angle.

• Parameters
  • angleX Rotation angle around the X-axis
  • angleZ Rotation angle around the Z-axis
• Return value ERR_SUCC Success, other values indicate failure

errno_t set_installation_angle(double angleX, double angleZ);

Sample Code:

#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.\n";
    return -1;
  }
  ret = robot.set_installation_angle(180, 0);
  if (ret != ERR_SUCC)
  {
    std::cerr << "set installation angle failed.\n";
    return -1;
  }
  Quaternion quat;
  Rpy rpy;
  ret = robot.get_installation_angle(&quat, &rpy);
  if (ret != ERR_SUCC)
  {
    std::cerr << "get installation angle failed.\n";
    return -1;
  }
  std::cout << "quat: [" << quat.x << ", " << quat.y << ", " << quat.z << ", " << quat.s
  "]\n";
  std::cout << "anglex: " << rpy.rx << ", anglez: " << rpy.rz << "\n";
  ret = robot.login_out();
  if (ret != ERR_SUCC)
  {
    std::cerr << "login out failed.\n";
    return -1;
  }
  return 0;
}

Set user variables

set user variables

errno_t set_user_var(UserVariable v);

Get user variavles

get user_var list

errno_t get_user_var(UserVariableList *vlist);

Get robot state

Get robot state

• Parameters
  • state result
• Return value ERR_SUCC Success other failed

errno_t get_robot_state(RobotState *state);

Sample Code:

#include <iostream>
#include "JAKAZuRobot.h"
#include <windows.h>

//Get robot state (emergency stop powered on servo enabled)
int example_get_robstate()
{
  JAKAZuRobot demo;
  //State robot state
  RobotState state;
  demo.login_in("192.168.2.152");
  demo.power_on();
  demo.enable_robot();
  //Get robot state
  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;
}

Set and Interrogate Robot Safety Status

Interrogate whether on limit

Interrogate whether on limit.

• Parameters
  • on_limit Interrogate results
• Return value  ERR_SUCC Error or Success

errno_t  is_on_limit(BOOL *on_limit);  

Sample Code:

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
 #define PI 3.1415926  
 //Interrogate whether on limit  
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)  
  {  
    //Interrogate whether on limit  
    demo.is_on_limit(&on_limit);  
    std::cout << " on_limit is :" << on_limit << std::endl;  
    Sleep(200);  
  }  
  return 0;  
 }  

Interrogate whether in collision protection mode

Interrogate whether in Collision Protection mode.

• Parameters
  • in_collision Interrogate results
• Return value  ERR_SUCC Error or Success

errno_t  is_in_collision(BOOL *in_collision);  

Collision recover

Collision recover.

• Return value  ERR_SUCC Error or Success

errno_t  collision_recover();  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Collision protection status inquiry, recovery  
int example_collision_recover()  
{  
  JAKAZuRobot demo;  
  BOOL in_collision;  
  demo.login_in("192.168.2.152");  
  demo.power_on();  
  demo.enable_robot();  
  //Interrogate whether in collision protection mode  
  demo.is_in_collision(&in_collision);  
  std::cout << " in_collision is :" << in_collision << std::endl;  
  if (in_collision)  
  //Resume from collision protection if in collision protection mode  
  {demo.collision_recover();}  
  else  
  {std::cout << "robot is not collision" << std::endl;}  
  return 0;  
 }  

Set collision level

Set collision level.

• Parameters
  • level Collision level, the value range is [0,5],
    • 0: close collision,
    • 1: collision threshold 25N,
    • 2: collision threshold 50N,
    • 3: collision threshold 75N,
    • 4: collision threshold 100N,
    • 5: collision threshold 125N
• Return value  ERR_SUCC Error or Success

errno_t set_collision_level(const int level);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//View and set collision level  
int example_collision_level()  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  int level;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.152");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Interrogate current collision level   
  demo.get_collision_level(&level);  
  std::cout << " collision level is :" << level << std::endl;  
  //Set collision level from 0 to 5. 0 is off collision, 1 is collision threshold 25N, 2   is collision threshold 50N, 3 iscollision threshold 75N, 4 is collision threshold 100N,   5 is collision threshold 125N.  
  demo.set_collision_level(2);  
  //Interrogate current collision level  
  demo.get_collision_level(&level);  
  std::cout << " collision level is :" << level << std::endl;  
  return 0;  
 }

Get collision level

Get the robot collision level.

• Return value  ERR_SUCC Error or Success

errno_t get_collision_level(int *level);  

Robot terminates automatically due to abnormal network

Set the control handle because of abnormal network, the robot controller terminates the current motion after a period of time when SDK loses connection with the robot controller.

• Parameters
  • millisecond 3.Time parameter, unit: ms
  • mnt Robot motion type when the network is abnormal
• Return value ERR_SUCC Error or Success*/

errno_t set_network_exception_handle(float millisecond, ProcessType mnt);

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set the automatic termination motion type when the network is abnormal  
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();  
  //Set condition of compliance torque  
  ret = demo.set_network_exception_handle(milisec, MOT_KEEP);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Get the last error code

Get the last error code in the robot running process, when clear_error is called, the last error code will be cleared.

• Return value  ERR_SUCC Error or Success

errno_t  get_last_error(ErrorCode *code);  

Set error code file path

Set the error code file path. If you need to use the get_last_error interface, set the error code file path. If no need to use the get_last_error interface, do not set the interface.

• Return value  ERR_SUCC Error or Success

errno_t set_errorcode_file_path(char *path);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Error Code Viewing  
int example_get_last_errcode()  
{  
  int ret;  
  // Initialize error code file storage path  
  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");//Intentionally load a non-existent program   to raise an error  
  std::cout << ret << std::endl;  
  demo.get_last_error(&Eret);//Interrogate the last error message  
  std::cout << " error code is :" << Eret.code << " message: "<< Eret.message<< std::endl;   
  demo.set_errorcode_file_path(path);//Set error code description file  
  demo.get_last_error(&Eret);//Interrogate the last error message  
  std::cout << " error code is :" << Eret.code << " message: " << Eret.  message << std::endl;  
  return 0;  
 }  

Use the App Script Program

Run the loaded program

Run the loaded program.

• Return value  ERR_SUCC Error or Success

errno_t  program_run();  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Script loading, run control, process view  
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();  
  //Load the example script pre-edited by the app  
  demo.program_load("example");  
  //Get the loaded program name 
  demo.get_loaded_program(name);  
  std::cout <<"Pro_name is :"<< name << std::endl;  
  //Run the loaded program  
  demo.program_run();  
  Sleep(1000);//Let the program run for 1s first  
  //Pause the running program  
  demo.program_pause();  
  //Get the line number of the currently executing program  
  demo.get_current_line(&cur_line);  
  std::cout << "cur_line is :" << cur_line << std::endl;  
  //Get current program status  
  demo.get_program_state(&pstatus);  
  std::cout <<  "pro_status is : " << pstatus << std::endl;  
  //Continue running the current program  
  demo.program_resume();  
  Sleep(10000);//Requires window.h delay of 10s  
  //Terminate the current program  
  demo.program_abort();  
  return 0;  
 }  

Pause the running program

Pause the running program.

• Return value  ERR_SUCC Error or Success

errno_t  program_pause();  

Resume program

Resume program.

• Return value  ERR_SUCC Error or Success

errno_t  program_resume();  

Abort program

Abort program.

• Return value  ERR_SUCC Error or Success

errno_t  program_abort();  

Load the specified program

Load the specified program,The name of the program can be the name in the app (load the track reproduction data, the loading of the track data needs to add track/ before the folder name).

• Parameters
  • file Program file path
• Return value  ERR_SUCC Error or Success

errno_t  program_load (const char *file);  

Get the loaded program

Get the name of the loaded operating program.

• Parameters
  • file Program file path
• Return value  ERR_SUCC Error or Success

errno_t  get_loaded_program (char *file);  

Get current line

Get current line.

• Parameters
  • curr_line Interrogate result of current line
• Return value  ERR_SUCC Error or Success

errno_t  get_current_line (int *curr_line);  

Get program status

Get the program status.

• Parameters
  • status Interrogate result of program status
• Return value  ERR_SUCC Error or Success

errno_t  get_program_status (ProgramStatus *status);  

Set rapid rate

Set robot rapid rate

• Parameters
  • rapid_rate The program rapid rate, [0,1]
• Return value  ERR_SUCC Error or Success

errno_t  set_rapidrate (double rapid_rate);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//View and adjust robot speed  
int example_rapidrate()  
{  
  double rapid_rate;  
  JAKAZuRobot demo;  
  demo.login_in("192.168.2.152");  
  demo.power_on();  
  demo.enable_robot();  
  //Get robot motion rate  
  demo.get_rapidrate(&rapid_rate);  
  std::cout << "rapid_rate is : " << rapid_rate << std::endl;  
  //Set robot motion rate  
  demo.set_rapidrate(0.4);  
  Sleep(100);  
  demo.get_rapidrate(&rapid_rate);  
  std::cout << "rapid_rate is : " << rapid_rate << std::endl;  
  return 0;  
 }  

Get rapid rate

Get robot rapid rate.

• Parameters
  • rapid_rate Current control system rate
• Return value  ERR_SUCC Error or Success

errno_t  get_rapidrate (double *rapid_rate);  

Trajectory

Set trajectory track configuration parameters

Set trajectory track configuration parameters.

• Parameters
  • para Track configuration parameters
• Return value  ERR_SUCC Error or Success

errno_t  set_traj_config(const TrajTrackPara *para);

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//View and set trajectory reproduction parameter  
int example_traj_config()  
{  
  JAKAZuRobot demo;  
  TrajTrackPara trajpar_read;  
  TrajTrackPara trajpar_set;  
  demo.login_in("192.168.2.194");  
  //Interrogate current trajectory reproduction parameter  
  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;   
  //Set current trajectory reproduction parameter  
  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);  
  //Interrogate current trajectory reproduction parameter  
  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;  
 }  

Get trajectory track configuration parameters

Get trajectory track configuration parameters.

• Parameters
  • para Track configuration parameters
• Return value  ERR_SUCC Error or Success

errno_t  get_traj_config(TrajTrackPara *para);  

Set trajectory sample mode

Set trajectory sample mode.

• Parameters
  • mode Select TRUE to start data collection, when selecting FALSE, data collection is closed
  • filename The name of the data file. When filename is a null int, the storage file is named after the current date
• Return value  ERR_SUCC Error or Success

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

Sample Code:

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
 #define PI 3.1415926  
 //Track acquisition switch and status interrogation  
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";  
  //Turn on the track recurrence data collection switch  
  demo.set_traj_sample_mode(TRUE, name);  
  //Get trajectory sample status  
  demo.get_traj_sample_status(&samp_stu);  
  Sleep(10000);  
  demo.set_traj_sample_mode(FALSE, name);  
  return 0;  
 }  

Get trajectory sample status

Get trajectory sample status.

• Parameters
  • mode  TRUE means the data is being collected, FALSE means the data collection is over, and it is not allowed to turn on the Data Collection switch again during data collection
• Return value  ERR_SUCC Error or Success

errno_t  get_traj_sample_status(BOOL *sample_status);  

Get exist trajectory file name

Get exist trajectory file name.

• Parameters
  • file name The name of trajectory file
• Return value  ERR_SUCC Error or Success

errno_t  get_exist_traj_file_name(MultStrStorType *filename);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Get exist trajectory file name in controller  
int example_get_traj_existed_filename()  
{  
  JAKAZuRobot demo;  
  MultStrStorType traj_file;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Interrogate current trajectory file name.  
  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;  
 }  

Rename exist trajectory file name

Rename exist trajectory file name.

• Parameters
  • src Original file name
  • dest The target file name, the length of the file name cannot exceed 100 characters, the file name cannot be empty, the target file name does not support Chinese
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Rename exist trajectory file name  
int example_rename_traj_file_name()  
{  
  JAKAZuRobot demo;  
  MultStrStorType traj_file;  
  char name_new[20] = "555";  
  demo.login_in("192.168.2.194");  
  //Interrogate current trajectory file name.  
  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;  
  //Rename exist trajectory file name  
  demo.rename_traj_file_name(traj_file.name[0], name_new);  
  //Interrogate current trajectory file name.  
  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;  
 }  

Remove the trajectory file in the controller

Remove the trajectory file in the controller

• Parameters
  • file name The file name of the file to be deleted is the name of data file
• Return value  ERR_SUCC Error or Success

errno_t  remove_traj_file(const char *filename);  

Generate the trajectory execution script

Generate the trajectory execution script

• Parameters
  • filename The file name of the data file is the name of the data file without suffix
• Return value  ERR_SUCC Error or Success

errno_t  generate_traj_exe_file(const char *filename);  

Robot Servo Move

Robot servo move control mode

Robot servo move control mode enable

• Parameters
  • enable  TRUE means to enter the servo move control mode, FALSE means to quit the mode
• Return value ERR_SUCC  Error or Success
• NOTE: In the versions of v19 and before this is a non-blocked interface, and after version V20 this is changed to be a block-interface.

errno_t  servo_move_enable(BOOL enable);  

Robot joint servo move

Joint move control mode

• Parameters
  • joint_pos Joint move position
  • move_mode Specify move mode: incremental move, absolute move
• Return value ERR_SUCC Error or Success

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

Sample Code:

 //Robot joint servo move  
 //You need to call servo_move_enable(TRUE) to enable servo mode before use this interface  
 //The sending cycle of the controller is 8ms，so the recommended cycle of user is also 8ms. The network environment can be reduced in the case of poor conditions  
 //Upper limit of joint speed is 180rad/s  
 //There is a big difference between this instruction and joint_move. The interpolation of joint_move is performed by the controller, and servo_j needs to do the trajectory planning in advance.  

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
 #define PI 3.1415926  
 int main()  
 {  
    //Instance API object demo   
    JAKAZuRobot demo;  
    //login controller, you need to replace 192.168.2.194 with the IP of your own   controller.  
    demo.login_in("192.168.2.152");  
    //Power on the robot  
    demo.power_on();  
    //Enable the robot  
    demo.enable_robot();  
    //TRUE means entering servo mode  
    demo.servo_move_enable(TRUE);  
    //Define and initialize JointValue variables  
    JointValue joint_pos = {-0.001, 0* PI / 180, 0* PI / 180, 0* PI / 180, 0* PI / 180, -0.001};  
    for (int i = 0; i < 100; i++)  
    {  
      //Joint servo move，which INCR means incremental move  
      demo.servo_j(&joint_pos, INCR);  
    }  
    //FALSE means exiting servo mode  
    demo.servo_move_enable(FALSE);  
    return 0;  
 }   

Robot joint servo move extension

The robot joint move control mode increases the cycle adjustability. Cycle can be adjusted to multiples of 8ms.

• Parameters
  • joint_pos Joint move target position
  • move_mode Designated move mode: incremental move, absolute move
  • step_num  Multiplying period, servo_j move period is step_num*8ms, where step_num>=1
• Return value ERR_SUCC Error or Success

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

Robot Cartesian servo move

Control mode of robot cartesian space position.

• Parameters
  • cartesian_pose End position of robot cartesian space motion
  • move_mode Specify move mode: ABS stands for absolute move, INCR stands for relative move
• Return value  ERR_SUCC Error or Success

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

Sample Code:

 //Robot Cartesian servo move  
 //You need to call servo_move_enable(TRUE) to enable servo mode before use this interface   
 //The sending cycle of the controller is 8ms，so the recommended cycle of user is also 8ms. The network environment can be reduced in the case of poor conditions  
//Upper limit of joint speed is 3.141592 rad/s. There is no relatively intuitive restriction on Cartesian space, but this joint speed restriction should be satisfied.  
//There is a big difference between this instruction and linear_move. The interpolation of linear_move is performed by the controller, and servo_p needs to do the trajectory planning in advance.  

#include <iostream>  
#include "JAKAZuRobot.h"  
#define PI 3.1415926  
int main()//Robot Cartesian servo move  
{  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.152");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //TRUEmeans enter servo mode  
  demo.servo_move_enable(TRUE);  
  //Define and initialize CartesianPose variables  
  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++)  
  {  
    //Cartesian servo mode, which INCR stands for incremental move  
    demo.servo_p(&cart, INCR);  
  }  
  //FALSE means exiting servo mode  
  demo.servo_move_enable(FALSE);  
  return 0;  
 }  

Robot cartesian servo move extension

Control mode of robot cartesian position.

• Parameters
  • cartesian_pose End position of robot cartesian space motion
  • move_mode Specify move mode: incremental move or absolute move
  • step_num  Multiplying period, servo_p move period is step_num*8ms, where step_num>=1
• Return value  ERR_SUCC Error or Success

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

None filters in SERVO mode

Do not use filters in the SERVO mode, this command cannot be set in the SERVOJ mode, and can be set after quitting the SERVOJ mode.

• Return value  ERR_SUCC Error or Success

errno_t  servo_move_use_none_filter();  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
//None filters in SERVO mode  
int example_servo_use_none_filter()  
{
  int ret;  
  //Instance API object demo   
  AKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.   
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  ret = demo.servo_move_use_none_filter();  
  std::cout << ret << std::endl;  
  return 0;  
}  

Use joint first-order low pass filter in SERVO mode

Use joint First-order low-pass filter in SERVO mode, this command cannot be send in SERVOJ mode, and can be set after quitting SERVOJ.

• Parameters
  • cutoffFreq First-order low-pass filter cut-off frequency
• Return value  ERR_SUCC Error or Success

errno_t  servo_move_use_joint_LPF(double cutoffFreq);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Use joint first-order low pass filter in SERVO mode  
int example_servo_use_joint_LPF()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //First-order low-pass filtering in servo mode in joint, cutoff frequency is 0.5Hz  
  ret = demo.servo_move_use_joint_LPF(0.5);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Use joint nonlinear filter in SERVO mode

Use joint nonlinear filter in SERVO mode, this command cannot be set in SERVOJ mode but can be set after quitting SERVOJ.

• Parameters
  • max_vr The upper limit of Cartesian space orientation change speed (absolute value) °/s
  • max_ar The upper limit of accelerated speed of Cartesian space orientation change speed (absolute value)°/s^2
  • max_jr The upper limit value of jerk (absolute value) of Cartesian space orientation change speed °/s^3
• Return value  ERR_SUCC Error or Success

errno_t  servo_move_use_joint_NLF(double max_vr, double max_ar, double max_jr);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Joint nonlinear filter in SERVO mode  
int example_servo_use_joint_NLF()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Joint nonlinear filter in SERVO mode  
  ret = demo.servo_move_use_joint_NLF(2,2,4);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Use Cartesian nonlinear filter in SERVO mode

Cartesian space nonlinear filter under the mode, this command cannot be set in SERVOJ mode, but it can be set after quitting SERVOJ.

• Parameters
  • max_vp The upper limit (absolute value) of the move command speed in Cartesian space. Unit: mm/s
  • max_ap The upper limit (absolute value) of the move command accelerated speed in Cartesian space. Unit: mm/s^2
  • max_jp The unit of upper limit (absolute value) of the move command jerk in Cartesian space. mm/s^3
  • max_vr The upper limit of Cartesian space orientation change speed (absolute value) °/s
  • max_ar The upper limit of accelerated speed of Cartesian space orientation change speed (absolute value)°/s^2
  • max_jr The upper limit value of jerk (absolute value) of Cartesian space orientation change speed °/s^3
• Return value  ERR_SUCC Error or Success

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);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Cartesian nonlinear filter in SERVO mode  
int example_servo_use_carte_NLF()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Cartesian nonlinear filter in SERVO mode  
  ret = demo.servo_move_use_carte_NLF(2, 2, 4, 2, 2, 4);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Use joint multi-order mean filter in SERVO mode

Use joint space multi-order mean filter under the SERVO mode, this command cannot be set in SERVOJ mode but can be set after quitting SERVOJ.

• Parameters
  • max_buf The size of the mean filter buffer
  • kp Acceleration filter factor
  • kv Speed filter factor
  • ka Position filter factor
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Joint multi-order mean filter in SERVO mode  
int example_servo_use_joint_MMF()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Joint multi-order mean filter in SERVO mode  
  ret = demo.servo_move_use_joint_MMF(20, 0.2, 0.4, 0.2);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Set speed foresight parameter under robot servo mode

Joint space multi-order mean filter under the SERVO mode, this command cannot be set in SERVO mode but can be set after exiting SERVO.

• Parameters
  • max_buf the buffer size of the mean filter
  • kp acceleration filter factor
  • kv speed filter factor
  • ka position filter factor
• Return value ERR_SUCC Error or Success

errno_t servo_speed_foresight(int** max_buf, double kp);

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set speed foresight parameter under robot servo mode  
int example_speed_foresight()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Joint multi-order mean filter in SERVO mode  
  ret = demo.servo_speed_foresight(200, 2);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Robot Kinematics

Kine inverse

Calculate the kine inverse of the specified pose under the current tool, current installation angle, and current user coordinate frame settings.

• Parameters
  • ref_pos Reference joint position for kine inverse
  • cartesian_pose Cartesian space pose value
  • joint_pos Joint space position calculation result when calculation is successful
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Kine inverse of robot. Know tcp_pos,find joint_pos  
int example_kine_inverse()  
{  
  int ret;  
  JAKAZuRobot demo;  
  //Initialize reference points  
  JointValue ref_jpos = { 0.558, 0.872, 0.872 , 0.349, 0.191, 0.191 };  
  //Initialize Cartesian space point coordinates  
  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;  
  //Initialize return value  
  JointValue joint_pos = { 0,0,0,0,0,0 }; ;  
  demo.login_in("192.168.2.194");  
  //Kine inverse  
  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;  
 }  

Kine forward

Calculate the pose value of the specified joint position under the current tool, current installation angle and current user coordinate frame settings.

• Parameters
  • joint_pos Joint space position
  • cartesian_pose Calculation results of Cartesian space pose
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
// Kine forward of robot. Know tcp_pos,find joint_pos 
int example_kine_forward()  
{  
  int ret;  
  JAKAZuRobot demo;  
  //Initialize return value  
  CartesianPose tcp_pos;  
  demo.login_in("192.168.2.194");  
  //Initialize joint matrix  
  JointValue joint_pos = { 0.558, 0.872, 0.872 , 0.349, 0.191, 0.191 };  
  //Kine forward  
  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;  
 }   

Rpy to rotation matrix

Rpy to rot matrix.

• Parameters
  • rpy Rpy parameters to be converted
  • rot_matrix Rot matrix after conversion
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Rpy to rot matrix  
int example_rpy_to_rot_matrix()  
{  
  int ret;   
  JAKAZuRobot demo;  
  //Initialize rot matrix  
  Rpy rpy;  
  rpy.rx = -1.81826; rpy.ry = -0.834253;  rpy.rz = -2.30243;  
  //Initialize return value  
  RotMatrix rot_matrix;  
  demo.login_in("192.168.2.194");  
  //Rpy to rot matrix  
  ret = demo.rpy_to_rot_matrix(&rpy, &rot_matrix);  
  std::cout << ret << "eul2rotm" << 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;  
 }  

Rotation matrix to rpy

Rot matrix to rpy.

• Parameters
  • rot_matrix Rot matrix data to be converted
  • rpy RPY values obtained
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Rot matrix ---> rpy  
int example_rot_matrix_to_rpy()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //Initialize rpy  
  Rpy rpy;  
  //Initialize rot matrix  
  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;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own  controller.  
  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 \n", rpy.rx, rpy.ry, rpy.rz);  
  return 0;  
 }  

Quaternion to rotation matrix

Quaternion to to rot matrix.

• Parameters
  • quaternion Quaternion data to be converted
  • rot_matrix Rot matrix obtained
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Quaternion --> rot matrix  
int example_quaternion_to_rot_matrix()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //Initialize quaternion  
  Quaternion quat;  
  quat.s = 0.0629;  quat.x = 0.522886; quat.y = -0.5592;  quat.z = 0.6453;  
  //Initialize rot matrix  
  RotMatrix rot_matrix;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.  
  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;  
 } 

Get the DH parameters of the currently connected robot

Get the robot DH parameters.

• Parameters
  • dhParam DH parameters
• Return value ERR_SUCC Error or Success

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

Rotation matrix to quaternion

Rot matrix to quaternion.

• Parameters
  • rot_matrix Rot matrix to be converted
  • quaternion Converted quaternion result
• Return value  ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Rot matrix ---> quaternion  
int example_rot_matrix_to_quaternion()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //Initialize quaternion  
  Quaternion quat;  
  //Initialize rot matrix  
  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;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.  
  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;  
 }  

Force Control Robot

JAKA provides a set of force control interfaces based on torque sensors. Users can utilize these interfaces to implement advanced force control functions as compliance control and more. This enables the realization of complex application scenarios, such as Cartesian space-directed dragging and force-controlled assembly.

But these interfaces require additional configuration of end force sensors.

For better understanding of the content below and the use of related functions, we suggest our users to read User Manual for Force Control Products and (Click to download quick start). Also, in this chapter, force control refers to force compliant control. End force sensor, Force sensor or Sensor refers to the 1/6 dimensions force/torque sensor mounted at the end of the robot.

Set end sensor mode

• Parameters
  • sensor_brand: the mode of sensor, with a value range from 1-6 or a set value 10, and needs to be in consistent with the type number engraved on the sensor shell. 10 means the sensor embeded within the robots, which is managed by the system automatically, therefore it does not need to be configured by this interface.
• Return value ERR_SUCC Error or Success

errno_t set_torsenosr_brand(int sensor_brand);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set end sensor mode  
int example_set_torsensor_brand()  
{  
  int ret;  
  JAKAZuRobot demo;  
  demo.login_in("192.168.2.194");  
  demo.power_on();  
  demo.enable_robot();  
  //Set end sensor mode  
  ret = demo.set_torsenosr_brand(2);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Get end sensor mode

Get end sensor mode

• Parameters
  • sensor_brand Sensor modes
• Return value ERR_SUCC Error or Success

errno_t get_torsenosr_brand(int *sensor_brand);  

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Get sensor brand  
int example_get_torsensor_brand()  
{  
  int ret,cur_sensor;  
  JAKAZuRobot demo;  
  demo.login_in("192.168.2.194");  
  demo.power_on();  
  demo.enable_robot();  
  //Get sensor brand  
  ret = demo.get_torsenosr_brand(&cur_sensor);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Turn on/off end sensor

Turn on/off end sensor.

• Parameters
  • sensor_mode 0 means turning off the sensor, 1 means turning on the sensor
• Return value ERR_SUCC Error or Success

errno_t set_torque_sensor_mode(int sensor_mode);

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Turn on/off end sensor  
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);  
  //Turn on/off end sensor，1 is on，0 is off  
  ret = demo.set_torque_sensor_mode(1);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Set compliance control parameter

Set compliance control parameter.

• Parameters
  • axis Optional value from 0 to 5 to configure certain axis， corresponds to fx, fy, fz, mx, my, mz respectively
  • opt  0 means not checked non-zero values mean checked
  • ftUser Damping force, The force of user use to make the robot moves in a certain direction at the maximum speed
  • ftReboundFK Springback force, the force for the robot moves to the initial state
  • ftConstant Constant force, all set to 0 in manual operation
  • ftNnormalTrack Normal tracking, all set to 0 in manual operation
• Return value ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set compliance control parameters  
int example_set_admit_ctrl_config()  
{  
  int ret;  
  JAKAZuRobot demo;  
  demo.login_in("192.168.2.194");  
  demo.power_on();  
  demo.enable_robot();  
  //Set compliance control parameters  
  ret = demo.set_admit_ctrl_config(1,1,20,5,0,0);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Set sensor end payload

Set sensor end payload.

• Parameters
  • payload End payload. Unit:kg\mm
• Return value ERR_SUCC Error or Success

errno_t set_torq_sensor_tool_payload(const PayLoad *payload);  

Get end sensor's payload identification state

Get end sensor's payload identification state.

• Parameters
  • identify_status 0 means identification completed, 1 means in process, 2 means failure
• Return value ERR_SUCC Error or Success

errno_t get_torq_sensor_identify_staus(int *identify_status); 

Identify end sensor payload

Start to identify end sensor payload. This command will control the robot to move to a position specified by jointposition.

• Parameters
  • joint_pos The last position when the torque sensor is used for automatic payload. Refer to User Manual for Force Control Products and (Click to download quick start) for details.
• Return value ERR_SUCC Error or Success

errno_t start_torq_sensor_payload_identify(const JointValue *joint_pos); 

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Identify end sensor payload and acquire status  
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();  
  //end positions need to be set according to real applications, here is only for example, do not use directly
    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;
  //Start identifying sensor payloads 
  ret = demo.start_torq_sensor_payload_identify(&joint_pos);  
  do  
  {  
    Sleep(1);
    //Interrogate the status of sensor payloads  
    demo.get_torq_sensor_identify_staus(&ret);  
    std::cout << ret << std::endl;  
  } 
  while (1 == ret);  
  //Get identifying results  
  if(ret == 0) ret = demo.get_torq_sensor_payload_identify_result(&pl); 
  std::cout << ret << std::endl;  
  //Set end payloads of sensor  
  ret = demo.set_torq_sensor_tool_payload(&pl);  
  //Get the currently set sensor end load  
  ret = demo.get_torq_sensor_tool_payload(&pl_ret);  
  return 0;  
 }  

Get end sensor's payload identification result

Get end sensor's payload identification result.

• Parameters
  • payload End payload. Unit: kg\mm
• Return value ERR_SUCC Error or Success

errno_t get_torq_sensor_payload_identify_result(PayLoad *payload);  

Get end sensor payload

Get end sensor payload.

• Parameters
  • payload End payload. Unit: kg\mm
• Return value ERR_SUCC Error or Success

errno_t get_torq_sensor_tool_payload(PayLoad *payload);  

Set force control coordinate system

Note:

This interface is adapted to controller of version 1.7.1. In controller version 1.7.2, this interface is divided into different interfaces based on functions. When calling this interface in controller 1.7.2, all its replaced interfaces would be called, and parameters will be set accordingly.

• Parameters
  • ftFrame 0 means tools, 1 means world
• Return value ERR_SUCC Error or Success

errno_t set_ft_ctrl_frame(const int ftFrame); 

Get force control coordinate system

Note:

This interface is adapted to controller of version 1.7.1. In controller version 1.7.2, this interface is divided into different interfaces based on functions. When calling this interface in controller 1.7.2, it will return the force control coordinate system.

• Parameters
  • ftFrame 0 means tools, 1 means world
• Return value ERR_SUCC Error or Success

errno_t get_ft_ctrl_frame(int *ftFrame);  

Turn on/off too drive

Note:

This interface is adapted to controller of version 1.7.1. In 1.7.2, this interface will be divided into different interfaces. ::：

The sensor needs to be activated and appropriate compliance control parameters should be set. Additionally, it is recommended to perform at least one force sensor zero calibration before enabling tool drive.

• Parameters
  • enable_flag 0 means to turn off tool drag enabling, 1 means to turn on
• Return value ERR_SUCC Error or Success

errno_t enable_admittance_ctrl(const int enable_flag); 

Sample Code:

#include <iostream>    
#include "JAKAZuRobot.h"    
#include <windows.h>    
#define PI 3.1415926    
//turn on/off tool drive  
int example_enable_admittance_ctrl()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to use the IP of your own controller.  
  demo.login_in("10.5.5.100");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Turn on the force sensor  
  demo.set_torque_sensor_mode(1);  
  //Zero calibration the force sensor  
  demo.set_compliant_type(1, 0);  
  printf("inint sensor complen");  
  //Set compliance control parameters, here only illustates z direction
  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);  
  //Turn on tool drive  
  ret = demo.enable_admittance_ctrl(1);  
  printf("enable_admittance_ctrl open！\n");  
  std::cout << ret << std::endl;  
  printf("input any word to quit:\n");  
  std::cin >> ret; 
  //Turn off tool drive
  ret = demo.enable_admittance_ctrl(0);  
  printf("closen");  
  return 0;  
 }  

Set Force Control Type and Zero Calibration (Initialization) Settings

Note:

This interface is adapted to controller of version 1.7.1. In 1.7.2, this interface will be divided into different interfaces.

When the 1.7.2 controller calls this interface, it is only used to trigger zero calibration and set the force control type. Note that when sensor_compensation is set to 1, the compliance_type parameter must be set to 0. Additionally, you must wait 1 second before calling this interface again to set the compliance_type parameter.

• Parameters
  • sensor_compensation: 1 indicates that a sensor zero calibration will be performed immediately, and the real-time force curve on the app as well as the values returned from port 10000 for torqsensor[1][2] will switch to represent the actual external force. 0 means no calibration will be performed, and when not in force control mode, the real-time force curve on the app and the values returned from port 10000 for torqsensor[1][2] will switch to the raw sensor readings (if in force control mode, they will still represent the actual external force).
  • compliance_type: The force control type. 0 means not using any kind of compliance control method, 1 means using constant compliance control, and 2 means using speed compliance control.
• Return value ERR_SUCC Error or Success

errno_t set_compliant_type(int sensor_compensation, int compliance_type);  

Get Force Control Type and Zero Calibration (Initialization) Settings

Note:

This interface is adapted to controller of version 1.7.1. In 1.7.2, this interface will be divided into different interfaces.

When the 1.7.2 controller calls this interface, it is only used to achieve force control function, the parameters of sensor_compensation are invalid.

• Parameters
  • sensor_compensation Whether to enable sensor compensation, 1 means to start and initialize, 0 means not to initialize
  • compliance_type 0 means no compliant control, 1 means constant compliant control, 2 Means speed compliance control
• Return value ERR_SUCC Error or Success

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

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set force control type and sensor initial state  
int example_set_compliant_type()  
{  
  int ret,sensor_compensation,compliance_type;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  demo.servo_move_enable(TRUE);  
  //Set force control type and sensor (zero calibration) initial state  
  ret = demo.set_compliant_type(1,0);  
  std::cout << ret << std::endl;  
  //Get force control type and read state
  ret = demo.get_compliant_type(&sensor_compensation, &compliance_type);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Set force control compliant parameter

Note:

This interface is adapted to controller of version 1.7.1. In controller version 1.7.2, this interface is divided into different interfaces based on functions. When calling this interface in controller 1.7.2, all its replaced interfaces would be called, and parameters will be set accordingly.

• Parameters

  • axis:

    • 0 – X axis;
    • 1 – Y axis;
    • 2 – Z axis;
    • 3 – RX (rotation around X);
    • 4 – RY (rotation around Y);
    • 5 – RZ (rotation around Z).

  • opt：0 for off, 1 for on.

  • ftUser：Damping force, affecting the stiffness exhibited by the robot end-effector when interacting with the external environment. The larger this parameter, the greater the stiffness exhibited by the robot end-effector. The units are ×8 N·s/m (for x/y/z) and ×16 Nm·s/π (for rx/ry/rz).

  • ftReboundFK：Rebound force, representing the elastic coefficient between the robot's command trajectory (or initial position) and its position during compliance control. The units are N/mm (for x/y/z) and Nm/rad (for rx/ry/rz).

  • ftConstant：The target force, with units of N (for x/y/z) and Nm (for rx/ry/rz).

  • ftNnormalTrack：Interfaces for compatibility, must be set to 0 to ensure proper functioning.

  • Users can refer to User Manual for Force Control Products and (Click to download quick start) for detailed descriptions on above parameters.

• Return value ERR_SUCC Error or Success

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

Sample Code:

 #include <iostream>  
 #include "JAKAZuRobot.h"  
 #include <windows.h>  
   
 //set compliant force control parameters
 int example_set_admit_ctrl_config()  
 {  
    int ret  
    JAKAZuRobot demo; 
    demo.login_in("192.168.2.194");  
    demo.power_on();  
    demo.enable_robot();  
    //set compliant force control parameters
    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;  
}  

Get force control compliant parameter

Note:

This interface is adapted to controller of version 1.7.1. In controller version 1.7.2, this interface is divided into different interfaces based on functions. When calling this interface in controller 1.7.2, all its replaced interfaces would be called, and parameters will be set accordingly.

• Parameters
  • admit_ctrl_cfg The address storage of compliant force control parameters. An array made of 6 AdmitCtrlType parameters, corresponding to the compliant force control parameters of x, y, z, rx, ry, rz directions.
• Return value ERR_SUCC Error or Success

errno_t get_admit_ctrl_config(RobotAdmitCtrl *admit_ctrl_cfg);

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Get compliance force control parameters  
int example_get_admit_ctrl_config()  
{  
  RobotAdmitCtrl adm_ctr_cfg;  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Get compliance force control parameters  
  ret = demo.get_admit_ctrl_config(&adm_ctr_cfg);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Set sensor communication parameter

Set force control sensor communication parameter.

• Parameters
  • type Communication type, 0 means using network port or USB, 1 means using TIO
  • ip_addr Force control sensor address when using network port
  • port Force control sensor port number when using network port
  • ip_addr and port are unvalid when the value is 1or using a USB. Using the default parameters given in examples will do fine.
• Return value ERR_SUCC Error or Success

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

Get end sensor communication parameter

Get end sensor communication parameter.

• Parameters
  • type Communication type, 0 means using network port or USB, 1 means using TIO
  • ip_addr Force control sensor address when using network port
  • port Force control sensor port number when using network port
  • ip_addr and port are unvalid when using TIO or a USB. And the return value is invalid too.
• Return value ERR_SUCC Error or Success

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

Sample Code:

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;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.105 with the IP of your own controller.  
  printf("logining!n");  
  demo.login_in("192.168.2.106");  
  //Power on the robot  
  printf("poweringn");  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Set sensor mode  
  ret = demo.set_torsenosr_brand(4);  
  //Get sensor communication parameters  
  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;  
  //Set sensor communication parameters  
  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;  
 }  

Turn off force control

Turn off force control. Taking effect on compliant force control and speed complicant force control while excluding tool drive mode.

• Return value ERR_SUCC Error or Success

errno_t disable_force_control(); 

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Turn off force control  
int example_disable_force_control()  
{  
  int ret;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Turn off force control  
  ret = demo.disable_force_control();  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Set velocity compliance control parameter

Set velocity compliance control parameter.

• Parameters
  • vel_cfg velocity compliance control parameter
• Return value ERR_SUCC Error or Success

errno_t set_vel_compliant_ctrl(const VelCom *vel_cfg);

Set compliant force control condition

Note:

This interface is not suggested to use.

• Parameters
  • ft Compliance control torque condition, will stop if the torque exceeds this condition.
• Return value ERR_SUCC Error or Success

errno_t set_compliance_condition(const FTxyz *ft);

Sample Code:

#include <iostream>  
#include "JAKAZuRobot.h"  
#include <windows.h>  
#define PI 3.1415926  
//Set condition of speed compliant control  
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;  
  //Instance API object demo   
  JAKAZuRobot demo;  
  //login controller, you need to replace 192.168.2.194 with the IP of your own controller.  
  demo.login_in("192.168.2.194");  
  //Power on the robot  
  demo.power_on();  
  //Enable the robot  
  demo.enable_robot();  
  //Set condition of speed compliant control  
  ret = demo.set_compliance_condition(&ft);  
  std::cout << ret << std::endl;  
  return 0;  
 }  

Set Cutoff Frenquency of the Torque Sensor Low-pass Filter

Set the value of the low-pass filter for force control.

• Parameters
  • torque_sensor_filter The cutoff frequency of the low-pass filter. Unit: Hz.

errno_t set_torque_sensor_filter(const float torque_sensor_filter);  

Get Cutoff Frenquency of the Torque Sensor Low-pass Filter

Get the value of the low-pass filter for force control.

• Parameters
  • torque_sensor_filter The cutoff frequency of the low-pass filter. Unit: Hz.

errno_t get_torque_sensor_filter(float *torque_sensor_filter); 

Set end sensor's soft limit

• Parameters
  • torque_sensor_soft_limit : the maximum allowed force or torque values in each direction, with units of N (for force) and Nm (for torque). Exceeding these values will trigger an error, terminate the program, and stop the robot's movement.
• Force limit fx, fy, fz Unit：N
• Torque limit tx, ty, tz Unit：N*m

errno_t set_torque_sensor_soft_limit(const FTxyz torque_sensor_soft_limit);

Get end sensor's soft limit

• Parameters
  • torque_sensor_soft_limit : the maximum allowed force or torque values in each direction, with units of N (for force) and Nm (for torque). Exceeding these values will trigger an error, terminate the program, and stop the robot's movement.
  • Force limit fx, fy, fz Unit：N
  • Torque limit tx, ty, tz Unit：N*m

errno_t get_torque_sensor_soft_limit(FTxyz *torque_sensor_soft_limit);

In this chapter, interfaces below are adapted to controllers of version 1.7.2. If your controller is of this version and above, we suggest you to use this interface.

Zero calibration of force sensors

Trigger sensor zeroing and blocking for 0.5 seconds

errno_t zero_end_sensor();

Get the force sensor’s drag state

Get the drag-on status of the force control tool, that is, whether the controller is in admitting mode.

• Parameters
  • enable_flag: 0 is to turn off force control dragging, 1 is to turn it on, drive_stat is whether the current state of dragging triggers singularity point, speed, joint limit warning
• Return value ERR_SUCC Success Other failures

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

Get the force sensor’s coordinate system in drag mode

Get the tool drag coordinate system and call the new interface inside the controller.

• Parameters
  • toolDragFrame 0 Tool 1 World
• Return value ERR_SUCC Success Other failures

errno_t get_tool_drive_frame(FTFrameType *ftFrame);

Set the force sensor’s coordinate system in drag mode

Set the tool to drag the coordinate system and call the new interface inside the controller.

• Parameters
  • toolDragFrame 0 Tool 1 World
• Return value ERR_SUCC Success Other failures

errno_t set_tool_drive_frame(FTFrameType ftFrame);

Get fusion drive sensitivity

Get the fusion drag sensitivity.

errno_t get_fusion_drive_sensitivity_level(int *level);

Set fusion drive sensitivity

Set the drag sensitivity of the blend.

• Parameters sensitivity_level Sensitivity level, 0-5, 0 means off

errno_t set_fusion_drive_sensitivity_level(int level);

Get motion limit (singularity and joint limit) warning range

Get the warning range of motion limit (singularity point and joint limit)

errno_t get_motion_limit_warning_range(int *warningRange);

Set motion limit (singularity and joint limit) warning range

Set motion limit (singularity point and joint limit) warning range

• Parameters
  • range_level Range level, 1-5

errno_t set_motion_limit_warning_range(int warningRange);

Get force control speed limit

Get force control speed limit

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

Set force control speed limit

Set force control speed limit

• Parameters
  • speed_limit Line speed limit, mm/s
  • angular_speed_limit Angular velocity limit, rad/s

errno_t set_compliant_speed_limit(double vel, double angularVel);

Get torque reference center

errno_t get_torque_ref_point(int *refPoint);

Set torque reference center

• Parameters
  • ref_point 0 represents the sensor center, 1 represents TCP

errno_t set_torque_ref_point(int refPoint);

Get end sensor sensitivity

errno_t get_end_sensor_sensitivity_threshold(FTxyz *threshold);

Set end sensor sensitivity

• Parameters
  • threshold_percent 6-dimensional array, 0~1, the larger the value, the less sensitive the sensor

errno_t set_end_sensor_sensitivity_threshold(FTxyz threshold);

Sample Code:

Tips

This sample code is adapted to controllers of version 1.7.2 and above.

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

  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);
  
  //log out
  demo.login_out();
  
  cout << "end" << endl;
  return 0;
 
 }

FTP Service

Initialize FTP client

To initialize FTP client, establish connection with control cabinet, capable of exporting program, track.

• Return value ERR_SUCC Error or Success

errno_t init_ftp_client();

FTP upload

To upload local files with specified type and name to controller.

• Parameters
  • remote upload to the absolute path of the controller internal file name. If it is a folder, the name should be ended with " or "/"
  • local the absolute path of the local file name. If it is a folder, the name should be ended with a " or "/"
  • opt 1 means single file 2 means folder
• Return value ERR_SUCC Error or Success

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

FTP download

To download files with specified type and name from controller to local path.

• Parameters
  • remote controller internal file name absolute path, if it is a folder, the name should be ended with " or "/"
  • local download to the absolute path of local file name. If it is a folder, the name should be ended with a " "/"
  • opt 1 means single file 2 means folder
• Return value ERR_SUCC Error or Success

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

Interrogate FTP directory

Interrogate FTP directory.

• Parameters
  • remote the original file name of the controller internal file, Interrogate track "/track/". Interrogate script program "/program/"
  • opt 0 means file name and subdirectory name, 1 means file name, and 2 means subdirectory name
  • ret returned Interrogate result
• Return value ERR_SUCC Error or Success

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

Delete FTP

To delete files with specified type and name from controller.

• Parameters
  • remote controller internal file name
  • opt 1 means single file 2 means folder
• Return value ERR_SUCC Error or Success

errno_t del_ftp_file(char *remote, int opt);

Rename FTP

To rename controller files with specified type and name.

• Parameters
  • remote original file name of controller internal file
  • des target file name for the renamed file
  • opt 1 means single file 2 means folder
• Return value ERR_SUCC Error or Success

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

Close FTP client

To disconnect the link with controller FTP.

• Return value ERR_SUCC Error or Success

errno_t close_ftp_client();

List of Interface Call Return Values and Troubleshooting

Error Code	Description	Suggested Action
0	success	No action needed.
2	Interface error or controller not supported	Verify controller and SDK versions; consider upgrading or using another interface.
-1	Invalid handler	Ensure you call the login interface before using it.
-2	Invalid parameter	Check if the parameters are correct.
-3	Fail to connect	Verify network status or ensure the robot IP is correct.
-4	Kinematic inverse error	Check the current coordinate system or reference joint angles for validity.
-5	Emergency stop	E-stop status; reserved state.
-6	Not powered on	Power the robot.
-7	Not enabled	Enable the robot.
-8	Not in servo mode	Ensure servo mode is enabled before calling servoJP.
-9	Must turn off enable before power off	Disable before powering off.
-10	Cannot operate, program is running	Stop the running program first.
-11	Cannot open file, or file doesn't exist	Check if the file exists or can be accessed.
-12	Motion abnormal	Check for singularities or movements exceeding robot limits.
-14	FTP error	Investigate FTP connection issues.
-15	Socket message or value oversize	Ensure parameters are within acceptable limits.
-16	Kinematic forward error	Verify inputs for forward kinematics.
-17	Not support empty folder	Avoid using empty folders.
-20	Protective stop	Investigate and address protective stop conditions.
-21	Emergency stop	Check and reset the emergency stop.
-22	On soft limit	Use the teaching feature in the robot app to exit soft limits.
-30	Fail to encode command string	Likely an error in parsing controller messages.
-31	Fail to decode command string	Check for errors in controller message parsing.
-32	Fail to uncompress port 10004 string	Possible network fluctuation or data overflow.
-40	Move linear error	Verify the path avoids singularity regions.
-41	Move joint error	Ensure joint angles are valid.
-42	Move circular error	Check the circular motion parameters.
-50	Block wait timeout	Verify and increase wait timeout if needed.
-51	Power on timeout	Check the power-on process.
-52	Power off timeout	Check the power-off process.
-53	Enable timeout	Review the enabling process.
-54	Disable timeout	Review the disabling process.
-55	Set user frame timeout	Check the user frame settings.
-56	Set tool timeout	Verify the tool coordinate settings.
-60	Set IO timeout	Ensure IO configurations are correct.

Feedback

For any inaccurate descriptions or errors in the document, we would like to invite the readers to correct and criticize. In case of any questions during your reading or any comments you want to make, please send an email to <support@jaka.com,> and our colleagues will reply.