robotStruct.h

浏览该文件的文档.

 
#ifndef ROBOTSTRUCT_H_
#define ROBOTSTRUCT_H_
 
/*---------------------------- Includes ------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
 
 
#ifdef __cplusplus
namespace HYYRobotBase
{
extern "C" {
#endif
 
 
/*---------------------------- Defines -------------------------------------*/
#define ROBOT_MAX_NUM 10
#define ROBOT_MAX_DOF 10
#define MAX_CHAR_NUM 300
#define MAX_BSPLINE_NUM 200
#define ROBOT_DATA_NAME_LEN_MAX 10
 
typedef unsigned char byte;
 
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef enum{
    _other=0,  
    _ethercat,  
    _ur, 
    _aubo,
    _custom,  
}controller_mode;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct{
    char* path; 
    controller_mode mode; 
    int dete_background;
    int EtherCATonly;
    int server_modbus;
    int port;
    int iscopy;
}command_arg;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct PayLoad{
    double m;
    double cm[3];
    double I[3][3];
    double I2[3][3];
}PayLoad;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct robjoint{
    double angle[ROBOT_MAX_DOF];
    int dof;
}robjoint;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct robpose{
    double xyz[3];
    double kps[3];
}robpose;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct speed{
    double per[ROBOT_MAX_DOF];
    int per_flag;
    double tcp;
    double orl;
    int tcp_flag;
    int dof;
}speed;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct zone{
    int zone_flag;
    double zone_size;
}zone;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct tool{
    int robhold;
    robpose tframe;
    PayLoad payload;
}tool;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct wobj{
    int robhold;
    int ufprog;
    int ufmec;
    robpose uframe;
    robpose oframe;
}wobj;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct{
    double angle[ROBOT_MAX_DOF];
    int dof;
}ROBJOINT;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct{
    double xyzkps[6];
}ROBPOSE;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct{
    double per[ROBOT_MAX_DOF];
    int per_flag;
    double tcp;
    double orl;
    int tcp_flag;
 
    int dof;
}SPEED;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct{
    int zone_flag;
    double zone_size;
}ZONE;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct{
    int robhold;
    double toolframe[6];
    PayLoad payload;
}TOOL;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef struct{
    int robhold;
    int ufprog;
    int ufmec;
    double userframe[6];
    double workframe[6];
}WOBJ;
 
/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
typedef enum robdatatype{
    _robjoint,
    _robpose,
    _speed,
    _zone,
    _tool,
    _wobj
}robdatatype;
 
extern int getDataNum(robdatatype rdt);
 
extern int getDataName(robdatatype rdt, int n, char* dataname);
 
extern int getrobjoint(const char* J, robjoint* rjoint);
 
extern int getrobpose(const char* P, robpose* rpose);
 
extern int getspeed(const char* S, speed* sp);
 
extern int getzone(const char* Z, zone* zo);
 
extern int gettool(const char* T, tool* to);
 
extern int getwobj(const char* W, wobj* wo);
 
extern int writerobjoint(const char* J,robjoint* rjoint);
 
extern int writerobpose(const char* P, robpose* rpose);
 
extern int writespeed(const char* S, speed* sp);
 
extern int writezone(const char* Z, zone* zo);
 
extern int writetool(const char* T, tool* to);
 
extern int writewobj(const char* W, wobj* wo);
 
extern void init_robjoint(robjoint* rjoint, double* data, int dof);
 
extern void init_robpose(robpose* rpose, double* xyz, double* rpy);
 
extern void init_speed_joint(speed* sp, double* data, int dof, int flag);
 
extern void init_speed_cartesian(speed* sp, double tcp, double orl, int flag);
 
extern void init_speed(speed* sp, double* data, int dof, int per_flag, double tcp, double orl, int tcp_flag);
 
extern void init_zone(zone* ze, double size,  int flag);
 
extern void init_tool(tool* tl, double* frame, int robhold, PayLoad* payload);
 
extern void init_wobj(wobj* wj, double* userframe, double* workframe,  int robhold, int ufprog, int ufmec);
 
extern void init_PayLoad(PayLoad* pl,double m, double* cm,double (*I)[3]);
 
extern void parse_robjoint(robjoint* rjoint, double* data, int* dof);
 
extern void parse_robpose(robpose* rpose, double* xyz, double* rpy);
 
extern void parse_speed_joint(speed* sp, double* data, int*dof, int* flag);
 
extern void parse_speed_cartesian(speed* sp, double* tcp, double* orl, int* flag);
 
extern void parse_speed(speed* sp, double* data, int*dof, int* per_flag, double* tcp, double* orl, int* tcp_flag);
 
 
extern void parse_zone(zone* ze, double* size,  int* flag);
 
