ARCS SDK API  0.24.0
robot_config.h
浏览该文件的文档.
1 /** @file robot_config.h
2  * @brief 获取机器人配置接口，如获取DH参数、碰撞等级、安装位姿等等
3  */
4 #ifndef AUBO_SDK_ROBOT_CONFIG_H
5 #define AUBO_SDK_ROBOT_CONFIG_H
6 
7 #include <vector>
8 #include <unordered_map>
9 
10 #include <aubo/global_config.h>
11 #include <aubo/type_def.h>
12 
13 namespace arcs {
14 namespace common_interface {
15 
16 class ARCS_ABI_EXPORT RobotConfig
17 {
18 public:
19  RobotConfig();
20  virtual ~RobotConfig();
21 
22  /**
23  * 获取机器人的名字
24  *
25  * @return 返回机器人的名字
26  *
27  * @throws arcs::common_interface::AuboException
28  *
29  * @par Python函数原型
30  * getName(self: pyaubo_sdk.RobotConfig) -> str
31  *
32  * @par Lua函数原型
33  * getName() -> string
34  *
35  * @par JSON-RPC请求示例
36  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getName","params":[],"id":1}
37  *
38  * @par JSON-RPC响应示例
39  * {"id":1,"jsonrpc":"2.0","result":"rob1"}
40  *
41  */
42  std::string getName();
43 
44  /**
45  * 获取机器人的自由度(从硬件抽象层读取)
46  *
47  * @return 返回机器人的自由度
48  *
49  * @throws arcs::common_interface::AuboException
50  *
51  * @par Python函数原型
52  * getDof(self: pyaubo_sdk.RobotConfig) -> int
53  *
54  * @par Lua函数原型
55  * getDof() -> number
56  *
57  * @par JSON-RPC请求示例
58  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDof","params":[],"id":1}
59  *
60  * @par JSON-RPC响应示例
61  * {"id":1,"jsonrpc":"2.0","result":6}
62  *
63  */
64  int getDof();
65 
66  /**
67  * 获取机器人的伺服控制周期(从硬件抽象层读取)
68  *
69  * @return 机器人的伺服控制周期
70  *
71  * @throws arcs::common_interface::AuboException
72  *
73  * @par Python函数原型
74  * getCycletime(self: pyaubo_sdk.RobotConfig) -> float
75  *
76  * @par Lua函数原型
77  * getCycletime() -> number
78  *
79  * @par JSON-RPC请求示例
80  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCycletime","params":[],"id":1}
81  *
82  * @par JSON-RPC响应示例
83  * {"id":1,"jsonrpc":"2.0","result":0.005}
84  *
85  */
86  double getCycletime();
87 
88  /**
89  * 预设缓速模式下的速度缩减比例
90  *
91  * @param level 缓速等级 1, 2
92  * @param fraction
93  *
94  * @return 成功返回0；失败返回错误码
95  * AUBO_BUSY
96  * AUBO_BAD_STATE
97  * AUBO_INVL_ARGUMENT
98  * -AUBO_BAD_STATE
99  *
100  * @throws arcs::common_interface::AuboException
101  *
102  * @par JSON-RPC请求示例
103  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setSlowDownFraction","params":[1,0.8],"id":1}
104  *
105  * @par JSON-RPC响应示例
106  * {"id":1,"jsonrpc":"2.0","result":0}
107  *
108  */
109  int setSlowDownFraction(int level, double fraction);
110 
111  /**
112  * 获取预设的缓速模式下的速度缩减比例
113  *
114  * @param level 缓速等级 1, 2
115  * @return 返回预设的缓速模式下的速度缩减比例
116  *
117  * @throws arcs::common_interface::AuboException
118  *
119  * @par JSON-RPC请求示例
120  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSlowDownFraction","params":[1],"id":1}
121  *
122  * @par JSON-RPC响应示例
123  * {"id":1,"jsonrpc":"2.0","result":0.5}
124  *
125  */
126  double getSlowDownFraction(int level);
127 
128  /**
129  * 获取默认的工具端加速度，单位m/s^2
130  *
131  * @return 默认的工具端加速度
132  *
133  * @throws arcs::common_interface::AuboException
134  *
135  * @par Python函数原型
136  * getDefaultToolAcc(self: pyaubo_sdk.RobotConfig) -> float
137  *
138  * @par Lua函数原型
139  * getDefaultToolAcc() -> number
140  *
141  * @par JSON-RPC请求示例
142  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultToolAcc","params":[],"id":1}
143  *
144  * @par JSON-RPC响应示例
145  * {"id":1,"jsonrpc":"2.0","result":0.0}
146  */
147  double getDefaultToolAcc();
148 
149  /**
150  * 获取默认的工具端速度，单位m/s
151  *
152  * @return 默认的工具端速度
153  *
154  * @throws arcs::common_interface::AuboException
155  *
156  * @par Python函数原型
157  * getDefaultToolSpeed(self: pyaubo_sdk.RobotConfig) -> float
158  *
159  * @par Lua函数原型
160  * getDefaultToolSpeed() -> number
161  *
162  * @par JSON-RPC请求示例
163  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultToolSpeed","params":[],"id":1}
164  *
165  * @par JSON-RPC响应示例
166  * {"id":1,"jsonrpc":"2.0","result":0.0}
167  *
168  */
169  double getDefaultToolSpeed();
170 
171  /**
172  * 获取默认的关节加速度，单位rad/s^2
173  *
174  * @return 默认的关节加速度
175  *
176  * @throws arcs::common_interface::AuboException
177  *
178  * @par Python函数原型
179  * getDefaultJointAcc(self: pyaubo_sdk.RobotConfig) -> float
180  *
181  * @par Lua函数原型
182  * getDefaultJointAcc() -> number
183  *
184  * @par JSON-RPC请求示例
185  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultJointAcc","params":[],"id":1}
186  *
187  * @par JSON-RPC响应示例
188  * {"id":1,"jsonrpc":"2.0","result":0.0}
189  *
190  */
191  double getDefaultJointAcc();
192 
193  /**
194  * 获取默认的关节速度，单位rad/s
195  *
196  * @return 默认的关节速度
197  *
198  * @throws arcs::common_interface::AuboException
199  *
200  * @par Python函数原型
201  * getDefaultJointSpeed(self: pyaubo_sdk.RobotConfig) -> float
202  *
203  * @par Lua函数原型
204  * getDefaultJointSpeed() -> number
205  *
206  * @par JSON-RPC请求示例
207  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultJointSpeed","params":[],"id":1}
208  *
209  * @par JSON-RPC响应示例
210  * {"id":1,"jsonrpc":"2.0","result":0.0}
211  *
212  */
213  double getDefaultJointSpeed();
214 
215  /**
216  * 获取机器人类型代码
217  *
218  * @return 机器人类型代码
219  *
220  * @throws arcs::common_interface::AuboException
221  *
222  * @par Python函数原型
223  * getRobotType(self: pyaubo_sdk.RobotConfig) -> str
224  *
225  * @par Lua函数原型
226  * getRobotType() -> string
227  *
228  * @par JSON-RPC请求示例
229  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotType","params":[],"id":1}
230  *
231  * @par JSON-RPC响应示例
232  * {"id":1,"jsonrpc":"2.0","result":"aubo_i5H"}
233  *
234  */
235  std::string getRobotType();
236 
237  /**
238  * 获取机器人子类型代码
239  *
240  * @return 机器人子类型代码
241  *
242  * @throws arcs::common_interface::AuboException
243  *
244  * @par Python函数原型
245  * getRobotSubType(self: pyaubo_sdk.RobotConfig) -> str
246  *
247  * @par Lua函数原型
248  * getRobotSubType() -> string
249  *
250  * @par JSON-RPC请求示例
251  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotSubType","params":[],"id":1}
252  *
253  * @par JSON-RPC响应示例
254  * {"id":1,"jsonrpc":"2.0","result":"B0"}
255  *
256  */
257  std::string getRobotSubType();
258 
259  /**
260  * 获取控制柜类型代码
261  *
262  * @return 控制柜类型代码
263  *
264  * @throws arcs::common_interface::AuboException
265  *
266  * @par Python函数原型
267  * getControlBoxType(self: pyaubo_sdk.RobotConfig) -> str
268  *
269  * @par Lua函数原型
270  * getControlBoxType() -> string
271  *
272  * @par JSON-RPC请求示例
273  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getControlBoxType","params":[],"id":1}
274  *
275  * @par JSON-RPC响应示例
276  * {"id":1,"jsonrpc":"2.0","result":"cb_ISStation"}
277  *
278  */
279  std::string getControlBoxType();
280 
281  /**
282  * 设置安装位姿(机器人的基坐标系相对于世界坐标系) world->base
283  *
284  * 一般在多机器人系统中使用，默认为 [0,0,0,0,0,0]
285  *
286  * @param pose 安装位姿
287  * @return 成功返回0; 失败返回错误码
288  * AUBO_BUSY
289  * AUBO_BAD_STATE
290  * -AUBO_INVL_ARGUMENT
291  * -AUBO_BAD_STATE
292  *
293  * @throws arcs::common_interface::AuboException
294  *
295  * @par Python函数原型
296  * setMountingPose(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
297  *
298  * @par Lua函数原型
299  * setMountingPose(pose: table) -> nil
300  *
301  * @par JSON-RPC请求示例
302  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setMountingPose","params":[[0.0,0.0,0.0,0.0,0.0,0.0]],"id":1}
303  *
304  * @par JSON-RPC响应示例
305  * {"id":1,"jsonrpc":"2.0","result":0}
306  *
307  */
308  int setMountingPose(const std::vector<double> &pose);
309 
310  /**
311  * 获取安装位姿(机器人的基坐标系相对于世界坐标系)
312  *
313  * @return 安装位姿
314  *
315  * @throws arcs::common_interface::AuboException
316  *
317  * @par Python函数原型
318  * getMountingPose(self: pyaubo_sdk.RobotConfig) -> List[float]
319  *
320  * @par Lua函数原型
321  * getMountingPose() -> table
322  *
323  * @par JSON-RPC请求示例
324  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getMountingPose","params":[],"id":1}
325  *
326  * @par JSON-RPC响应示例
327  * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
328  *
329  */
330  std::vector<double> getMountingPose();
331 
332  /**
333  * 设置碰撞灵敏度等级
334  * 数值越大越灵敏
335  *
336  * @param level 碰撞灵敏度等级
337  * 0: 关闭碰撞检测功能
338  * 1~9: 碰撞灵敏等级
339  * @return 成功返回0; 失败返回错误码
340  * AUBO_BUSY
341  * AUBO_BAD_STATE
342  * -AUBO_INVL_ARGUMENT
343  * -AUBO_BAD_STATE
344  *
345  * @throws arcs::common_interface::AuboException
346  *
347  * @par Python函数原型
348  * setCollisionLevel(self: pyaubo_sdk.RobotConfig, arg0: int) -> int
349  *
350  * @par Lua函数原型
351  * setCollisionLevel(level: number) -> nil
352  *
353  * @par JSON-RPC请求示例
354  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setCollisionLevel","params":[6],"id":1}
355  *
356  * @par JSON-RPC响应示例
357  * {"id":1,"jsonrpc":"2.0","result":0}
358  *
359  */
360  int setCollisionLevel(int level);
361 
362  /**
363  * 获取碰撞灵敏度等级
364  *
365  * @return 碰撞灵敏度等级
366  *
367  * @throws arcs::common_interface::AuboException
368  *
369  * @par Python函数原型
370  * getCollisionLevel(self: pyaubo_sdk.RobotConfig) -> int
371  *
372  * @par Lua函数原型
373  * getCollisionLevel() -> number
374  *
375  * @par JSON-RPC请求示例
376  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCollisionLevel","params":[],"id":1}
377  *
378  * @par JSON-RPC响应示例
379  * {"id":1,"jsonrpc":"2.0","result":6}
380  *
381  */
382  int getCollisionLevel();
383 
384  /**
385  * 设置碰撞停止类型
386  *
387  * @param type 类型 \n
388  * 0: 碰撞后浮动，即碰撞之后进入拖动示教模式 \n
389  * 1: 碰撞后静止 \n
390  * 2: 碰撞后抱闸
391  *
392  * @return 成功返回0; 失败返回错误码
393  * AUBO_BUSY
394  * AUBO_BAD_STATE
395  * -AUBO_INVL_ARGUMENT
396  * -AUBO_BAD_STATE
397  *
398  * @throws arcs::common_interface::AuboException
399  *
400  * @par Python函数原型
401  * setCollisionStopType(self: pyaubo_sdk.RobotConfig, arg0: int) -> int
402  *
403  * @par Lua函数原型
404  * setCollisionStopType(type: number) -> nil
405  *
406  * @par JSON-RPC请求示例
407  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setCollisionStopType","params":[1],"id":1}
408  *
409  * @par JSON-RPC响应示例
410  * {"id":1,"jsonrpc":"2.0","result":0}
411  *
412  */
413  int setCollisionStopType(int type);
414 
415  /**
416  * 获取碰撞停止类型
417  *
418  * @return 返回碰撞停止类型 \n
419  * 0: 碰撞后浮动，即碰撞之后进入拖动示教模式 \n
420  * 1: 碰撞后静止 \n
421  * 2: 碰撞后抱闸
422  *
423  * @throws arcs::common_interface::AuboException
424  *
425  * @par Python函数原型
426  * getCollisionStopType(self: pyaubo_sdk.RobotConfig) -> int
427  *
428  * @par Lua函数原型
429  * getCollisionStopType() -> number
430  *
431  * @par JSON-RPC请求示例
432  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCollisionStopType","params":[],"id":1}
433  *
434  * @par JSON-RPC响应示例
435  * {"id":1,"jsonrpc":"2.0","result":1}
436  *
437  */
438  int getCollisionStopType();
439 
440  /**
441  * 设置机器人的原点位置
442  *
443  * @param positions 关节角度
444  * @return 成功返回0；失败返回错误码
445  * AUBO_BUSY
446  * AUBO_BAD_STATE
447  * -AUBO_INVL_ARGUMENT
448  * -AUBO_BAD_STATE
449  *
450  * @throws arcs::common_interface::AuboException
451  *
452  * @par JSON-RPC请求示例
453  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setHomePosition","params":[[0.0,-0.2617993877991494,1.74532925199433,0.4363323129985824,1.570796326794897,0.0]],"id":1}
454  *
455  * @par JSON-RPC响应示例
456  * {"id":1,"jsonrpc":"2.0","result":0}
457  *
458  */
459  int setHomePosition(const std::vector<double> &positions);
460 
461  /**
462  * 获取机器人的原点位置
463  *
464  * @return
465  *
466  * @throws arcs::common_interface::AuboException
467  *
468  * @par JSON-RPC请求示例
469  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getHomePosition","params":[],"id":1}
470  *
471  * @par JSON-RPC响应示例
472  * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.2617993877991494,1.74532925199433,0.4363323129985824,1.570796326794897,0.0]}
473  *
474  */
475  std::vector<double> getHomePosition();
476 
477  /**
478  * 设置拖动阻尼
479  *
480  * @param damp 阻尼
481  *
482  * @return 成功返回0；失败返回错误码
483  * AUBO_BUSY
484  * AUBO_BAD_STATE
485  * -AUBO_INVL_ARGUMENT
486  * -AUBO_BAD_STATE
487  *
488  * @throws arcs::common_interface::AuboException
489  *
490  * @par Python函数原型
491  * setFreedriveDamp(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
492  *
493  * @par Lua函数原型
494  * setFreedriveDamp(damp: table) -> number
495  *
496  * @par JSON-RPC请求示例
497  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setFreedriveDamp","params":[[0.5,0.5,0.5,0.5,0.5,0.5]],"id":1}
498  *
499  * @par JSON-RPC响应示例
500  * {"id":1,"jsonrpc":"2.0","result":0}
501  *
502  */
503  int setFreedriveDamp(const std::vector<double> &damp);
504 
505  /**
506  * 获取拖动阻尼
507  *
508  * @return 拖动阻尼
509  *
510  * @throws arcs::common_interface::AuboException
511  *
512  * @par Python函数原型
513  * getFreedriveDamp(self: pyaubo_sdk.RobotConfig) -> List[float]
514  *
515  * @par Lua函数原型
516  * getFreedriveDamp() -> table
517  *
518  * @par JSON-RPC请求示例
519  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getFreedriveDamp","params":[],"id":1}
520  *
521  * @par JSON-RPC响应示例
522  * {"id":1,"jsonrpc":"2.0","result":[0.5,0.5,0.5,0.5,0.5,0.5]}
523  *
524  */
525  std::vector<double> getFreedriveDamp();
526 
527  /**
528  * 获取机器人DH参数
529  * alpha a d theta beta
530  *
531  * @param real 读取真实参数(理论值+补偿值)或者理论参数
532  * @return 返回机器人DH参数
533  *
534  * @throws arcs::common_interface::AuboException
535  *
536  * @par Python函数原型
537  * getKinematicsParam(self: pyaubo_sdk.RobotConfig, arg0: bool) -> Dict[str,
538  * List[float]]
539  *
540  * @par Lua函数原型
541  * getKinematicsParam(real: boolean) -> table
542  *
543  * @par JSON-RPC请求示例
544  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getKinematicsParam","params":[true],"id":1}
545  *
546  * @par JSON-RPC响应示例
547  * {"id":1,"jsonrpc":"2.0","result":{"a":[0.0,-0.0001255999959539622,0.4086348000024445,0.3757601999930339,-0.00018950000230688602,3.7000001611886546e-05],
548  * "alpha":[0.0,-1.5701173967707458,3.1440308735524347,3.14650750358636,-1.5703093767832055,1.5751177669179182],"beta":[0.0,0.0,0.0,0.0,0.0,0.0],
549  * "d":[0.122,0.12154769999941345,-4.769999941345304e-05,4.769999941345304e-05,0.10287890000385232,0.116],
550  * "theta":[3.141592653589793,-1.5707963267948966,0.0,-1.5707963267948966,0.0,0.0]}}
551  *
552  */
553  std::unordered_map<std::string, std::vector<double>> getKinematicsParam(
554  bool real);
555 
556  /**
557  * 获取指定温度下的DH参数补偿值:alpha a d theta beta
558  *
559  * @param ref_temperature 参考温度 ℃，默认20℃
560  * @return 返回DH参数补偿值
561  *
562  * @throws arcs::common_interface::AuboException
563  *
564  * @par Python函数原型
565  * getKinematicsCompensate(self: pyaubo_sdk.RobotConfig, arg0: float) ->
566  * Dict[str, List[float]]
567  *
568  * @par Lua函数原型
569  * getKinematicsCompensate(ref_temperature: number) -> table
570  *
571  * @par JSON-RPC请求示例
572  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getKinematicsCompensate","params":[20],"id":1}
573  *
574  * @par JSON-RPC响应示例
575  * {"id":1,"jsonrpc":"2.0","result":{"a":[0.0,-0.0001255999959539622,0.0006348000024445355,-0.0002398000069661066,-0.00018950000230688602,3.7000001611886546e-05],
576  * "alpha":[0.0,0.000678930024150759,0.002438219962641597,0.0049148499965667725,0.00048695001169107854,0.004321440123021603],
577  * "beta":[0.0,0.0,0.0,0.0,0.0,0.0],"d":[0.0,4.769999941345304e-05,-4.769999941345304e-05,4.769999941345304e-05,0.0003789000038523227,0.0],
578  * "theta":[0.0,0.0,0.0,0.0,0.0,0.0]}}
579  *
580  */
581  std::unordered_map<std::string, std::vector<double>>
582  getKinematicsCompensate(double ref_temperature);
583 
584  /**
585  * 设置标准 DH 补偿到机器人
586  *
587  * @param param
588  *
589  * @return 成功返回0；失败返回错误码
590  * AUBO_BUSY
591  * AUBO_BAD_STATE
592  * -AUBO_INVL_ARGUMENT
593  * -AUBO_BAD_STATE
594  *
595  * @throws arcs::common_interface::AuboException
596  *
597  */
598  int setKinematicsCompensate(
599  const std::unordered_map<std::string, std::vector<double>> &param);
600 
601  /**
602  * 设置需要保存到接口板底座的参数
603  *
604  * @param param 补偿数据
605  *
606  * @return 成功返回0；失败返回错误码
607  * AUBO_BUSY
608  * AUBO_BAD_STATE
609  * -AUBO_INVL_ARGUMENT
610  * -AUBO_BAD_STATE
611  *
612  * @throws arcs::common_interface::AuboException
613  *
614  * @par Python函数原型
615  * setPersistentParameters(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
616  *
617  * @par Lua函数原型
618  * setPersistentParameters(param: string) -> nil
619  *
620  */
621  int setPersistentParameters(const std::string &param);
622 
623  /**
624  * 设置硬件抽象层自定义参数
625  * 目的是为了做不同硬件之间的兼容
626  *
627  * @param param 自定义参数
628  *
629  * @return 成功返回0；失败返回错误码
630  * AUBO_BUSY
631  * AUBO_BAD_STATE
632  * -AUBO_INVL_ARGUMENT
633  * -AUBO_BAD_STATE
634  *
635  * @throws arcs::common_interface::AuboException
636  *
637  */
638  int setHardwareCustomParameters(const std::string &param);
639 
640  /**
641  * 获取硬件抽象层自定义参数
642  *
643  * @param
644  * @return 返回硬件抽象层自定义的参数
645  *
646  * @throws arcs::common_interface::AuboException
647  *
648  */
649  std::string getHardwareCustomParameters(const std::string &param);
650 
651  /**
652  * 设置机器人关节零位
653  *
654  * @return 成功返回0；失败返回错误码
655  * AUBO_BUSY
656  * AUBO_BAD_STATE
657  * -AUBO_BAD_STATE
658  *
659  * @throws arcs::common_interface::AuboException
660  *
661  * @par Python函数原型
662  * setRobotZero(self: pyaubo_sdk.RobotConfig) -> int
663  *
664  * @par Lua函数原型
665  * setRobotZero() -> nil
666  *
667  * @par JSON-RPC请求示例
668  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setRobotZero","params":[],"id":1}
669  *
670  * @par JSON-RPC响应示例
671  * {"id":1,"jsonrpc":"2.0","result":0}
672  *
673  */
674  int setRobotZero();
675 
676  /**
677  * 获取可用的末端力矩传感器的名字
678  *
679  * @return 返回可用的末端力矩传感器的名字
680  *
681  * @throws arcs::common_interface::AuboException
682  *
683  * @par Python函数原型
684  * getTcpForceSensorNames(self: pyaubo_sdk.RobotConfig) -> List[str]
685  *
686  * @par Lua函数原型
687  * getTcpForceSensorNames() -> table
688  *
689  * @par JSON-RPC请求示例
690  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceSensorNames","params":[],"id":1}
691  *
692  * @par JSON-RPC响应示例
693  * {"id":1,"jsonrpc":"2.0","result":[]}
694  *
695  */
696  std::vector<std::string> getTcpForceSensorNames();
697 
698  /**
699  * 设置末端力矩传感器
700  * 如果存在内置的末端力矩传感器，默认将使用内置的力矩传感器
701  *
702  * @param name 末端力矩传感器的名字
703  *
704  * @return 成功返回0；失败返回错误码
705  * AUBO_BUSY
706  * AUBO_BAD_STATE
707  * -AUBO_INVL_ARGUMENT
708  * -AUBO_BAD_STATE
709  *
710  * @throws arcs::common_interface::AuboException
711  *
712  * @par Python函数原型
713  * selectTcpForceSensor(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
714  *
715  * @par Lua函数原型
716  * selectTcpForceSensor(name: string) -> nil
717  *
718  */
719  int selectTcpForceSensor(const std::string &name);
720 
721  /**
722  * 设置传感器安装位姿
723  *
724  * @param sensor_pose 传感器安装位姿
725  *
726  * @return 成功返回0；失败返回错误码
727  * AUBO_BUSY
728  * AUBO_BAD_STATE
729  * -AUBO_INVL_ARGUMENT
730  * -AUBO_BAD_STATE
731  *
732  * @throws arcs::common_interface::AuboException
733  *
734  */
735  int setTcpForceSensorPose(const std::vector<double> &sensor_pose);
736 
737  /**
738  * 获取传感器安装位姿
739  *
740  * @return 传感器安装位姿
741  *
742  * @throws arcs::common_interface::AuboException
743  *
744  * @par JSON-RPC请求示例
745  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceSensorPose","params":[],"id":1}
746  *
747  * @par JSON-RPC响应示例
748  * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
749  *
750  */
751  std::vector<double> getTcpForceSensorPose();
752  /**
753  * 是否安装了末端力矩传感器
754  *
755  * @return 安装返回true; 没有安装返回false
756  *
757  * @throws arcs::common_interface::AuboException
758  *
759  * @par Python函数原型
760  * hasTcpForceSensor(self: pyaubo_sdk.RobotConfig) -> bool
761  *
762  * @par Lua函数原型
763  * hasTcpForceSensor() -> boolean
764  *
765  * @par JSON-RPC请求示例
766  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.hasTcpForceSensor","params":[],"id":1}
767  *
768  * @par JSON-RPC响应示例
769  * {"id":1,"jsonrpc":"2.0","result":true}
770  *
771  */
772  bool hasTcpForceSensor();
773 
774  /**
775  * 设置末端力矩偏移
776  *
777  * @param force_offset 末端力矩偏移
778  * @return 成功返回0; 失败返回错误码
779  *
780  * @throws arcs::common_interface::AuboException
781  *
782  * @par Python函数原型
783  * setTcpForceOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
784  *
785  * @par Lua函数原型
786  * setTcpForceOffset(force_offset: table) -> nil
787  *
788  */
789  int setTcpForceOffset(const std::vector<double> &force_offset);
790 
791  /**
792  * 获取末端力矩偏移
793  *
794  * @return 返回末端力矩偏移
795  *
796  * @throws arcs::common_interface::AuboException
797  *
798  * @par Python函数原型
799  * getTcpForceOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
800  *
801  * @par Lua函数原型
802  * getTcpForceOffset() -> table
803  *
804  * @par JSON-RPC请求示例
805  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceOffset","params":[],"id":1}
806  *
807  * @par JSON-RPC响应示例
808  * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
809  *
810  */
811  std::vector<double> getTcpForceOffset();
812 
813  /**
814  * 获取可用的底座力矩传感器的名字
815  *
816  * @return 返回可用的底座力矩传感器的名字
817  *
818  * @throws arcs::common_interface::AuboException
819  *
820  * @par Python函数原型
821  * getBaseForceSensorNames(self: pyaubo_sdk.RobotConfig) -> List[str]
822  *
823  * @par Lua函数原型
824  * getBaseForceSensorNames() -> table
825  *
826  * @par JSON-RPC请求示例
827  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getBaseForceSensorNames","params":[],"id":1}
828  *
829  * @par JSON-RPC响应示例
830  * {"id":1,"jsonrpc":"2.0","result":[]}
831  *
832  */
833  std::vector<std::string> getBaseForceSensorNames();
834 
835  /**
836  * 设置底座力矩传感器
837  * 如果存在内置的底座力矩传感器，默认将使用内置的力矩传感器
838  *
839  * @param name 底座力矩传感器的名字
840  *
841  * @return 成功返回0；失败返回错误码
842  * AUBO_BUSY
843  * AUBO_BAD_STATE
844  * -AUBO_INVL_ARGUMENT
845  * -AUBO_BAD_STATE
846  *
847  * @throws arcs::common_interface::AuboException
848  *
849  * @par Python函数原型
850  * selectBaseForceSensor(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
851  *
852  * @par Lua函数原型
853  * selectBaseForceSensor(name: string) -> nil
854  *
855  */
856  int selectBaseForceSensor(const std::string &name);
857 
858  /**
859  * 是否安装了底座力矩传感器
860  *
861  * @return 安装返回true;没有安装返回false
862  *
863  * @throws arcs::common_interface::AuboException
864  *
865  * @par Python函数原型
866  * hasBaseForceSensor(self: pyaubo_sdk.RobotConfig) -> bool
867  *
868  * @par Lua函数原型
869  * hasBaseForceSensor() -> boolean
870  *
871  * @par JSON-RPC请求示例
872  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.hasBaseForceSensor","params":[],"id":1}
873  *
874  * @par JSON-RPC响应示例
875  * {"id":1,"jsonrpc":"2.0","result":false}
876  *
877  */
878  bool hasBaseForceSensor();
879 
880  /**
881  * 设置底座力矩偏移
882  *
883  * @param force_offset 底座力矩偏移
884  *
885  * @return 成功返回0；失败返回错误码
886  * AUBO_BUSY
887  * AUBO_BAD_STATE
888  * -AUBO_INVL_ARGUMENT
889  * -AUBO_BAD_STATE
890  *
891  * @throws arcs::common_interface::AuboException
892  *
893  * @par Python函数原型
894  * setBaseForceOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) ->
895  * int
896  *
897  * @par Lua函数原型
898  * setBaseForceOffset(force_offset: table) -> nil
899  *
900  */
901  int setBaseForceOffset(const std::vector<double> &force_offset);
902 
903  /**
904  * 获取底座力矩偏移
905  *
906  * @return 返回底座力矩偏移
907  *
908  * @throws arcs::common_interface::AuboException
909  *
910  * @par Python函数原型
911  * getBaseForceOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
912  *
913  * @par Lua函数原型
914  * getBaseForceOffset() -> table
915  *
916  * @par JSON-RPC请求示例
917  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getBaseForceOffset","params":[],"id":1}
918  *
919  * @par JSON-RPC响应示例
920  * {"id":1,"jsonrpc":"2.0","result":[]}
921  *
922  */
923  std::vector<double> getBaseForceOffset();
924 
925  /**
926  * 获取安全参数校验码 CRC32
927  *
928  * @return 返回安全参数校验码
929  *
930  * @throws arcs::common_interface::AuboException
931  *
932  * @par Python函数原型
933  * getSafetyParametersCheckSum(self: pyaubo_sdk.RobotConfig) -> int
934  *
935  * @par Lua函数原型
936  * getSafetyParametersCheckSum() -> number
937  *
938  * @par JSON-RPC请求示例
939  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafetyParametersCheckSum","params":[],"id":1}
940  *
941  * @par JSON-RPC响应示例
942  * {"id":1,"jsonrpc":"2.0","result":2033397241}
943  *
944  */
945  uint32_t getSafetyParametersCheckSum();
946 
947  /**
948  * 发起确认安全配置参数请求:
949  * 将安全配置参数写入到安全接口板flash或文件
950  *
951  * @param parameters 安全配置参数
952  *
953  * @return 成功返回0；失败返回错误码
954  * AUBO_BUSY
955  * AUBO_BAD_STATE
956  * -AUBO_INVL_ARGUMENT
957  * -AUBO_BAD_STATE
958  *
959  * @throws arcs::common_interface::AuboException
960  *
961  * @par Python函数原型
962  * confirmSafetyParameters(self: pyaubo_sdk.RobotConfig, arg0:
963  * arcs::common_interface::RobotSafetyParameterRange) -> int
964  *
965  * @par Lua函数原型
966  *
967  *
968  */
969  int confirmSafetyParameters(const RobotSafetyParameterRange &parameters);
970 
971  /**
972  * 计算安全参数的 CRC32 校验值
973  *
974  * @return crc32
975  *
976  * @throws arcs::common_interface::AuboException
977  *
978  */
979  uint32_t calcSafetyParametersCheckSum(
980  const RobotSafetyParameterRange &parameters);
981 
982  /**
983  * 获取关节最大位置（物理极限）
984  *
985  * @return 返回关节最大位置
986  *
987  * @throws arcs::common_interface::AuboException
988  *
989  * @par Python函数原型
990  * getJointMaxPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
991  *
992  * @par Lua函数原型
993  * getJointMaxPositions() -> table
994  *
995  * @par JSON-RPC请求示例
996  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxPositions","params":[],"id":1}
997  *
998  * @par JSON-RPC响应示例
999  * {"id":1,"jsonrpc":"2.0","result":[6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586]}
1000  *
1001  */
1002  std::vector<double> getJointMaxPositions();
1003 
1004  /**
1005  * 获取关节最小位置（物理极限）
1006  *
1007  * @return 返回关节最小位置
1008  *
1009  * @throws arcs::common_interface::AuboException
1010  *
1011  * @par Python函数原型
1012  * getJointMinPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
1013  *
1014  * @par Lua函数原型
1015  * getJointMinPositions() -> table
1016  *
1017  * @par JSON-RPC请求示例
1018  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMinPositions","params":[],"id":1}
1019  *
1020  * @par JSON-RPC响应示例
1021  * {"id":1,"jsonrpc":"2.0","result":[-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586]}
1022  *
1023  */
1024  std::vector<double> getJointMinPositions();
1025 
1026  /**
1027  * 获取关节最大速度（物理极限）
1028  *
1029  * @return 返回关节最大速度
1030  *
1031  * @throws arcs::common_interface::AuboException
1032  *
1033  * @par Python函数原型
1034  * getJointMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
1035  *
1036  * @par Lua函数原型
1037  * getJointMaxSpeeds() -> table
1038  *
1039  * @par JSON-RPC请求示例
1040  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxSpeeds","params":[],"id":1}
1041  *
1042  * @par JSON-RPC响应示例
1043  * {"id":1,"jsonrpc":"2.0","result":[3.892084231947355,3.892084231947355,3.892084231947355,3.1066860685499065,3.1066860685499065,3.1066860685499065]}
1044  *
1045  */
1046  std::vector<double> getJointMaxSpeeds();
1047 
1048  /**
1049  * 获取关节最大加速度（物理极限）
1050  *
1051  * @return 返回关节最大加速度
1052  *
1053  * @throws arcs::common_interface::AuboException
1054  *
1055  * @par Python函数原型
1056  * getJointMaxAccelerations(self: pyaubo_sdk.RobotConfig) -> List[float]
1057  *
1058  * @par Lua函数原型
1059  * getJointMaxAccelerations() -> table
1060  *
1061  * @par JSON-RPC请求示例
1062  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxAccelerations","params":[],"id":1}
1063  *
1064  * @par JSON-RPC响应示例
1065  * {"id":1,"jsonrpc":"2.0","result":[31.104877758314785,31.104877758314785,31.104877758314785,20.73625684294463,20.73625684294463,20.73625684294463]}
1066  *
1067  */
1068  std::vector<double> getJointMaxAccelerations();
1069 
1070  /**
1071  * 获取TCP最大速度（物理极限）
1072  *
1073  * @return 返回TCP最大速度
1074  *
1075  * @throws arcs::common_interface::AuboException
1076  *
1077  * @par Python函数原型
1078  * getTcpMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
1079  *
1080  * @par Lua函数原型
1081  * getTcpMaxSpeeds() -> table
1082  *
1083  * @par JSON-RPC请求示例
1084  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpMaxSpeeds","params":[],"id":1}
1085  *
1086  * @par JSON-RPC响应示例
1087  * {"id":1,"jsonrpc":"2.0","result":[2.0,5.0]}
1088  *
1089  */
1090  std::vector<double> getTcpMaxSpeeds();
1091 
1092  /**
1093  * 获取TCP最大加速度（物理极限）
1094  *
1095  * @return 返回TCP最大加速度
1096  *
1097  * @throws arcs::common_interface::AuboException
1098  *
1099  * @par Python函数原型
1100  * getTcpMaxAccelerations(self: pyaubo_sdk.RobotConfig) -> List[float]
1101  *
1102  * @par Lua函数原型
1103  * getTcpMaxAccelerations() -> table
1104  *
1105  * @par JSON-RPC请求示例
1106  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpMaxAccelerations","params":[],"id":1}
1107  *
1108  * @par JSON-RPC响应示例
1109  * {"id":1,"jsonrpc":"2.0","result":[10.0,10.0]}
1110  *
1111  */
1112  std::vector<double> getTcpMaxAccelerations();
1113 
1114  /**
1115  * 设置机器人安装姿态
1116  *
1117  * @param gravity 安装姿态
1118  *
1119  * @return 成功返回0；失败返回错误码
1120  * AUBO_BUSY
1121  * AUBO_BAD_STATE
1122  * -AUBO_INVL_ARGUMENT
1123  * -AUBO_BAD_STATE
1124  *
1125  * @throws arcs::common_interface::AuboException
1126  *
1127  * @par Python函数原型
1128  * setGravity(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
1129  *
1130  * @par Lua函数原型
1131  * setGravity(gravity: table) -> nil
1132  *
1133  * @par JSON-RPC请求示例
1134  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setGravity","params":[[0.0,0.0,-9.87654321]],"id":1}
1135  *
1136  * @par JSON-RPC响应示例
1137  * {"id":1,"jsonrpc":"2.0","result":0}
1138  *
1139  */
1140  int setGravity(const std::vector<double> &gravity);
1141 
1142  /**
1143  * 获取机器人的安装姿态
1144  *
1145  * 如果机器人底座安装了姿态传感器，则从传感器读取数据，否则按照用户设置
1146  *
1147  * @return 返回安装姿态
1148  *
1149  * @throws arcs::common_interface::AuboException
1150  *
1151  * @par Python函数原型
1152  * getGravity(self: pyaubo_sdk.RobotConfig) -> List[float]
1153  *
1154  * @par Lua函数原型
1155  * getGravity() -> table
1156  *
1157  * @par JSON-RPC请求示例
1158  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getGravity","params":[],"id":1}
1159  *
1160  * @par JSON-RPC响应示例
1161  * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,-9.87654321]}
1162  *
1163  */
1164  std::vector<double> getGravity();
1165 
1166  /**
1167  * 设置当前的TCP偏移
1168  *
1169  * TCP偏移表示形式为(x,y,z,rx,ry,rz)。
1170  * 其中x、y、z是工具中心点（TCP）在基坐标系下相对于法兰盘中心的位置偏移，单位是m。
1171  * rx、ry、rz是工具中心点（TCP）在基坐标系下相对于法兰盘中心的的姿态偏移，是ZYX欧拉角，单位是rad。
1172  *
1173  * @param offset 当前的TCP偏移,形式为(x,y,z,rx,ry,rz)
1174  *
1175  * @return 成功返回0；失败返回错误码
1176  * AUBO_BUSY
1177  * AUBO_BAD_STATE
1178  * -AUBO_INVL_ARGUMENT
1179  * -AUBO_BAD_STATE
1180  *
1181  * @throws arcs::common_interface::AuboException
1182  *
1183  * @par Python函数原型
1184  * setTcpOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
1185  *
1186  * @par Lua函数原型
1187  * setTcpOffset(offset: table) -> nil
1188  *
1189  * @par JSON-RPC请求示例
1190  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setTcpOffset","params":[[0.0,0.0,0.0,0.0,0.0,0.0]],"id":1}
1191  *
1192  * @par JSON-RPC响应示例
1193  * {"id":1,"jsonrpc":"2.0","result":0}
1194  *
1195  */
1196  int setTcpOffset(const std::vector<double> &offset);
1197 
1198  /**
1199  * 获取当前的TCP偏移
1200  *
1201  * TCP偏移表示形式为(x,y,z,rx,ry,rz)。
1202  * 其中x、y、z是工具中心点（TCP）在基坐标系下相对于法兰盘中心的位置偏移，单位是m。
1203  * rx、ry、rz是工具中心点（TCP）在基坐标系下相对于法兰盘中心的的姿态偏移，是ZYX欧拉角，单位是rad。
1204  *
1205  * @return 当前的TCP偏移,形式为(x,y,z,rx,ry,rz)
1206  *
1207  * @throws arcs::common_interface::AuboException
1208  *
1209  * @par Python函数原型
1210  * getTcpOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
1211  *
1212  * @par Lua函数原型
1213  * getTcpOffset() -> table
1214  *
1215  * @par JSON-RPC请求示例
1216  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpOffset","params":[],"id":1}
1217  *
1218  * @par JSON-RPC响应示例
1219  * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1220  *
1221  */
1222  std::vector<double> getTcpOffset();
1223 
1224  /**
1225  * 设置工具端质量、质心及惯量
1226  *
1227  * @param m 工具端质量
1228  * @param com 质心
1229  * @param inertial 惯量
1230  *
1231  * @return 成功返回0；失败返回错误码
1232  * AUBO_BUSY
1233  * AUBO_BAD_STATE
1234  * -AUBO_INVL_ARGUMENT
1235  * -AUBO_BAD_STATE
1236  *
1237  * @throws arcs::common_interface::AuboException
1238  *
1239  * @par Python函数原型
1240  * setToolInertial(self: pyaubo_sdk.RobotConfig, arg0: float, arg1:
1241  * List[float], arg2: List[float]) -> int
1242  *
1243  * @par Lua函数原型
1244  * setToolInertial(m: number, com: table, inertial: table) -> nil
1245  *
1246  */
1247  int setToolInertial(double m, const std::vector<double> &com,
1248  const std::vector<double> &inertial);
1249 
1250  /**
1251  * 设置有效负载
1252  *
1253  * @param m 质量, 单位: kg
1254  * @param cog 重心, 单位: m, 形式为(CoGx, CoGy, CoGz)
1255  * @param aom 力矩轴的方向, 单位: rad, 形式为(rx, ry, rz)
1256  * @param inertia 惯量, 单位: kg*m^2, 形式为(Ixx, Ixy, Ixz, Iyx, Iyy, Iyz,
1257  * Izx, Izy, Izz)
1258  *
1259  * @return 成功返回0；失败返回错误码
1260  * AUBO_BUSY
1261  * AUBO_BAD_STATE
1262  * -AUBO_INVL_ARGUMENT
1263  * -AUBO_BAD_STATE
1264  *
1265  * @throws arcs::common_interface::AuboException
1266  *
1267  * @par Python函数原型
1268  * setPayload(self: pyaubo_sdk.RobotConfig, arg0: float, arg1: List[float],
1269  * arg2: List[float], arg3: List[float]) -> int
1270  *
1271  * @par Lua函数原型
1272  * setPayload(m: number, cog: table, aom: table, inertia: table) -> nil
1273  *
1274  * @par Lua示例
1275  * setPayload(3, {0,0,0}, {0,0,0}, {0,0,0,0,0,0,0,0,0})
1276  *
1277  * @par JSON-RPC请求示例
1278  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setPayload","params":[3,[0,0,0],[0,0,0],[0,0,0,0,0,0,0,0,0]],"id":1}
1279  *
1280  * @par JSON-RPC响应示例
1281  * {"id":1,"jsonrpc":"2.0","result":0}
1282  *
1283  */
1284  int setPayload(double m, const std::vector<double> &cog,
1285  const std::vector<double> &aom,
1286  const std::vector<double> &inertia);
1287 
1288  /**
1289  * 获取有效负载
1290  *
1291  * @return 有效负载.
1292  * 第一个元素表示质量, 单位: kg;
1293  * 第二个元素表示重心, 单位: m, 形式为(CoGx, CoGy, CoGz);
1294  * 第三个元素表示力矩轴的方向, 单位: rad, 形式为(rx, ry, rz);
1295  * 第四个元素表示惯量, 单位: kg*m^2, 形式为(Ixx, Ixy, Ixz, Iyx, Iyy, Iyz,
1296  * Izx, Izy, Izz)
1297  *
1298  * @throws arcs::common_interface::AuboException
1299  *
1300  * @par Python函数原型
1301  * getPayload(self: pyaubo_sdk.RobotConfig) -> Tuple[float, List[float],
1302  * List[float], List[float]]
1303  *
1304  * @par Lua函数原型
1305  * getPayload() -> number, table, table, table
1306  *
1307  * @par Lua示例
1308  * m, cog, aom, inertia = getPayload()
1309  *
1310  * @par JSON-RPC请求示例
1311  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getPayload","params":[],"id":1}
1312  *
1313  * @par JSON-RPC响应示例
1314  * {"id":1,"jsonrpc":"2.0","result":[3.0,[0.0,0.0,0.0],[0.0,0.0,0.0],[0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]]}
1315  *
1316  */
1317  Payload getPayload();
1318 
1319  /**
1320  * 末端位姿是否在安全范围之内
1321  *
1322  * @param pose 末端位姿
1323  * @return 在安全范围内返回true; 反之返回false
1324  *
1325  * @throws arcs::common_interface::AuboException
1326  *
1327  * @par Python函数原型
1328  * toolSpaceInRange(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> bool
1329  *
1330  * @par Lua函数原型
1331  * toolSpaceInRange(pose: table) -> boolean
1332  *
1333  * @par JSON-RPC请求示例
1334  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.toolSpaceInRange","params":[[0.58712,
1335  * -0.15775, 0.48703, 2.76, 0.344, 1.432]],"id":1}
1336  *
1337  * @par JSON-RPC响应示例
1338  * {"id":1,"jsonrpc":"2.0","result":true}
1339  *
1340  */
1341  bool toolSpaceInRange(const std::vector<double> &pose);
1342 
1343  /**
1344  * 发起固件升级请求，控制器软件将进入固件升级模式
1345  *
1346  * @param fw 固件升级路径。该路径的格式为: 固件安装包路径\#升级节点列表。
1347  * 其中固件安装包路径和升级节点列表以井号(#)分隔，升级节点以逗号(,)分隔。
1348  * 如果节点名称后带有!，则表示强制(不带版本校验)升级该节点；
1349  * 反之，则表示带校验版本地升级节点，
1350  * 即在升级该节点前，会先判断当前版本和目标版本是否相同，如果相同就不升级该节点。\n
1351  * 可以根据实际需求灵活设置需要升级的节点。\n
1352  * 例如，
1353  * /tmp/firmware_update-1.0.42-rc.5+2347b0d.firm\#master_mcu!,slace_mcu!,
1354  * base!,tool!,joint1!,joint2!,joint3!,joint4!,joint5!,joint6!
1355  * 表示强制升级接口板主板、接口板从板、基座、工具和6个关节（joint1至joint6）。\n
1356  * all表示所有的节点，例如
1357  * /tmp/firm_XXX.firm\#all 表示带校验版本地升级全部节点，
1358  * /tmp/firm_XXX.firm\#all！表示强制升级全部节点
1359  *
1360  * @return 指令下发成功返回0; 失败返回错误码。 \n
1361  * -AUBO_BAD_STATE: 运行时(RuntimeMachine)的当前状态不是Stopped,
1362  * 固件升级请求被拒绝。AUBO_BAD_STATE的值是1。 \n
1363  * -AUBO_TIMEOUT: 超时。AUBO_TIMEOUT的值是4。 \n
1364  *
1365  * @throws arcs::common_interface::AuboException
1366  *
1367  * @par Python函数原型
1368  * firmwareUpdate(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
1369  *
1370  * @par Lua函数原型
1371  * firmwareUpdate(fw: string) -> nil
1372  *
1373  * @par JSON-RPC请求示例
1374  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.firmwareUpdate","params":["/tmp/firmware_update-1.0.42-rc.12+3e33eac.firm#master_mcu"],"id":1}
1375  *
1376  * @par JSON-RPC响应示例
1377  * {"id":1,"jsonrpc":"2.0","result":0}
1378  *
1379  */
1380  int firmwareUpdate(const std::string &fw);
1381 
1382  /**
1383  * 获取当前的固件升级的进程
1384  *
1385  * @return 当前的固件升级进程。 \n
1386  * 第一个元素表示步骤名称。如果是failed，则表示固件升级失败 \n
1387  * 第二个元素表示升级的进度(0~1)，完成之后，返回("", 1)
1388  *
1389  * @throws arcs::common_interface::AuboException
1390  *
1391  * @par Python函数原型
1392  * getFirmwareUpdateProcess(self: pyaubo_sdk.RobotConfig) -> Tuple[str,
1393  * float]
1394  *
1395  * @par Lua函数原型
1396  * getFirmwareUpdateProcess() -> table
1397  *
1398  * @par JSON-RPC请求示例
1399  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getFirmwareUpdateProcess","params":[],"id":1}
1400  *
1401  * @par JSON-RPC响应示例
1402  * {"id":1,"jsonrpc":"2.0","result":[" ",0.0]}
1403  *
1404  */
1405  std::tuple<std::string, double> getFirmwareUpdateProcess();
1406 
1407  /**
1408  * 获取关节最大位置（当前正在使用的限制值）
1409  *
1410  * @return 返回关节最大位置（当前正在使用的限制值）
1411  *
1412  * @throws arcs::common_interface::AuboException
1413  *
1414  * @par Python函数原型
1415  * getLimitJointMaxPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
1416  *
1417  * @par Lua函数原型
1418  * getLimitJointMaxPositions() -> table
1419  *
1420  * @par JSON-RPC请求示例
1421  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxPositions","params":[],"id":1}
1422  *
1423  * @par JSON-RPC响应示例
1424  * {"id":1,"jsonrpc":"2.0","result":[6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465]}
1425  *
1426  */
1427  std::vector<double> getLimitJointMaxPositions();
1428 
1429  /**
1430  * 获取关节最小位置（当前正在使用的限制值）
1431  *
1432  * @return 返回关节最小位置（当前正在使用的限制值）
1433  *
1434  * @throws arcs::common_interface::AuboException
1435  *
1436  * @par Python函数原型
1437  * getLimitJointMinPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
1438  *
1439  * @par Lua函数原型
1440  * getLimitJointMinPositions() -> table
1441  *
1442  * @par JSON-RPC请求示例
1443  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMinPositions","params":[],"id":1}
1444  *
1445  * @par JSON-RPC响应示例
1446  * {"id":1,"jsonrpc":"2.0","result":[-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465]}
1447  *
1448  */
1449  std::vector<double> getLimitJointMinPositions();
1450 
1451  /**
1452  * 获取关节最大速度（当前正在使用的限制值）
1453  *
1454  * @return 返回关节最大速度（当前正在使用的限制值）
1455  *
1456  * @throws arcs::common_interface::AuboException
1457  *
1458  * @par Python函数原型
1459  * getLimitJointMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
1460  *
1461  * @par Lua函数原型
1462  * getLimitJointMaxSpeeds() -> table
1463  *
1464  * @par JSON-RPC请求示例
1465  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxSpeeds","params":[],"id":1}
1466  *
1467  * @par JSON-RPC响应示例
1468  * {"id":1,"jsonrpc":"2.0","result":[3.8920841217041016,3.8920841217041016,3.8920841217041016,3.1066861152648926,3.1066861152648926,3.1066861152648926]}
1469  *
1470  */
1471  std::vector<double> getLimitJointMaxSpeeds();
1472 
1473  /**
1474  * 获取关节最大加速度（当前正在使用的限制值）
1475  *
1476  * @return 返回关节最大加速度（当前正在使用的限制值）
1477  *
1478  * @throws arcs::common_interface::AuboException
1479  *
1480  * @par Python函数原型
1481  * getLimitJointMaxAccelerations(self: pyaubo_sdk.RobotConfig) ->
1482  * List[float]
1483  *
1484  * @par Lua函数原型
1485  * getLimitJointMaxAccelerations() -> table
1486  *
1487  * @par JSON-RPC请求示例
1488  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxAccelerations","params":[],"id":1}
1489  *
1490  * @par JSON-RPC响应示例
1491  * {"id":1,"jsonrpc":"2.0","result":[31.104877758314785,31.104877758314785,31.104877758314785,20.73625684294463,20.73625684294463,20.73625684294463]}
1492  *
1493  */
1494  std::vector<double> getLimitJointMaxAccelerations();
1495 
1496  /**
1497  * 获取TCP最大速度（当前正在使用的限制值）
1498  *
1499  * @return 返回TCP最大速度（当前正在使用的限制值）
1500  *
1501  * @throws arcs::common_interface::AuboException
1502  *
1503  * @par Python函数原型
1504  * getLimitTcpMaxSpeed(self: pyaubo_sdk.RobotConfig) -> List[float]
1505  *
1506  * @par Lua函数原型
1507  * getLimitTcpMaxSpeed() -> table
1508  *
1509  * @par JSON-RPC请求示例
1510  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitTcpMaxSpeed","params":[],"id":1}
1511  *
1512  * @par JSON-RPC响应示例
1513  * {"id":1,"jsonrpc":"2.0","result":2.0}
1514  *
1515  */
1516  double getLimitTcpMaxSpeed();
1517 
1518  /**
1519  * 获取当前安全停止的类型
1520  *
1521  * @return 返回当前安全停止的类型
1522  *
1523  * @par JSON-RPC请求示例
1524  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafeguardStopType","params":[],"id":1}
1525  *
1526  * @par JSON-RPC响应示例
1527  * {"id":1,"jsonrpc":"2.0","result":"None"}
1528  *
1529  */
1530  SafeguedStopType getSafeguardStopType();
1531 
1532  /**
1533  * 按位获取完整的安全停止触发源
1534  *
1535  * @return 返回所有安全停止触发源
1536  *
1537  * 安全停止的原因:
1538  * 手动模式下可配置安全IO触发的安全停止 - 1<<0
1539  * 自动模式下可配置安全IO触发的安全停止 - 1<<1
1540  * 控制柜SI输入触发的安全停止 - 1<<2
1541  * 示教器三态开关触发的安全停止 - 1<<3
1542  * 自动切手动触发的安全停止 - 1<<4
1543  *
1544  * @par JSON-RPC请求示例
1545  * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafeguardStopSource","params":[],"id":1}
1546  *
1547  * @par JSON-RPC响应示例
1548  * {"id":1,"jsonrpc":"2.0","result":0}
1549  *
1550  */
1551  int getSafeguardStopSource();
1552 
1553 protected:
1554  void *d_;
1555 };
1556 using RobotConfigPtr = std::shared_ptr<RobotConfig>;
1557 
1558 // clang-format off
1559 #define RobotConfig_DECLARES \
1560  _FUNC(RobotConfig, 0, getDof) \
1561  _FUNC(RobotConfig, 0, getName) \
1562  _FUNC(RobotConfig, 0, getCycletime) \
1563  _FUNC(RobotConfig, 2, setSlowDownFraction, level, fraction) \
1564  _FUNC(RobotConfig, 1, getSlowDownFraction, level) \
1565  _FUNC(RobotConfig, 0, getRobotType) \
1566  _FUNC(RobotConfig, 0, getRobotSubType) \
1567  _FUNC(RobotConfig, 0, getControlBoxType) \
1568  _FUNC(RobotConfig, 0, getDefaultToolAcc) \
1569  _FUNC(RobotConfig, 0, getDefaultToolSpeed) \
1570  _FUNC(RobotConfig, 0, getDefaultJointAcc) \
1571  _FUNC(RobotConfig, 0, getDefaultJointSpeed) \
1572  _INST(RobotConfig, 1, setMountingPose, pose) \
1573  _FUNC(RobotConfig, 0, getMountingPose) \
1574  _INST(RobotConfig, 1, setCollisionLevel, level); \
1575  _FUNC(RobotConfig, 0, getCollisionLevel); \
1576  _INST(RobotConfig, 1, setCollisionStopType, type); \
1577  _FUNC(RobotConfig, 0, getCollisionStopType); \
1578  _FUNC(RobotConfig, 1, setHomePosition, positions); \
1579  _FUNC(RobotConfig, 0, getHomePosition); \
1580  _INST(RobotConfig, 1, setFreedriveDamp, damp); \
1581  _FUNC(RobotConfig, 0, getFreedriveDamp); \
1582  _FUNC(RobotConfig, 0, getTcpForceSensorNames) \
1583  _INST(RobotConfig, 1, selectTcpForceSensor, name) \
1584  _FUNC(RobotConfig, 0, hasTcpForceSensor) \
1585  _INST(RobotConfig, 1, setTcpForceOffset, force_offset) \
1586  _FUNC(RobotConfig, 0, getTcpForceOffset) \
1587  _FUNC(RobotConfig, 0, getBaseForceSensorNames) \
1588  _INST(RobotConfig, 1, selectBaseForceSensor, name) \
1589  _FUNC(RobotConfig, 0, hasBaseForceSensor) \
1590  _INST(RobotConfig, 1, setBaseForceOffset, force_offset) \
1591  _FUNC(RobotConfig, 0, getBaseForceOffset) \
1592  _INST(RobotConfig, 1, setPersistentParameters, param) \
1593  _INST(RobotConfig, 1, setKinematicsCompensate, param) \
1594  _INST(RobotConfig, 1, setHardwareCustomParameters, param) \
1595  _FUNC(RobotConfig, 1, getHardwareCustomParameters, param) \
1596  _INST(RobotConfig, 0, setRobotZero) \
1597  _FUNC(RobotConfig, 1, getKinematicsParam, real) \
1598  _FUNC(RobotConfig, 1, getKinematicsCompensate, ref_temperature) \
1599  _FUNC(RobotConfig, 0, getSafetyParametersCheckSum) \
1600  _FUNC(RobotConfig, 1, confirmSafetyParameters, parameters) \
1601  _FUNC(RobotConfig, 1, calcSafetyParametersCheckSum, parameters) \
1602  _FUNC(RobotConfig, 0, getJointMaxPositions) \
1603  _FUNC(RobotConfig, 0, getJointMinPositions) \
1604  _FUNC(RobotConfig, 0, getJointMaxSpeeds) \
1605  _FUNC(RobotConfig, 0, getJointMaxAccelerations) \
1606  _FUNC(RobotConfig, 0, getTcpMaxSpeeds) \
1607  _FUNC(RobotConfig, 0, getTcpMaxAccelerations) \
1608  _FUNC(RobotConfig, 1, toolSpaceInRange, pose) \
1609  _INST(RobotConfig, 4, setPayload, m, cog, aom, inertia) \
1610  _FUNC(RobotConfig, 0, getPayload) \
1611  _FUNC(RobotConfig, 0, getTcpOffset) \
1612  _FUNC(RobotConfig, 0, getGravity) \
1613  _INST(RobotConfig, 1, setGravity, gravity) \
1614  _INST(RobotConfig, 1, setTcpOffset, offset) \
1615  _INST(RobotConfig, 3, setToolInertial, m, com, inertial) \
1616  _FUNC(RobotConfig, 1, firmwareUpdate, fw) \
1617  _FUNC(RobotConfig, 0, getFirmwareUpdateProcess) \
1618  _FUNC(RobotConfig, 1, setTcpForceSensorPose, sensor_pose) \
1619  _FUNC(RobotConfig, 0, getTcpForceSensorPose) \
1620  _FUNC(RobotConfig, 0, getLimitJointMaxPositions) \
1621  _FUNC(RobotConfig, 0, getLimitJointMinPositions) \
1622  _FUNC(RobotConfig, 0, getLimitJointMaxSpeeds) \
1623  _FUNC(RobotConfig, 0, getLimitJointMaxAccelerations) \
1624  _FUNC(RobotConfig, 0, getLimitTcpMaxSpeed) \
1625  _FUNC(RobotConfig, 0, getSafeguardStopType) \
1626  _FUNC(RobotConfig, 0, getSafeguardStopSource)
1627 
1628 // clang-format on
1629 } // namespace common_interface
1630 } // namespace arcs
1631 #endif // AUBO_SDK_ROBOT_CONFIG_H
type_def.h
数据类型的定义
arcs::common_interface::Payload
std::tuple< double, std::vector< double >, std::vector< double >, std::vector< double >> Payload
Definition: type_def.h:666
arcs::common_interface::SafeguedStopType
SafeguedStopType
Definition: type_def.h:532
arcs::common_interface::RobotSafetyParameterRange
Definition: type_def.h:35
arcs::common_interface::RobotConfig
Definition: robot_config.h:16
arcs::common_interface::RobotConfigPtr
std::shared_ptr< RobotConfig > RobotConfigPtr
Definition: robot_config.h:1556
arcs
Definition: aubo_api.h:17
arcs::common_interface::RobotConfig::d_
void * d_
Definition: robot_config.h:1554
制作者   doxygen 1.8.11