运动

所有的运动指令在执行之前都要上电操作

引入头文件

#include "BaseMove.h"
#include "RobotMove.h"

setMoveThread

说明

设置指令线程运行方式，设置后对所有指令起作用

示例

int isthread = 1;
setMoveThread(isthread);//设置线程运行

wait_move_finish

说明

等待运动结束（开线程运行时有效）

示例

int robot_index = 0;
int state = wait_move_finish(robot_index);

get_robot_move_state

说明

获取机器人运动状态

示例

get_robot_move_state(0)

Rsleep

说明

设置机器人休眠

示例

void sleeptest()
{

    printf("sleep 5\n");
    sleep(5);

    printf("usleep 50005000000\n");
    usleep(5000000);

    printf("usleep 10000\n");
    RSleep2(5);

    printf("sleep test over\n");
}

AccSet

说明

设置机器人运动速度的百分比（加速度和加加速度），当机器人搬运易碎物品时，可使用AccSet 指令来降低加速度和减速度以达到更加平顺的运动 效果。

示例

AccSet(50, 100, 0); //设置索引0的机器人加速度大小被降低为系统预设值的50%，加速度变化率（即加加速度或jerk）保持不变。

move_start

说明

机器人上电或开始运动

move_stop

说明

机器人停止运动或下电

MoveA

说明

使机器人进行MoveA运动，用于对机器人末端运动轨迹没有要求的场合，使机器人快速的从一个点运动到另一个点。所有的轴同步运动，机器人末端沿一条不规则的曲线移动，请注意是否有发生碰撞的危险。

示例

void moveA_test()
{
    robjoint rjoint; // 定义关节
    getrobjoint("j0",&rjoint); //从数据文件获取关节角度
    speed rspeed;
    getspeed("V0", &rspeed); //从数据文件获取运动速度
    START(); //上电
    moveA(&rjoint, &rspeed, NULL, NULL, NULL);
    END();//下电
}

机器人将运动至 j0 位置

dual_moveA

说明

双臂绝对位置运动指令，控制两个机器人的末端运动

示例

robjoint rjoint1,rjoint2; // 定义关节
getrobjoint("j0",&rjoint1); //从数据文件获取关节角度
getrobjoint("j1",&rjoint2);
speed rspeed1,rspeed2;
getspeed("V0", &rspeed1); //从数据文件获取运动速度
getspeed("V1", &rspeed2);
START(); //上电
dual_moveA(&rjoint1,&rjoint2, &rspeed1, &rspeed2,NULL, NULL, NULL,NULL, NULL, NULL);
END();//下电

multi_moveA

说明

选取多机械臂中的一个做绝对位置运动指令

示例

与moveA类似，只是增加了机器人的索引号

multi_moveA(&rjoint, &rspeed, NULL, NULL, NULL,0);

moveJ

说明

MoveJ Move The Robot By Joint Movement 用于对机器人末端运动轨迹没有要求的场合，使机器人快速的从一个点运动到另一个点。所有的轴同步运动，机器人末端沿一条不规则的曲线移动，请注意是否有发生碰撞的危险。

示例

void movej_test()
{
    int ret=0;

    robjoint rjoint;
    speed rspeed;
    getrobjoint("j1", &rjoint);
    getspeed("v1", &rspeed);
    while (1)
    {
        ret=movej(&rjoint, &rspeed, NULL, NULL, NULL, 0, 1);
        printf("=====%d\n",ret);
    }
}

dual_moveJ

说明

双臂关节运动指令

示例

dual_moveJ(&rjoint1,&rjoint2, &rspeed1, &rspeed2,NULL, NULL, NULL,NULL, NULL, NULL);

multi_moveJ

说明

选取多机械臂中的一个做绝对位置运动指令

示例

multi_moveJ(&rjoint, &rspeed, NULL, NULL, NULL,0);

moveL

说明

MoveL Move Line 用于将工具中心点 TCP沿直线移动到给定的目标位置。 当起点和终点姿态不同时，姿态将与位置同步旋转到终点的姿态 。由于平移和旋转速度是分开指定的，为了保证不超出指定速度的限制，MoveL指令最终的运动时间取决于姿态和位置变化时间较长的那一个。因此在 执行某些特定轨迹（例如位移很小而姿态变化很大）时 ，如果机器人运动速度明显过慢或过快，请检查旋转速度设置是否合理。当需要保持工具中心点TCP静止，而只调整工具姿态时，可以通过 为 MoveL指定位置相同但姿态不同的起点和终点 来实现。

示例