extern void parse_tool(tool* tl, double* frame, int* robhold, PayLoad* payload);
 
extern void parse_wobj(wobj* wj, double* userframe, double* workframe,  int* robhold, int* ufprog, int* ufmec);
 
extern void parse_PayLoad(PayLoad* pl,double* m, double* cm,double (*I)[3]);
 
 
/*说明:数据批量操作接口,用于操作数据量较大时使用,如批量读取和写入.数据量较小时可用get***(),write***()等接口操作.数据量大时建议使用批量操作接口.
 *          使用时利用CreatDataBatch()创建批量操作数据,创建时需要指定操作数据类型和读(0)写(1)方式,再利用数据类型对应的get***_batch() 或write***_batch()进行读或写操作,
 *          操作完成,必须使用FreeDataDatch()释放操作数据.
 *
 * 使用代码例子:
 *             void robot_read_data_batch_test()
 *             {
 *                  int err=0;
 *                  char name[ROBOT_DATA_NAME_LEN_MAX];
 *              robjoint rjoint;
 *              double angle[ROBOT_MAX_DOF];
 *              int dof=0;
 *              int num=CreatDataBatch(_robjoint, 0);//创建批操作数据
 *              if (num<0)
 *              {
 *                  printf("CreatDataBatch failure\n");
 *                  return;
 *              }
 *              int i=0;
 *              int j=0;
 *              for (i=0;i<num;i++)
 *              {
 *                  err=getrobjoint_batch(name,&rjoint, i);//获取索引为i的数据内容及名字
 *                  if (0!=err)
 *                  {
 *                      printf("getrobjoint_batch failure\n");
 *                      break;
 *                  }
 *                  //------------------------------数据使用------------------
 *                  parse_robjoint(&rjoint, angle, &dof);//解析数据
 *                  printf("读取数据名字:%s,数据维度%d, 数据内容: ",name,dof);
 *                  for (j=0;j<dof;j++)
 *                  {
 *                      printf("%f,",angle[j]);
 *                  }
 *                  printf("\n");
 *              }
 *              err=FreeDataDatch();//释放批操作数据
 *                  if (0!=err)
 *                  {
 *                      printf("FreeDataDatch failure\n");
 *                  }
 *             }
 *
 *             void robot_write_data_batch_test()
 *             {
 *              char name[ROBOT_DATA_NAME_LEN_MAX];
 *              robjoint rjoint;
 *              double angle[ROBOT_MAX_DOF];
 *              int dof=0;
 *              int err=CreatDataBatch(_robjoint, 1);//创建批操作数据
 *              if (err<0)
 *              {
 *                  printf("CreatDataBatch failure\n");
 *                  return;
 *              }
 *              int i=0;
 *              int num=10;//写入十个数据
 *              for (i=0;i<num;i++)
 *              {
 *                  //------------------------设置写入数据----------------------------
 *                  dof=6;//设置数据维度要与机器人自由度一致,可以通过相应接口获取
 *                  angle[0]=0;angle[1]=0;angle[2]=0;angle[3]=0;angle[4]=1;angle[5]=0;
 *                  sprintf(name,"%s,%d","J",i);//设置数据名称
 *                  init_robjoint(&rjoint, angle, dof);//设置机器人数据
 *                  //------------------写入数据----------------------
 *                  err=writerobjoint_batch(name,&rjoint);
 *                  if (0!=err)
 *                  {
 *                      printf("getrobjoint_batch failure\n");
 *                      break;
 *                  }
 *              }
 *              err=FreeDataDatch();//释放批操作数据
 *              if (0!=err)
 *              {
 *                  printf("FreeDataDatch failure\n");
 *              }
 *             }
 *
 * */
 
extern int CreatDataBatch(robdatatype rdt, int RW_flag);
 
extern int FreeDataDatch();
 
extern int getrobjoint_batch(char* J,robjoint* rjoint, int index);
 
extern int getrobpose_batch(char* P,robpose* rpose, int index);
 
extern int getspeed_batch(char* S, speed* sp, int index);
 
extern int getzone_batch(char* Z, zone* zo, int index);
 
extern int gettool_batch(char* T, tool* to, int index);
 
extern int getwobj_batch(char* W, wobj* wo, int index);
 
extern int writerobjoint_batch(const char* J,robjoint* rjoint);
 
extern int writerobpose_batch(const char* P, robpose* rpose);
 
extern int writespeed_batch(const char* S, speed* sp);
 
extern int writezone_batch(const char* Z, zone* zo);
 
extern int writetool_batch(const char* T, tool* to);
 
extern int writewobj_batch(const char* W, wobj* wo);
 
 
 
 
#ifdef __cplusplus
}
}
#endif
 
 
#endif /* ROBOTSTRUCT_H_ */