void moveL_test()
{
//  sleep(5);
    robpose rpose;
    getrobpose("p0",&rpose);//从数据文件获取关节角度
    speed rspeed;
    getspeed("V0", &rspeed);//从数据文件获取运动速度
    START();//上电
    moveL(&rpose, &rspeed, NULL, NULL, NULL);
    END();//下电
}

dual_moveL

说明

双臂线性运动指令

示例

dual_moveL( &rpose1, &rpose2, &rspeed1, &rspeed2,NULL,NULL,NULL,NULL,NULL,NULL);

multi_moveL

说明

选取多机械臂中的一个做线性运动指令

示例

multi_moveL(&rpose, &rspeed, &rzone, NULL, NULL, 0);

moveC

说明

MoveC Move Circle 用于将工具中心点 TCP沿 圆弧 经过中间辅助点 移动到给定的目标位置。 当起点和终点姿态不同时，姿态将 与 位置同步 旋转到终点的姿态 ，辅助点的姿态 不影响圆弧运动过程 。 由于平移和旋转速度是分开指定的，为了保证不超出指定速度的限制，MoveC指令最终的运动时间取决于姿态和位置变化时间较长的那一个。 因此在某些特定轨迹（例如位移很小而姿态变化很大）下，如果机器人运动速度明显过慢或过快，请检查旋转速度设置是否合理。

示例

void moveC_test()
{
//  sleep(5);
    robpose rpose;
    getrobpose("p0",&rpose);//从数据文件获取关节角度
    robpose rpose_min;
    getrobpose("p1",&rpose_min);//从数据文件获取关节角度
    speed rspeed;
    getspeed("V0", &rspeed);//从数据文件获取运动速度
    START();//上电
    moveC(&rpose, &rpose_min, &rspeed, NULL, NULL, NULL);
    END();//下电
}

dual_moveC

说明

双臂圆弧运动指令

示例

dual_moveC( &rpose1, &rpose2, &rspeed1, &rspeed2,NULL,NULL,NULL,NULL,NULL,NULL);

multi_moveC

说明

选取多机械臂中的一个做圆弧运动指令

示例

multi_moveC(&rpose, &rpose_mid,&rspeed, &rzone, NULL, NULL, NULL,0);

moveH

说明

螺旋线运动指令, 用于将工具中心点沿“螺旋线”经过中间辅助点移动到给定的目标位置。这条指令在处理某些打磨工艺时非常有用。与MoveC 一样，MoveT 指令也需要同时给定辅助点和目标点，但是不论辅助点和目标点姿态如何，在整个运动过程中工具的姿态都不会变化，始终保持与起点相同.

示例

dual_moveH

说明

双臂螺旋线运动指令

示例

multi_moveH

说明

选取多机械臂中的一个做螺旋线运动指令

示例

multi_moveH(robpose* rpose, robpose* rpose_mid, robpose* pose_line, double screw, speed* rspeed, zone* rzone, tool* rtool, wobj* rwobj, int _index);

moveS

说明

关节空间的B样条运动

示例

int value = moveS(char *filename, speed *rspeed, tool *rtool, wobj *rwobj);

dual_moveS

说明

双臂关节空间的B样条运动

示例

dual_moveS("filename1", "filename2",&rspeed1,  &rspeed2, NULL, NULL, NULL, NULL);

multi_moveS

说明

选取多机械臂中的一个做关节空间的B样条运动

示例

multi_moveS("filename", &rspeed, NULL, NULL, 0);

Offs

说明

位置偏移函数 ，用于把某个点在当前指令中指定的工件坐标系下偏移 一段距离并返回新点的 位置值，偏移量由 x、 y、 z三个量来表示，仅支持位置平移，不支持姿态旋转。

示例

//笛卡尔空间相对rpose1沿着工件坐标系的z轴移动100mm
robpose op=Offs(&rpose1,0,0,100,0,0,0);

OffsRel

说明

机器人位姿相对偏移补偿

示例

//笛卡尔空间相对rpose1沿着工具坐标系的z轴移动100mm并绕z轴选择1rad
robpose orp=OffsRel(&rpose1,0,0,0,0,1,0);

<<<<<<< HEAD

robot_getJoint

说明

获取机器人当前关节角

示例

 double joint[ROBOT_MAX_DOF];
 int index = request->req();
 robot_getJoint(joint, index);

robot_getCartesian

说明

获取机器人当前位姿, 成功返回0，失败返回其他

示例

int err =  robot_getCartesian(NULL,NULL, &pospose, 0);

SetDo

说明

设置某个数字输出信号的值。

示例

int i_id=0;
int set_value=0;
SetDo(i_id,set_value);

GetDi

说明

获取数字量输入

示例

int i_id=0;
int get_value=0;
get_value=GetDi(i_id);

WaitDi

说明

等待数字量输入赋值

示例

int id = 0;
int value = 0;
WaitDi(id, value);

SetAo

说明

设置模拟量输出

示例

int id = 0;
double flag = 0;
SetAo(id, flag);

GetAi

说明

获取模拟量输入

示例

int id = 0;
double valAi = GetAi(id);

robot_getDOF

说明

获取机器人自由度

示例

int index = 0;
int dof = robot_getDOF(index);

additionaxis_getDOF

说明

获取机器人附加轴数量

示例

int index = 0;
int dof = additionaxis_getDOF(index);

robot_getNUM

说明

获取机器人数量

示例

int num = robot_getNUM();

additionaxis_getNUM

说明

获取附加轴组数量

示例

int num = additionaxis_getNUM();

SocketCreate

说明

建立一个Socket连接 ，通过使用 Socket指令，程序可以从外部设备获取数据或者向外发送程序数据。 Socket指令是基于 TCP/IP协议的，因此理论上任何支持 TCP/IP的外部设备都可以和 RL程序通信以交换数据。所有发送给Socket指令的数据（即使用 SocketRead系列指令接收的数据），都应该以“回车”结尾，在接收到“回车”之前的所有数据都将合并做为同一条数据处理。使用Socket功能时，机器人控制器仅支持作为 client连接外部 server。

示例

char * ip = strdup(socketIP.c_str()); 
int port = request->reqint();
std::string socketName = request->reqstr2();
char * sName = strdup(socketName.c_str());
int return_value = SocketCreate(ip, port, sName);

ClientCreate

说明

创建socket client

示例

char* name="c1";
int err=ClientCreate(NULL, 6660, name);

SocketClose

说明

关闭socket（含server和client）

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int return_value = SocketClose(sName);

SocketSendByteI

说明

TCP发送Byte型数据

示例

int len = request->req();  

std::string datastr = request->reqarr();
byte* data_bytes = (byte*)datastr.c_str();
std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int return_value = SocketSendByteI(data_bytes, len, sName);

SocketRecvByteI

说明

TCP接收Byte型数据

示例

int return_value = SocketRecvByteI(data_bytes, len, sName);

SocketSendByteII

说明

TCP发送数据

示例

int return_value = SocketSendByteII(header, header_format, hf_len, data_int, data_float, data_format, df_len, sName);

SocketRecvByteII

说明

TCP接收数据

示例

len=SocketRecvByteII(header,  header_format, hf_len, data_int, data_float, data_format, df_len, name);
    if (len<0)
    {
        printf("SocketRecvByteII failure");
        SocketClose(name);
        return NULL;
    }

SocketSendByte

说明

通过TCP发送一个byte型数据

示例

int return_value = SocketSendByte(dataArray, sName);

SocketRecvByte

说明

通过TCP接收一个byte型数据

示例

int return_value = SocketRecvByte(dataArray, sName);

SocketSendString

说明

通过TCP发送一个String型数据

示例

std::string socketData = request->reqstr1();
char * data = strdup(socketData.c_str()); 
std::string socketName = request->reqstr2();
char * sName = strdup(socketName.c_str()); 
int return_value = SocketSendString(data, sName);

SocketRecvString

说明

通过TCP接收一个String型数据

示例

char data[DATALEN_SOCKET_RECV]; 
std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int return_value = SocketRecvString(data, sName);

SocketSendDouble

说明

通过TCP发送一个double型数据

示例

double data = request->req();
std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 

int return_value = SocketSendDouble(data, sName);

SocketRecvDouble

说明

通过TCP接收一个double型数据

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
double dataArray[2];
int return_value = SocketRecvDouble(dataArray, sName);

SocketSendInt

说明

通过TCP发送一个int型数据

示例

int data = request->req();
std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int return_value = SocketSendInt(data, sName);

SocketRecvInt

说明

通过TCP接收一个int型数据

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int dataArray[2];
int return_value = SocketRecvInt(dataArray, sName);

SocketSendByteArray

说明

通过TCP发送一个byte型数组

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int len = request->req();

HYYRobotBase::byte dataArray[DATALEN_SOCKET_RECV];
char charArray[DATALEN_SOCKET_RECV];
int return_value = -1;
if(len>1){
  return_value = SocketSendByteArray(dataArray, len, sName);

SocketRecvByteArray

说明

通过TCP接收一个byte型数组

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int len = request->req();

HYYRobotBase::byte dataArray[DATALEN_SOCKET_RECV];
char charArray[DATALEN_SOCKET_RECV];
int return_value = -1;
if(len>1){
  return_value = SocketRecvByteArray(dataArray, sName);

SocketSendDoubleArray

说明

通过TCP发送一个double型数组

示例

int LEN = request->req();
double data[LEN];  
std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int return_value = SocketSendDoubleArray(data, LEN, sName);

SocketRecvDoubleArray

说明

通过TCP接收一个double型数组

示例

Status SocketRecvDoubleArray(ServerContext* context, const robot::ReqStrInt* request,
      robot::StatusArraydoubleRet* resp)  override{  //

    std::string socketName = request->reqstr();
    char * sName = strdup(socketName.c_str()); 

    double dataArray[DATALEN_SOCKET_RECV];
    int return_value = HYYRobotBase::SocketRecvDoubleArray(dataArray, sName);
    for(int ii=0; ii<DATALEN_SOCKET_RECV; ii++) {
        resp->add_data(dataArray[ii]);
    }
    resp->set_ret(return_value);

    std::cout << "SocketRecvDoubleArray OK " << std::endl;
    return Status::OK;
  }

SocketSendIntArray

说明

通过TCP发送一个int型数组

示例

 Status SocketSendIntArray(ServerContext* context, const robot::ReqArrayintIntStr* request,
      robot::StatusInt* resp)  override{  //

    int LEN = request->req();
    int dataArray[LEN]; 
    for(int ii=0; ii<LEN; ii++) {
        dataArray[ii] = request->reqarr(ii);
    }     
    std::string socketName = request->reqstr();
    char * sName = strdup(socketName.c_str()); 
    int return_value = HYYRobotBase::SocketSendIntArray(dataArray, LEN, sName);
    resp->set_data(return_value);

    std::cout << "SocketSendIntArray OK " << std::endl;
    return Status::OK;
  }

SocketRecvIntArray

说明

通过TCP接收一个int型数组

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int dataArray[DATALEN_SOCKET_RECV];
int return_value = HYYRobotBase::SocketRecvIntArray(dataArray, sName);

UDPSendByteI

说明

UDP发送Byte型数据

示例

int len = request->req();  

std::string datastr = request->reqarr();
byte* data_bytes = (byte*)datastr.c_str();
std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 
int return_value = UDPSendByteI(data_bytes, len, sName);

UDPRecvByteI

说明

UDP接收Byte型数据

示例

Status UDPRecvByteI(ServerContext* context, const robot::ReqStrInt* request,
      robot::StatusArraybytesRet* resp)  override{  //

    int len = request->req();
    HYYRobotBase::byte data_bytes[len];

    std::string socketName = request->reqstr();
    char * sName = strdup(socketName.c_str()); 

    int return_value = HYYRobotBase::UDPRecvByteI(data_bytes, len, sName);
    const char * databytes = (char *)data_bytes; 
    resp->set_data(databytes);     
    resp->set_ret(return_value);

    std::cout << "UDPRecvByteI OK " << std::endl;
    return Status::OK;
  }

UDPSendByteII

说明

UDP发送数据

示例

int return_value = UDPSendByteII(header, header_format, hf_len, data_int, data_float, data_format, df_len, sName);

UDPRecvByteII

说明

UDP接收数据

示例

len=UDPRecvByteII(header,  header_format, hf_len, data_int, data_float, data_format, df_len, name);
    if (len<0)
    {
        printf("UDPRecvByteII failure");
        UDPClose(name);
        return NULL;
    }

UDPSendByte

说明

通过UDP发送一个byte型数据

示例

int return_value = UDPSendByte(dataArray, sName);

UDPRecvByte

说明

通过UDP接收一个byte型数据

示例

int return_value = UDPRecvByte(dataArray, sName);

UDPSendString

说明

通过UDP发送一个String型数据

示例

std::string UDPData = request->reqstr1();
char * data = strdup(UDPData.c_str()); 
std::string UDPName = request->reqstr2();
char * sName = strdup(UDPName.c_str()); 
int return_value = UDPSendString(data, sName);

UDPRecvString

说明

通过UDP接收一个String型数据

示例

char data[DATALEN_UDP_RECV]; 
std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 
int return_value = UDPRecvString(data, sName);

UDPSendDouble

说明

通过UDP发送一个double型数据

示例

double data = request->req();
std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 

int return_value = UDPSendDouble(data, sName);

UDPRecvDouble

说明

通过UDP接收一个double型数据

示例

std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 
double dataArray[2];
int return_value = UDPRecvDouble(dataArray, sName);

UDPSendInt

说明

通过UDP发送一个int型数据

示例

int data = request->req();
std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 
int return_value = UDPSendInt(data, sName);

UDPRecvInt

说明

通过UDP接收一个int型数据

示例

std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 
int dataArray[2];
int return_value = UDPRecvInt(dataArray, sName);

UDPSendByteArray

说明

通过UDP发送一个byte型数组

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int len = request->req();
HYYRobotBase::byte dataArray[DATALEN_UDP_RECV];
char charArray[DATALEN_UDP_RECV];
int return_value = -1;
if(len>1){
  return_value = UDPSendByteArray(dataArray, len, sName);

UDPRecvByteArray

说明

通过UDP接收一个byte型数组

示例

std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 
int len = request->req();

HYYRobotBase::byte dataArray[DATALEN_UDP_RECV];
char charArray[DATALEN_UDP_RECV];
int return_value = -1;
if(len>1){
  return_value = UDPRecvByteArray(dataArray, sName);

UDPSendDoubleArray

说明

通过UDP发送一个double型数组

示例

int LEN = request->req();
double data[LEN];  
std::string UDPName = request->reqstr();
char * sName = strdup(UDPName.c_str()); 
int return_value = UDPSendDoubleArray(data, LEN, sName);

UDPRecvDoubleArray

说明

通过UDP接收一个double型数组

示例

Status UDPRecvDoubleArray(ServerContext* context, const robot::ReqStrInt* request,
      robot::StatusArraydoubleRet* resp)  override{  //

    std::string UDPName = request->reqstr();
    char * sName = strdup(UDPName.c_str()); 

    double dataArray[DATALEN_UDP_RECV];
    int return_value = HYYRobotBase::UDPRecvDoubleArray(dataArray, sName);
    for(int ii=0; ii<DATALEN_UDP_RECV; ii++) {
        resp->add_data(dataArray[ii]);
    }
    resp->set_ret(return_value);

    std::cout << "UDPRecvDoubleArray OK " << std::endl;
    return Status::OK;
  }

UDPSendIntArray

说明

通过UDP发送一个int型数组

示例

 Status UDPSendIntArray(ServerContext* context, const robot::ReqArrayintIntStr* request,
      robot::StatusInt* resp)  override{  //

    int LEN = request->req();
    int dataArray[LEN]; 
    for(int ii=0; ii<LEN; ii++) {
        dataArray[ii] = request->reqarr(ii);
    }     
    std::string UDPName = request->reqstr();
    char * sName = strdup(UDPName.c_str()); 
    int return_value = HYYRobotBase::UDPSendIntArray(dataArray, LEN, sName);
    resp->set_data(return_value);

    std::cout << "UDPSendIntArray OK " << std::endl;
    return Status::OK;
  }

UDPRecvIntArray

说明

通过UDP接收一个int型数组

示例

std::string socketName = request->reqstr();
char * sName = strdup(socketName.c_str()); 
int dataArray[DATALEN_UDP_RECV];
int return_value = HYYRobotBase::UDPtRecvIntArray(dataArray, sName);

ThreadCreat

说明

创建线程

示例

int return_value =  ThreadCreat(fun, NULL, name, 0);

ThreadDataFree

说明

线程数据释放

示例

char * tname;
int return_value = ThreadDataFree(tname);

ThreadWait

说明

thread join (当线程属性为PTHREAD_CREATE_JOINABLE时有效)

示例

char * tname;
int return_value = ThreadWait(tname);

SFCInit

说明

创建传感器力控制数据

示例

//初始化力控制
int ret=SFCInit("SFCtest", 0, 0, &to, &wo, 0);

SFCSetHybridForceMotionCtrlParam

说明

设置力位混合控制参数

示例

ret=SFCSetHybridForceMotionCtrlParam("SFCtest", P, I, D);

SFCSetHybridForceMotionTargetForce

说明

设置力位混合控制目标力矩

示例

double target_force[6]={0,0,0,0,0,5};
ret=SFCSetHybridForceMotionTargetForce("SFCtest", target_force);

SFCSetAdmittanceCtrlParam

说明

设置导纳控制参数

示例

double M[6]={1,1,1,1,1,1};
double B[6]={80,80,80,80,80,80};
double K[6]={1000,1000,1000,1000,1000,1000};
ret=SFCSetAdmittanceCtrlParam("SFCtest", M, B, K);

SFCSetSensorMaxForce

说明

设置传感器接触力限制

示例

double target_force[6]={0,0,0,0,0,5};
ret=SFCSetSensorMaxForce("SFCtest", Max_force);

SFCStart

说明

启动传感器力控制（期望的运动目标由Move运动提供）

示例

//开启力控制
ret=SFCStart("SFCtest");

SFCEnd

说明

停止传感器力控制

示例

ret=SFCEnd("SFCtest");