AUBO SDK  0.26.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
13namespace arcs {
14namespace common_interface {
15
16class ARCS_ABI_EXPORT RobotConfig
17{
18public:
20 virtual ~RobotConfig();
21
22 /**
23 * \chinese
24 * 获取机器人的名字
25 *
26 * @return 返回机器人的名字
27 *
28 * @throws arcs::common_interface::AuboException
29 *
30 * @par Python函数原型
31 * getName(self: pyaubo_sdk.RobotConfig) -> str
32 *
33 * @par Lua函数原型
34 * getName() -> string
35 *
36 * @par JSON-RPC请求示例
37 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getName","params":[],"id":1}
38 *
39 * @par JSON-RPC响应示例
40 * {"id":1,"jsonrpc":"2.0","result":"rob1"}
41 * \endchinese
42 * \english
43 * Get the robot's name.
44 *
45 * @return The robot's name.
46 *
47 * @throws arcs::common_interface::AuboException
48 *
49 * @par Python function prototype
50 * getName(self: pyaubo_sdk.RobotConfig) -> str
51 *
52 * @par Lua function prototype
53 * getName() -> string
54 *
55 * @par JSON-RPC request example
56 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getName","params":[],"id":1}
57 *
58 * @par JSON-RPC response example
59 * {"id":1,"jsonrpc":"2.0","result":"rob1"}
60 * \endenglish
61 */
62 std::string getName();
63
64 /**
65 * \chinese
66 * 获取机器人的自由度(从硬件抽象层读取)
67 *
68 * @return 返回机器人的自由度
69 *
70 * @throws arcs::common_interface::AuboException
71 *
72 * @par Python函数原型
73 * getDof(self: pyaubo_sdk.RobotConfig) -> int
74 *
75 * @par Lua函数原型
76 * getDof() -> number
77 *
78 * @par JSON-RPC请求示例
79 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDof","params":[],"id":1}
80 *
81 * @par JSON-RPC响应示例
82 * {"id":1,"jsonrpc":"2.0","result":6}
83 * \endchinese
84 * \english
85 * Get the robot's degrees of freedom (from the hardware abstraction layer).
86 *
87 * @return The robot's degrees of freedom.
88 *
89 * @throws arcs::common_interface::AuboException
90 *
91 * @par Python function prototype
92 * getDof(self: pyaubo_sdk.RobotConfig) -> int
93 *
94 * @par Lua function prototype
95 * getDof() -> number
96 *
97 * @par JSON-RPC request example
98 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDof","params":[],"id":1}
99 *
100 * @par JSON-RPC response example
101 * {"id":1,"jsonrpc":"2.0","result":6}
102 * \endenglish
103 */
104 int getDof();
105
106 /**
107 * \chinese
108 * 获取机器人的伺服控制周期(从硬件抽象层读取)
109 *
110 * @return 机器人的伺服控制周期
111 *
112 * @throws arcs::common_interface::AuboException
113 *
114 * @par Python函数原型
115 * getCycletime(self: pyaubo_sdk.RobotConfig) -> float
116 *
117 * @par Lua函数原型
118 * getCycletime() -> number
119 *
120 * @par JSON-RPC请求示例
121 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCycletime","params":[],"id":1}
122 *
123 * @par JSON-RPC响应示例
124 * {"id":1,"jsonrpc":"2.0","result":0.005}
125 * \endchinese
126 * \english
127 * Get the robot's servo control cycle time (from the hardware abstraction
128 * layer).
129 *
130 * @return The robot's servo control cycle time.
131 *
132 * @throws arcs::common_interface::AuboException
133 *
134 * @par Python function prototype
135 * getCycletime(self: pyaubo_sdk.RobotConfig) -> float
136 *
137 * @par Lua function prototype
138 * getCycletime() -> number
139 *
140 * @par JSON-RPC request example
141 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCycletime","params":[],"id":1}
142 *
143 * @par JSON-RPC response example
144 * {"id":1,"jsonrpc":"2.0","result":0.005}
145 * \endenglish
146 */
147 double getCycletime();
148
149 /**
150 * \chinese
151 * 预设缓速模式下的速度缩减比例
152 *
153 * @param level 缓速等级 1, 2
154 * @param fraction
155 *
156 * @return 成功返回0;失败返回错误码
157 * AUBO_BUSY
158 * AUBO_BAD_STATE
159 * AUBO_INVL_ARGUMENT
160 * -AUBO_BAD_STATE
161 *
162 * @throws arcs::common_interface::AuboException
163 *
164 * @par JSON-RPC请求示例
165 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setSlowDownFraction","params":[1,0.8],"id":1}
166 *
167 * @par JSON-RPC响应示例
168 * {"id":1,"jsonrpc":"2.0","result":0}
169 * \endchinese
170 * \english
171 * Set the speed reduction ratio for the preset slow-down mode.
172 *
173 * @param level Slow-down level 1, 2
174 * @param fraction
175 *
176 * @return Returns 0 on success; error code on failure
177 * AUBO_BUSY
178 * AUBO_BAD_STATE
179 * AUBO_INVL_ARGUMENT
180 * -AUBO_BAD_STATE
181 *
182 * @throws arcs::common_interface::AuboException
183 *
184 * @par JSON-RPC request example
185 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setSlowDownFraction","params":[1,0.8],"id":1}
186 *
187 * @par JSON-RPC response example
188 * {"id":1,"jsonrpc":"2.0","result":0}
189 * \endenglish
190 */
191 int setSlowDownFraction(int level, double fraction);
192
193 /**
194 * \chinese
195 * 获取预设的缓速模式下的速度缩减比例
196 *
197 * @param level 缓速等级 1, 2
198 * @return 返回预设的缓速模式下的速度缩减比例
199 *
200 * @throws arcs::common_interface::AuboException
201 *
202 * @par JSON-RPC请求示例
203 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSlowDownFraction","params":[1],"id":1}
204 *
205 * @par JSON-RPC响应示例
206 * {"id":1,"jsonrpc":"2.0","result":0.5}
207 * \endchinese
208 * \english
209 * Get the speed reduction ratio for the preset slow-down mode.
210 *
211 * @param level Slow-down level 1, 2
212 * @return The speed reduction ratio for the preset slow-down mode.
213 *
214 * @throws arcs::common_interface::AuboException
215 *
216 * @par JSON-RPC request example
217 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSlowDownFraction","params":[1],"id":1}
218 *
219 * @par JSON-RPC response example
220 * {"id":1,"jsonrpc":"2.0","result":0.5}
221 * \endenglish
222 */
223 double getSlowDownFraction(int level);
224
225 /**
226 * \chinese
227 * 获取默认的工具端加速度,单位m/s^2
228 *
229 * @return 默认的工具端加速度
230 *
231 * @throws arcs::common_interface::AuboException
232 *
233 * @par Python函数原型
234 * getDefaultToolAcc(self: pyaubo_sdk.RobotConfig) -> float
235 *
236 * @par Lua函数原型
237 * getDefaultToolAcc() -> number
238 *
239 * @par JSON-RPC请求示例
240 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultToolAcc","params":[],"id":1}
241 *
242 * @par JSON-RPC响应示例
243 * {"id":1,"jsonrpc":"2.0","result":0.0}
244 * \endchinese
245 * \english
246 * Get the default tool acceleration, in m/s^2.
247 *
248 * @return The default tool acceleration.
249 *
250 * @throws arcs::common_interface::AuboException
251 *
252 * @par Python function prototype
253 * getDefaultToolAcc(self: pyaubo_sdk.RobotConfig) -> float
254 *
255 * @par Lua function prototype
256 * getDefaultToolAcc() -> number
257 *
258 * @par JSON-RPC request example
259 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultToolAcc","params":[],"id":1}
260 *
261 * @par JSON-RPC response example
262 * {"id":1,"jsonrpc":"2.0","result":0.0}
263 * \endenglish
264 */
266
267 /**
268 * \chinese
269 * 获取默认的工具端速度,单位m/s
270 *
271 * @return 默认的工具端速度
272 *
273 * @throws arcs::common_interface::AuboException
274 *
275 * @par Python函数原型
276 * getDefaultToolSpeed(self: pyaubo_sdk.RobotConfig) -> float
277 *
278 * @par Lua函数原型
279 * getDefaultToolSpeed() -> number
280 *
281 * @par JSON-RPC请求示例
282 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultToolSpeed","params":[],"id":1}
283 *
284 * @par JSON-RPC响应示例
285 * {"id":1,"jsonrpc":"2.0","result":0.0}
286 * \endchinese
287 * \english
288 * Get the default tool speed, in m/s.
289 *
290 * @return The default tool speed.
291 *
292 * @throws arcs::common_interface::AuboException
293 *
294 * @par Python function prototype
295 * getDefaultToolSpeed(self: pyaubo_sdk.RobotConfig) -> float
296 *
297 * @par Lua function prototype
298 * getDefaultToolSpeed() -> number
299 *
300 * @par JSON-RPC request example
301 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultToolSpeed","params":[],"id":1}
302 *
303 * @par JSON-RPC response example
304 * {"id":1,"jsonrpc":"2.0","result":0.0}
305 * \endenglish
306 */
308
309 /**
310 * \chinese
311 * 获取默认的关节加速度,单位rad/s^2
312 *
313 * @return 默认的关节加速度
314 *
315 * @throws arcs::common_interface::AuboException
316 *
317 * @par Python函数原型
318 * getDefaultJointAcc(self: pyaubo_sdk.RobotConfig) -> float
319 *
320 * @par Lua函数原型
321 * getDefaultJointAcc() -> number
322 *
323 * @par JSON-RPC请求示例
324 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultJointAcc","params":[],"id":1}
325 *
326 * @par JSON-RPC响应示例
327 * {"id":1,"jsonrpc":"2.0","result":0.0}
328 * \endchinese
329 * \english
330 * Get the default joint acceleration, in rad/s^2.
331 *
332 * @return The default joint acceleration.
333 *
334 * @throws arcs::common_interface::AuboException
335 *
336 * @par Python function prototype
337 * getDefaultJointAcc(self: pyaubo_sdk.RobotConfig) -> float
338 *
339 * @par Lua function prototype
340 * getDefaultJointAcc() -> number
341 *
342 * @par JSON-RPC request example
343 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultJointAcc","params":[],"id":1}
344 *
345 * @par JSON-RPC response example
346 * {"id":1,"jsonrpc":"2.0","result":0.0}
347 * \endenglish
348 */
350
351 /**
352 * \chinese
353 * 获取默认的关节速度,单位rad/s
354 *
355 * @return 默认的关节速度
356 *
357 * @throws arcs::common_interface::AuboException
358 *
359 * @par Python函数原型
360 * getDefaultJointSpeed(self: pyaubo_sdk.RobotConfig) -> float
361 *
362 * @par Lua函数原型
363 * getDefaultJointSpeed() -> number
364 *
365 * @par JSON-RPC请求示例
366 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultJointSpeed","params":[],"id":1}
367 *
368 * @par JSON-RPC响应示例
369 * {"id":1,"jsonrpc":"2.0","result":0.0}
370 * \endchinese
371 * \english
372 * Get the default joint speed, in rad/s.
373 *
374 * @return The default joint speed.
375 *
376 * @throws arcs::common_interface::AuboException
377 *
378 * @par Python function prototype
379 * getDefaultJointSpeed(self: pyaubo_sdk.RobotConfig) -> float
380 *
381 * @par Lua function prototype
382 * getDefaultJointSpeed() -> number
383 *
384 * @par JSON-RPC request example
385 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getDefaultJointSpeed","params":[],"id":1}
386 *
387 * @par JSON-RPC response example
388 * {"id":1,"jsonrpc":"2.0","result":0.0}
389 * \endenglish
390 */
392
393 /**
394 * \chinese
395 * 获取机器人类型代码
396 *
397 * @return 机器人类型代码
398 *
399 * @throws arcs::common_interface::AuboException
400 *
401 * @par Python函数原型
402 * getRobotType(self: pyaubo_sdk.RobotConfig) -> str
403 *
404 * @par Lua函数原型
405 * getRobotType() -> string
406 *
407 * @par JSON-RPC请求示例
408 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotType","params":[],"id":1}
409 *
410 * @par JSON-RPC响应示例
411 * {"id":1,"jsonrpc":"2.0","result":"aubo_i5H"}
412 * \endchinese
413 * \english
414 * Get the robot type code.
415 *
416 * @return The robot type code.
417 *
418 * @throws arcs::common_interface::AuboException
419 *
420 * @par Python function prototype
421 * getRobotType(self: pyaubo_sdk.RobotConfig) -> str
422 *
423 * @par Lua function prototype
424 * getRobotType() -> string
425 *
426 * @par JSON-RPC request example
427 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotType","params":[],"id":1}
428 *
429 * @par JSON-RPC response example
430 * {"id":1,"jsonrpc":"2.0","result":"aubo_i5H"}
431 * \endenglish
432 */
433 std::string getRobotType();
434
435 /**
436 * \chinese
437 * 获取机器人子类型代码
438 *
439 * @return 机器人子类型代码
440 *
441 * @throws arcs::common_interface::AuboException
442 *
443 * @par Python函数原型
444 * getRobotSubType(self: pyaubo_sdk.RobotConfig) -> str
445 *
446 * @par Lua函数原型
447 * getRobotSubType() -> string
448 *
449 * @par JSON-RPC请求示例
450 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotSubType","params":[],"id":1}
451 *
452 * @par JSON-RPC响应示例
453 * {"id":1,"jsonrpc":"2.0","result":"B0"}
454 * \endchinese
455 * \english
456 * Get the robot sub-type code.
457 *
458 * @return The robot sub-type code.
459 *
460 * @throws arcs::common_interface::AuboException
461 *
462 * @par Python function prototype
463 * getRobotSubType(self: pyaubo_sdk.RobotConfig) -> str
464 *
465 * @par Lua function prototype
466 * getRobotSubType() -> string
467 *
468 * @par JSON-RPC request example
469 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotSubType","params":[],"id":1}
470 *
471 * @par JSON-RPC response example
472 * {"id":1,"jsonrpc":"2.0","result":"B0"}
473 * \endenglish
474 */
475 std::string getRobotSubType();
476
477 /**
478 * \chinese
479 * 获取控制柜类型代码
480 *
481 * @return 控制柜类型代码
482 *
483 * @throws arcs::common_interface::AuboException
484 *
485 * @par Python函数原型
486 * getControlBoxType(self: pyaubo_sdk.RobotConfig) -> str
487 *
488 * @par Lua函数原型
489 * getControlBoxType() -> string
490 *
491 * @par JSON-RPC请求示例
492 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getControlBoxType","params":[],"id":1}
493 *
494 * @par JSON-RPC响应示例
495 * {"id":1,"jsonrpc":"2.0","result":"cb_ISStation"}
496 * \endchinese
497 * \english
498 * Get the control box type code.
499 *
500 * @return The control box type code.
501 *
502 * @throws arcs::common_interface::AuboException
503 *
504 * @par Python function prototype
505 * getControlBoxType(self: pyaubo_sdk.RobotConfig) -> str
506 *
507 * @par Lua function prototype
508 * getControlBoxType() -> string
509 *
510 * @par JSON-RPC request example
511 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getControlBoxType","params":[],"id":1}
512 *
513 * @par JSON-RPC response example
514 * {"id":1,"jsonrpc":"2.0","result":"cb_ISStation"}
515 * \endenglish
516 */
517 std::string getControlBoxType();
518
519 /**
520 * \chinese
521 * 设置安装位姿(机器人的基坐标系相对于世界坐标系) world->base
522 *
523 * 一般在多机器人系统中使用,默认为 [0,0,0,0,0,0]
524 *
525 * @param pose 安装位姿
526 * @return 成功返回0; 失败返回错误码
527 * AUBO_BUSY
528 * AUBO_BAD_STATE
529 * -AUBO_INVL_ARGUMENT
530 * -AUBO_BAD_STATE
531 *
532 * @throws arcs::common_interface::AuboException
533 *
534 * @par Python函数原型
535 * setMountingPose(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
536 *
537 * @par Lua函数原型
538 * setMountingPose(pose: table) -> nil
539 *
540 * @par JSON-RPC请求示例
541 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setMountingPose","params":[[0.0,0.0,0.0,0.0,0.0,0.0]],"id":1}
542 *
543 * @par JSON-RPC响应示例
544 * {"id":1,"jsonrpc":"2.0","result":0}
545 * \endchinese
546 * \english
547 * Set the mounting pose (robot base coordinate system relative to world
548 * coordinate system) world->base
549 *
550 * Typically used in multi-robot systems, default is [0,0,0,0,0,0]
551 *
552 * @param pose Mounting pose
553 * @return Returns 0 on success; error code on failure
554 * AUBO_BUSY
555 * AUBO_BAD_STATE
556 * -AUBO_INVL_ARGUMENT
557 * -AUBO_BAD_STATE
558 *
559 * @throws arcs::common_interface::AuboException
560 *
561 * @par Python function prototype
562 * setMountingPose(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
563 *
564 * @par Lua function prototype
565 * setMountingPose(pose: table) -> nil
566 *
567 * @par JSON-RPC request example
568 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setMountingPose","params":[[0.0,0.0,0.0,0.0,0.0,0.0]],"id":1}
569 *
570 * @par JSON-RPC response example
571 * {"id":1,"jsonrpc":"2.0","result":0}
572 * \endenglish
573 */
574 int setMountingPose(const std::vector<double> &pose);
575
576 /**
577 * \chinese
578 * 获取安装位姿(机器人的基坐标系相对于世界坐标系)
579 *
580 * @return 安装位姿
581 *
582 * @throws arcs::common_interface::AuboException
583 *
584 * @par Python函数原型
585 * getMountingPose(self: pyaubo_sdk.RobotConfig) -> List[float]
586 *
587 * @par Lua函数原型
588 * getMountingPose() -> table
589 *
590 * @par JSON-RPC请求示例
591 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getMountingPose","params":[],"id":1}
592 *
593 * @par JSON-RPC响应示例
594 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
595 * \endchinese
596 * \english
597 * Get the mounting pose (robot base coordinate system relative to world
598 * coordinate system)
599 *
600 * @return Mounting pose
601 *
602 * @throws arcs::common_interface::AuboException
603 *
604 * @par Python function prototype
605 * getMountingPose(self: pyaubo_sdk.RobotConfig) -> List[float]
606 *
607 * @par Lua function prototype
608 * getMountingPose() -> table
609 *
610 * @par JSON-RPC request example
611 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getMountingPose","params":[],"id":1}
612 *
613 * @par JSON-RPC response example
614 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
615 * \endenglish
616 */
617 std::vector<double> getMountingPose();
618
619 /**
620 * \chinese
621 * 将机器人绑定到一个坐标系,如果这个坐标系是运动的,那机器人也会跟着运动
622 * 应用于地轨或者龙门
623 * 这个函数调用的时候 frame 和 ROBOTBASE 的相对关系就固定了
624 * \endchinese
625 * \english
626 * Attach the robot base to a coordinate frame. If this frame moves, the
627 * robot will move accordingly. Used for applications like ground rails or
628 * gantries. When this function is called, the relationship between the
629 * frame and ROBOTBASE is fixed. \endenglish
630 */
631 int attachRobotBaseTo(const std::string &frame);
632 std::string getRobotBaseParent();
633
634 /**
635 * \chinese
636 * 设置工件数据,编程点位都是基于工件坐标系
637 * \endchinese
638 * \english
639 * Set work object data. All programmed points are based on the work object
640 * coordinate system. \endenglish
641 */
642
644
645 /**
646 * \chinese
647 * 设置碰撞灵敏度等级
648 * 数值越大越灵敏
649 *
650 * @param level 碰撞灵敏度等级
651 * 0: 关闭碰撞检测功能
652 * 1~9: 碰撞灵敏等级
653 * @return 成功返回0; 失败返回错误码
654 * AUBO_BUSY
655 * AUBO_BAD_STATE
656 * -AUBO_INVL_ARGUMENT
657 * -AUBO_BAD_STATE
658 *
659 * @throws arcs::common_interface::AuboException
660 *
661 * @par Python函数原型
662 * setCollisionLevel(self: pyaubo_sdk.RobotConfig, arg0: int) -> int
663 *
664 * @par Lua函数原型
665 * setCollisionLevel(level: number) -> nil
666 *
667 * @par JSON-RPC请求示例
668 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setCollisionLevel","params":[6],"id":1}
669 *
670 * @par JSON-RPC响应示例
671 * {"id":1,"jsonrpc":"2.0","result":0}
672 * \endchinese
673 * \english
674 * Set the collision sensitivity level.
675 * The higher the value, the more sensitive.
676 *
677 * @param level Collision sensitivity level
678 * 0: Disable collision detection
679 * 1~9: Collision sensitivity levels
680 * @return Returns 0 on success; error code on failure
681 * AUBO_BUSY
682 * AUBO_BAD_STATE
683 * -AUBO_INVL_ARGUMENT
684 * -AUBO_BAD_STATE
685 *
686 * @throws arcs::common_interface::AuboException
687 *
688 * @par Python function prototype
689 * setCollisionLevel(self: pyaubo_sdk.RobotConfig, arg0: int) -> int
690 *
691 * @par Lua function prototype
692 * setCollisionLevel(level: number) -> nil
693 *
694 * @par JSON-RPC request example
695 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setCollisionLevel","params":[6],"id":1}
696 *
697 * @par JSON-RPC response example
698 * {"id":1,"jsonrpc":"2.0","result":0}
699 * \endenglish
700 */
701 int setCollisionLevel(int level);
702
703 /**
704 * \chinese
705 * 获取碰撞灵敏度等级
706 *
707 * @return 碰撞灵敏度等级
708 *
709 * @throws arcs::common_interface::AuboException
710 *
711 * @par Python函数原型
712 * getCollisionLevel(self: pyaubo_sdk.RobotConfig) -> int
713 *
714 * @par Lua函数原型
715 * getCollisionLevel() -> number
716 *
717 * @par JSON-RPC请求示例
718 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCollisionLevel","params":[],"id":1}
719 *
720 * @par JSON-RPC响应示例
721 * {"id":1,"jsonrpc":"2.0","result":6}
722 * \endchinese
723 * \english
724 * Get the collision sensitivity level.
725 *
726 * @return Collision sensitivity level.
727 *
728 * @throws arcs::common_interface::AuboException
729 *
730 * @par Python function prototype
731 * getCollisionLevel(self: pyaubo_sdk.RobotConfig) -> int
732 *
733 * @par Lua function prototype
734 * getCollisionLevel() -> number
735 *
736 * @par JSON-RPC request example
737 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCollisionLevel","params":[],"id":1}
738 *
739 * @par JSON-RPC response example
740 * {"id":1,"jsonrpc":"2.0","result":6}
741 * \endenglish
742 */
744
745 /**
746 * \chinese
747 * 设置碰撞停止类型
748 *
749 * @param type 类型 \n
750 * 0: 碰撞后浮动,即碰撞之后进入拖动示教模式 \n
751 * 1: 碰撞后静止 \n
752 * 2: 碰撞后抱闸
753 *
754 * @return 成功返回0; 失败返回错误码
755 * AUBO_BUSY
756 * AUBO_BAD_STATE
757 * -AUBO_INVL_ARGUMENT
758 * -AUBO_BAD_STATE
759 *
760 * @throws arcs::common_interface::AuboException
761 *
762 * @par Python函数原型
763 * setCollisionStopType(self: pyaubo_sdk.RobotConfig, arg0: int) -> int
764 *
765 * @par Lua函数原型
766 * setCollisionStopType(type: number) -> nil
767 *
768 * @par JSON-RPC请求示例
769 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setCollisionStopType","params":[1],"id":1}
770 *
771 * @par JSON-RPC响应示例
772 * {"id":1,"jsonrpc":"2.0","result":0}
773 * \endchinese
774 * \english
775 * Set the collision stop type.
776 *
777 * @param type Type \n
778 * 0: Floating after collision, i.e., enters freedrive mode after collision
779 * \n 1: Stop after collision \n 2: Brake after collision
780 *
781 * @return Returns 0 on success; error code on failure
782 * AUBO_BUSY
783 * AUBO_BAD_STATE
784 * -AUBO_INVL_ARGUMENT
785 * -AUBO_BAD_STATE
786 *
787 * @throws arcs::common_interface::AuboException
788 *
789 * @par Python function prototype
790 * setCollisionStopType(self: pyaubo_sdk.RobotConfig, arg0: int) -> int
791 *
792 * @par Lua function prototype
793 * setCollisionStopType(type: number) -> nil
794 *
795 * @par JSON-RPC request example
796 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setCollisionStopType","params":[1],"id":1}
797 *
798 * @par JSON-RPC response example
799 * {"id":1,"jsonrpc":"2.0","result":0}
800 * \endenglish
801 */
802 int setCollisionStopType(int type);
803
804 /**
805 * \chinese
806 * 获取碰撞停止类型
807 *
808 * @return 返回碰撞停止类型 \n
809 * 0: 碰撞后浮动,即碰撞之后进入拖动示教模式 \n
810 * 1: 碰撞后静止 \n
811 * 2: 碰撞后抱闸
812 *
813 * @throws arcs::common_interface::AuboException
814 *
815 * @par Python函数原型
816 * getCollisionStopType(self: pyaubo_sdk.RobotConfig) -> int
817 *
818 * @par Lua函数原型
819 * getCollisionStopType() -> number
820 *
821 * @par JSON-RPC请求示例
822 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCollisionStopType","params":[],"id":1}
823 *
824 * @par JSON-RPC响应示例
825 * {"id":1,"jsonrpc":"2.0","result":1}
826 *
827 * \endchinese
828 * \english
829 * Get the collision stop type.
830 *
831 * @return The collision stop type. \n
832 * 0: Floating after collision, i.e., enters freedrive mode after collision
833 * \n 1: Stop after collision \n 2: Brake after collision
834 *
835 * @throws arcs::common_interface::AuboException
836 *
837 * @par Python function prototype
838 * getCollisionStopType(self: pyaubo_sdk.RobotConfig) -> int
839 *
840 * @par Lua function prototype
841 * getCollisionStopType() -> number
842 *
843 * @par JSON-RPC request example
844 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getCollisionStopType","params":[],"id":1}
845 *
846 * @par JSON-RPC response example
847 * {"id":1,"jsonrpc":"2.0","result":1}
848 *
849 * \endenglish
850 */
852
853 /**
854 * \chinese
855 * 设置机器人的原点位置
856 *
857 * @param positions 关节角度
858 * @return 成功返回0;失败返回错误码
859 * AUBO_BUSY
860 * AUBO_BAD_STATE
861 * -AUBO_INVL_ARGUMENT
862 * -AUBO_BAD_STATE
863 *
864 * @throws arcs::common_interface::AuboException
865 *
866 * @par JSON-RPC请求示例
867 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setHomePosition","params":[[0.0,-0.2617993877991494,1.74532925199433,0.4363323129985824,1.570796326794897,0.0]],"id":1}
868 *
869 * @par JSON-RPC响应示例
870 * {"id":1,"jsonrpc":"2.0","result":0}
871 * \endchinese
872 * \english
873 * Set the robot's home position.
874 *
875 * @param positions Joint angles
876 * @return Returns 0 on success; error code on failure
877 * AUBO_BUSY
878 * AUBO_BAD_STATE
879 * -AUBO_INVL_ARGUMENT
880 * -AUBO_BAD_STATE
881 *
882 * @throws arcs::common_interface::AuboException
883 *
884 * @par JSON-RPC request example
885 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setHomePosition","params":[[0.0,-0.2617993877991494,1.74532925199433,0.4363323129985824,1.570796326794897,0.0]],"id":1}
886 *
887 * @par JSON-RPC response example
888 * {"id":1,"jsonrpc":"2.0","result":0}
889 * \endenglish
890 */
891 int setHomePosition(const std::vector<double> &positions);
892
893 /**
894 * \chinese
895 * 获取机器人的原点位置
896 *
897 * @return
898 *
899 * @throws arcs::common_interface::AuboException
900 *
901 * @par JSON-RPC请求示例
902 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getHomePosition","params":[],"id":1}
903 *
904 * @par JSON-RPC响应示例
905 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.2617993877991494,1.74532925199433,0.4363323129985824,1.570796326794897,0.0]}
906 * \endchinese
907 * \english
908 * Get the robot's home position.
909 *
910 * @return
911 *
912 * @throws arcs::common_interface::AuboException
913 *
914 * @par JSON-RPC request example
915 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getHomePosition","params":[],"id":1}
916 *
917 * @par JSON-RPC response example
918 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.2617993877991494,1.74532925199433,0.4363323129985824,1.570796326794897,0.0]}
919 * \endenglish
920 */
921 std::vector<double> getHomePosition();
922
923 /**
924 * \chinese
925 * 设置拖动阻尼
926 *
927 * @param damp 阻尼
928 *
929 * @return 成功返回0;失败返回错误码
930 * AUBO_BUSY
931 * AUBO_BAD_STATE
932 * -AUBO_INVL_ARGUMENT
933 * -AUBO_BAD_STATE
934 *
935 * @throws arcs::common_interface::AuboException
936 *
937 * @par Python函数原型
938 * setFreedriveDamp(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
939 *
940 * @par Lua函数原型
941 * setFreedriveDamp(damp: table) -> number
942 *
943 * @par JSON-RPC请求示例
944 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setFreedriveDamp","params":[[0.5,0.5,0.5,0.5,0.5,0.5]],"id":1}
945 *
946 * @par JSON-RPC响应示例
947 * {"id":1,"jsonrpc":"2.0","result":0}
948 *
949 * \endchinese
950 * \english
951 * Set freedrive damping.
952 *
953 * @param damp Damping values.
954 *
955 * @return Returns 0 on success; error code on failure
956 * AUBO_BUSY
957 * AUBO_BAD_STATE
958 * -AUBO_INVL_ARGUMENT
959 * -AUBO_BAD_STATE
960 *
961 * @throws arcs::common_interface::AuboException
962 *
963 * @par Python function prototype
964 * setFreedriveDamp(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
965 *
966 * @par Lua function prototype
967 * setFreedriveDamp(damp: table) -> number
968 *
969 * @par JSON-RPC request example
970 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setFreedriveDamp","params":[[0.5,0.5,0.5,0.5,0.5,0.5]],"id":1}
971 *
972 * @par JSON-RPC response example
973 * {"id":1,"jsonrpc":"2.0","result":0}
974 *
975 * \endenglish
976 */
977 int setFreedriveDamp(const std::vector<double> &damp);
978
979 /**
980 * \chinese
981 * 获取拖动阻尼
982 *
983 * @return 拖动阻尼
984 *
985 * @throws arcs::common_interface::AuboException
986 *
987 * @par Python函数原型
988 * getFreedriveDamp(self: pyaubo_sdk.RobotConfig) -> List[float]
989 *
990 * @par Lua函数原型
991 * getFreedriveDamp() -> table
992 *
993 * @par JSON-RPC请求示例
994 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getFreedriveDamp","params":[],"id":1}
995 *
996 * @par JSON-RPC响应示例
997 * {"id":1,"jsonrpc":"2.0","result":[0.5,0.5,0.5,0.5,0.5,0.5]}
998 * \endchinese
999 * \english
1000 * Get freedrive damping.
1001 *
1002 * @return Freedrive damping values.
1003 *
1004 * @throws arcs::common_interface::AuboException
1005 *
1006 * @par Python function prototype
1007 * getFreedriveDamp(self: pyaubo_sdk.RobotConfig) -> List[float]
1008 *
1009 * @par Lua function prototype
1010 * getFreedriveDamp() -> table
1011 *
1012 * @par JSON-RPC request example
1013 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getFreedriveDamp","params":[],"id":1}
1014 *
1015 * @par JSON-RPC response example
1016 * {"id":1,"jsonrpc":"2.0","result":[0.5,0.5,0.5,0.5,0.5,0.5]}
1017 * \endenglish
1018 */
1019 std::vector<double> getFreedriveDamp();
1020
1021 /**
1022 * \chinese
1023 * 设置混合拖动阻尼
1024 *
1025 * @param damp 阻尼
1026 *
1027 * @return 成功返回0;失败返回错误码
1028 * AUBO_BUSY
1029 * AUBO_BAD_STATE
1030 * -AUBO_INVL_ARGUMENT
1031 * -AUBO_BAD_STATE
1032 *
1033 * @throws arcs::common_interface::AuboException
1034 *
1035 * @par Python函数原型
1036 * setHandguidDamp(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
1037 *
1038 * @par Lua函数原型
1039 * setHandguidDamp(damp: table) -> number
1040 *
1041 * @par JSON-RPC请求示例
1042 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setHandguidDamp","params":[[0.5,0.5,0.5,0.5,0.5,0.5]],"id":1}
1043 *
1044 * @par JSON-RPC响应示例
1045 * {"id":1,"jsonrpc":"2.0","result":0}
1046 * \endchinese
1047 * \english
1048 * Set handguiding damping.
1049 *
1050 * @param damp damping coef.
1051 *
1052 * @return return 0 for success;return rror code for failure
1053 * AUBO_BUSY
1054 * AUBO_BAD_STATE
1055 * -AUBO_INVL_ARGUMENT
1056 * -AUBO_BAD_STATE
1057 *
1058 * @throws arcs::common_interface::AuboException
1059 *
1060 * @par Python function prototype
1061 * setHandguidDamp(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
1062 *
1063 * @par Lua function prototype
1064 * setHandguidDamp(damp: table) -> number
1065 *
1066 * @par JSON-RPC request example
1067 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setHandguidDamp","params":[[0.5,0.5,0.5,0.5,0.5,0.5]],"id":1}
1068 *
1069 * @par JSON-RPC response example
1070 * {"id":1,"jsonrpc":"2.0","result":0}
1071 * \endenglish
1072 */
1073 int setHandguidDamp(const std::vector<double> &damp);
1074
1075 /**
1076 * \chinese
1077 * 获取混合拖动阻尼
1078 *
1079 * @return 拖动阻尼
1080 *
1081 * @throws arcs::common_interface::AuboException
1082 *
1083 * @par Python函数原型
1084 * getHandguidDamp(self: pyaubo_sdk.RobotConfig) -> List[float]
1085 *
1086 * @par Lua函数原型
1087 * getHandguidDamp() -> table
1088 *
1089 * @par JSON-RPC请求示例
1090 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getHandguidDamp","params":[],"id":1}
1091 *
1092 * @par JSON-RPC响应示例
1093 * {"id":1,"jsonrpc":"2.0","result":[0.5,0.5,0.5,0.5,0.5,0.5]}
1094 * \endchinese
1095 * \english
1096 * Get handguiding damping.
1097 *
1098 * @return handguuiding damping
1099 *
1100 * @throws arcs::common_interface::AuboException
1101 *
1102 * @par Python function prototype
1103 * getHandguidDamp(self: pyaubo_sdk.RobotConfig) -> List[float]
1104 *
1105 * @par Lua fuunction prototype
1106 * getHandguidDamp() -> table
1107 *
1108 * @par JSON-RPC request example
1109 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getHandguidDamp","params":[],"id":1}
1110 *
1111 * @par JSON-RPC response example
1112 * {"id":1,"jsonrpc":"2.0","result":[0.5,0.5,0.5,0.5,0.5,0.5]}
1113 * \endenglish
1114 */
1115 std::vector<double> getHandguidDamp();
1116
1117 /**
1118 * \chinese
1119 * 获取机器人DH参数
1120 * alpha a d theta beta
1121 *
1122 * @param real 读取真实参数(理论值+补偿值)或者理论参数
1123 * @return 返回机器人DH参数
1124 *
1125 * @throws arcs::common_interface::AuboException
1126 *
1127 * @par Python函数原型
1128 * getKinematicsParam(self: pyaubo_sdk.RobotConfig, arg0: bool) -> Dict[str,
1129 * List[float]]
1130 *
1131 * @par Lua函数原型
1132 * getKinematicsParam(real: boolean) -> table
1133 *
1134 * @par JSON-RPC请求示例
1135 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getKinematicsParam","params":[true],"id":1}
1136 *
1137 * @par JSON-RPC响应示例
1138 * {"id":1,"jsonrpc":"2.0","result":{"a":[0.0,-0.0001255999959539622,0.4086348000024445,0.3757601999930339,-0.00018950000230688602,3.7000001611886546e-05],
1139 * "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],
1140 * "d":[0.122,0.12154769999941345,-4.769999941345304e-05,4.769999941345304e-05,0.10287890000385232,0.116],
1141 * "theta":[3.141592653589793,-1.5707963267948966,0.0,-1.5707963267948966,0.0,0.0]}}
1142 * \endchinese
1143 * \english
1144 * Get the robot's DH parameters: alpha, a, d, theta, beta.
1145 *
1146 * @param real Read real parameters (theoretical + compensation) or
1147 * theoretical parameters.
1148 * @return Returns the robot's DH parameters.
1149 *
1150 * @throws arcs::common_interface::AuboException
1151 *
1152 * @par Python function prototype
1153 * getKinematicsParam(self: pyaubo_sdk.RobotConfig, arg0: bool) -> Dict[str,
1154 * List[float]]
1155 *
1156 * @par Lua function prototype
1157 * getKinematicsParam(real: boolean) -> table
1158 *
1159 * @par JSON-RPC request example
1160 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getKinematicsParam","params":[true],"id":1}
1161 *
1162 * @par JSON-RPC response example
1163 * {"id":1,"jsonrpc":"2.0","result":{"a":[0.0,-0.0001255999959539622,0.4086348000024445,0.3757601999930339,-0.00018950000230688602,3.7000001611886546e-05],
1164 * "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],
1165 * "d":[0.122,0.12154769999941345,-4.769999941345304e-05,4.769999941345304e-05,0.10287890000385232,0.116],
1166 * "theta":[3.141592653589793,-1.5707963267948966,0.0,-1.5707963267948966,0.0,0.0]}}
1167 * \endenglish
1168 */
1169 std::unordered_map<std::string, std::vector<double>> getKinematicsParam(
1170 bool real);
1171
1172 /**
1173 * \chinese
1174 * 获取指定温度下的DH参数补偿值:alpha a d theta beta
1175 *
1176 * @param ref_temperature 参考温度 ℃,默认20℃
1177 * @return 返回DH参数补偿值
1178 *
1179 * @throws arcs::common_interface::AuboException
1180 *
1181 * @par Python函数原型
1182 * getKinematicsCompensate(self: pyaubo_sdk.RobotConfig, arg0: float) ->
1183 * Dict[str, List[float]]
1184 *
1185 * @par Lua函数原型
1186 * getKinematicsCompensate(ref_temperature: number) -> table
1187 *
1188 * @par JSON-RPC请求示例
1189 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getKinematicsCompensate","params":[20],"id":1}
1190 *
1191 * @par JSON-RPC响应示例
1192 * {"id":1,"jsonrpc":"2.0","result":{"a":[0.0,-0.0001255999959539622,0.0006348000024445355,-0.0002398000069661066,-0.00018950000230688602,3.7000001611886546e-05],
1193 * "alpha":[0.0,0.000678930024150759,0.002438219962641597,0.0049148499965667725,0.00048695001169107854,0.004321440123021603],
1194 * "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],
1195 * "theta":[0.0,0.0,0.0,0.0,0.0,0.0]}}
1196 * \endchinese
1197 * \english
1198 * Get DH parameter compensation values (alpha, a, d, theta, beta) at the
1199 * specified temperature.
1200 *
1201 * @param ref_temperature Reference temperature in ℃, default is 20℃
1202 * @return Returns DH parameter compensation values.
1203 *
1204 * @throws arcs::common_interface::AuboException
1205 *
1206 * @par Python function prototype
1207 * getKinematicsCompensate(self: pyaubo_sdk.RobotConfig, arg0: float) ->
1208 * Dict[str, List[float]]
1209 *
1210 * @par Lua function prototype
1211 * getKinematicsCompensate(ref_temperature: number) -> table
1212 *
1213 * @par JSON-RPC request example
1214 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getKinematicsCompensate","params":[20],"id":1}
1215 *
1216 * @par JSON-RPC response example
1217 * {"id":1,"jsonrpc":"2.0","result":{"a":[0.0,-0.0001255999959539622,0.0006348000024445355,-0.0002398000069661066,-0.00018950000230688602,3.7000001611886546e-05],
1218 * "alpha":[0.0,0.000678930024150759,0.002438219962641597,0.0049148499965667725,0.00048695001169107854,0.004321440123021603],
1219 * "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],
1220 * "theta":[0.0,0.0,0.0,0.0,0.0,0.0]}}
1221 * \endenglish
1222 */
1223 std::unordered_map<std::string, std::vector<double>>
1224 getKinematicsCompensate(double ref_temperature);
1225
1226 /**
1227 * \chinese
1228 * 设置标准 DH 补偿到机器人
1229 *
1230 * @param param
1231 *
1232 * @return 成功返回0;失败返回错误码
1233 * AUBO_BUSY
1234 * AUBO_BAD_STATE
1235 * -AUBO_INVL_ARGUMENT
1236 * -AUBO_BAD_STATE
1237 *
1238 * @throws arcs::common_interface::AuboException
1239 * \endchinese
1240 * \english
1241 * Set standard DH compensation to the robot.
1242 *
1243 * @param param
1244 *
1245 * @return Returns 0 on success; error code on failure
1246 * AUBO_BUSY
1247 * AUBO_BAD_STATE
1248 * -AUBO_INVL_ARGUMENT
1249 * -AUBO_BAD_STATE
1250 *
1251 * @throws arcs::common_interface::AuboException
1252 * \endenglish
1253 */
1255 const std::unordered_map<std::string, std::vector<double>> &param);
1256
1257 /**
1258 * \chinese
1259 * 设置需要保存到接口板底座的参数
1260 *
1261 * @param param 补偿数据
1262 *
1263 * @return 成功返回0;失败返回错误码
1264 * AUBO_BUSY
1265 * AUBO_BAD_STATE
1266 * -AUBO_INVL_ARGUMENT
1267 * -AUBO_BAD_STATE
1268 *
1269 * @throws arcs::common_interface::AuboException
1270 *
1271 * @par Python函数原型
1272 * setPersistentParameters(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
1273 *
1274 * @par Lua函数原型
1275 * setPersistentParameters(param: string) -> nil
1276 *
1277 * \endchinese
1278 * \english
1279 * Set parameters to be saved to the interface board base.
1280 *
1281 * @param param Compensation data.
1282 *
1283 * @return Returns 0 on success; error code on failure.
1284 * AUBO_BUSY
1285 * AUBO_BAD_STATE
1286 * -AUBO_INVL_ARGUMENT
1287 * -AUBO_BAD_STATE
1288 *
1289 * @throws arcs::common_interface::AuboException
1290 *
1291 * @par Python function prototype
1292 * setPersistentParameters(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
1293 *
1294 * @par Lua function prototype
1295 * setPersistentParameters(param: string) -> nil
1296 *
1297 * \endenglish
1298 */
1299 int setPersistentParameters(const std::string &param);
1300
1301 /**
1302 * \chinese
1303 * 设置硬件抽象层自定义参数
1304 * 目的是为了做不同硬件之间的兼容
1305 *
1306 * @param param 自定义参数
1307 *
1308 * @return 成功返回0;失败返回错误码
1309 * AUBO_BUSY
1310 * AUBO_BAD_STATE
1311 * -AUBO_INVL_ARGUMENT
1312 * -AUBO_BAD_STATE
1313 *
1314 * @throws arcs::common_interface::AuboException
1315 * \endchinese
1316 * \english
1317 * Set custom parameters for the hardware abstraction layer.
1318 * The purpose is to ensure compatibility between different hardware.
1319 *
1320 * @param param Custom parameters.
1321 *
1322 * @return Returns 0 on success; error code on failure.
1323 * AUBO_BUSY
1324 * AUBO_BAD_STATE
1325 * -AUBO_INVL_ARGUMENT
1326 * -AUBO_BAD_STATE
1327 *
1328 * @throws arcs::common_interface::AuboException
1329 * \endenglish
1330 */
1331 int setHardwareCustomParameters(const std::string &param);
1332
1333 /**
1334 * \chinese
1335 * 获取硬件抽象层自定义参数
1336 *
1337 * @param
1338 * @return 返回硬件抽象层自定义的参数
1339 *
1340 * @throws arcs::common_interface::AuboException
1341 * \endchinese
1342 * \english
1343 * Get custom parameters from the hardware abstraction layer.
1344 *
1345 * @param
1346 * @return Returns custom parameters from the hardware abstraction layer.
1347 *
1348 * @throws arcs::common_interface::AuboException
1349 * \endenglish
1350 */
1351 std::string getHardwareCustomParameters(const std::string &param);
1352
1353 /**
1354 * \chinese
1355 * 设置机器人关节零位
1356 *
1357 * @return 成功返回0;失败返回错误码
1358 * AUBO_BUSY
1359 * AUBO_BAD_STATE
1360 * -AUBO_BAD_STATE
1361 *
1362 * @throws arcs::common_interface::AuboException
1363 *
1364 * @par Python函数原型
1365 * setRobotZero(self: pyaubo_sdk.RobotConfig) -> int
1366 *
1367 * @par Lua函数原型
1368 * setRobotZero() -> nil
1369 *
1370 * @par JSON-RPC请求示例
1371 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setRobotZero","params":[],"id":1}
1372 *
1373 * @par JSON-RPC响应示例
1374 * {"id":1,"jsonrpc":"2.0","result":0}
1375 * \endchinese
1376 * \english
1377 * Set the robot joint zero position.
1378 *
1379 * @return Returns 0 on success; error code on failure
1380 * AUBO_BUSY
1381 * AUBO_BAD_STATE
1382 * -AUBO_BAD_STATE
1383 *
1384 * @throws arcs::common_interface::AuboException
1385 *
1386 * @par Python function prototype
1387 * setRobotZero(self: pyaubo_sdk.RobotConfig) -> int
1388 *
1389 * @par Lua function prototype
1390 * setRobotZero() -> nil
1391 *
1392 * @par JSON-RPC request example
1393 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setRobotZero","params":[],"id":1}
1394 *
1395 * @par JSON-RPC response example
1396 * {"id":1,"jsonrpc":"2.0","result":0}
1397 * \endenglish
1398 */
1400
1401 /**
1402 * \chinese
1403 * 获取可用的末端力矩传感器的名字
1404 *
1405 * @return 返回可用的末端力矩传感器的名字
1406 *
1407 * @throws arcs::common_interface::AuboException
1408 *
1409 * @par Python函数原型
1410 * getTcpForceSensorNames(self: pyaubo_sdk.RobotConfig) -> List[str]
1411 *
1412 * @par Lua函数原型
1413 * getTcpForceSensorNames() -> table
1414 *
1415 * @par JSON-RPC请求示例
1416 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceSensorNames","params":[],"id":1}
1417 *
1418 * @par JSON-RPC响应示例
1419 * {"id":1,"jsonrpc":"2.0","result":[]}
1420 *
1421 * \endchinese
1422 * \english
1423 * Get the names of available TCP force sensors.
1424 *
1425 * @return Returns the names of available TCP force sensors.
1426 *
1427 * @throws arcs::common_interface::AuboException
1428 *
1429 * @par Python function prototype
1430 * getTcpForceSensorNames(self: pyaubo_sdk.RobotConfig) -> List[str]
1431 *
1432 * @par Lua function prototype
1433 * getTcpForceSensorNames() -> table
1434 *
1435 * @par JSON-RPC request example
1436 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceSensorNames","params":[],"id":1}
1437 *
1438 * @par JSON-RPC response example
1439 * {"id":1,"jsonrpc":"2.0","result":[]}
1440 *
1441 * \endenglish
1442 */
1443 std::vector<std::string> getTcpForceSensorNames();
1444
1445 /**
1446 * \chinese
1447 * 设置末端力矩传感器
1448 * 如果存在内置的末端力矩传感器,默认将使用内置的力矩传感器
1449 *
1450 * @param name 末端力矩传感器的名字
1451 *
1452 * @return 成功返回0;失败返回错误码
1453 * AUBO_BUSY
1454 * AUBO_BAD_STATE
1455 * -AUBO_INVL_ARGUMENT
1456 * -AUBO_BAD_STATE
1457 *
1458 * @throws arcs::common_interface::AuboException
1459 *
1460 * @par Python函数原型
1461 * selectTcpForceSensor(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
1462 *
1463 * @par Lua函数原型
1464 * selectTcpForceSensor(name: string) -> nil
1465 * \endchinese
1466 * \english
1467 * Set the TCP force sensor.
1468 * If there is a built-in TCP force sensor, the built-in sensor will be used
1469 * by default.
1470 *
1471 * @param name Name of the TCP force sensor.
1472 *
1473 * @return Returns 0 on success; error code on failure.
1474 * AUBO_BUSY
1475 * AUBO_BAD_STATE
1476 * -AUBO_INVL_ARGUMENT
1477 * -AUBO_BAD_STATE
1478 *
1479 * @throws arcs::common_interface::AuboException
1480 *
1481 * @par Python function prototype
1482 * selectTcpForceSensor(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
1483 *
1484 * @par Lua function prototype
1485 * selectTcpForceSensor(name: string) -> nil
1486 * \endenglish
1487 */
1488 int selectTcpForceSensor(const std::string &name);
1489
1490 /**
1491 * \chinese
1492 * 设置传感器安装位姿
1493 *
1494 * @param sensor_pose 传感器安装位姿
1495 *
1496 * @return 成功返回0;失败返回错误码
1497 * AUBO_BUSY
1498 * AUBO_BAD_STATE
1499 * -AUBO_INVL_ARGUMENT
1500 * -AUBO_BAD_STATE
1501 *
1502 * @throws arcs::common_interface::AuboException
1503 * \endchinese
1504 * \english
1505 * Set the sensor mounting pose.
1506 *
1507 * @param sensor_pose Sensor mounting pose
1508 *
1509 * @return Returns 0 on success; error code on failure
1510 * AUBO_BUSY
1511 * AUBO_BAD_STATE
1512 * -AUBO_INVL_ARGUMENT
1513 * -AUBO_BAD_STATE
1514 *
1515 * @throws arcs::common_interface::AuboException
1516 * \endenglish
1517 */
1518 int setTcpForceSensorPose(const std::vector<double> &sensor_pose);
1519
1520 /**
1521 * \chinese
1522 * 获取传感器安装位姿
1523 *
1524 * @return 传感器安装位姿
1525 *
1526 * @throws arcs::common_interface::AuboException
1527 *
1528 * @par JSON-RPC请求示例
1529 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceSensorPose","params":[],"id":1}
1530 *
1531 * @par JSON-RPC响应示例
1532 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1533 * \endchinese
1534 * \english
1535 * Get the sensor mounting pose.
1536 *
1537 * @return Sensor mounting pose.
1538 *
1539 * @throws arcs::common_interface::AuboException
1540 *
1541 * @par JSON-RPC request example
1542 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceSensorPose","params":[],"id":1}
1543 *
1544 * @par JSON-RPC response example
1545 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1546 * \endenglish
1547 */
1548 std::vector<double> getTcpForceSensorPose();
1549
1550 /**
1551 * \chinese
1552 * 是否安装了末端力矩传感器
1553 *
1554 * @return 安装返回true; 没有安装返回false
1555 *
1556 * @throws arcs::common_interface::AuboException
1557 *
1558 * @par Python函数原型
1559 * hasTcpForceSensor(self: pyaubo_sdk.RobotConfig) -> bool
1560 *
1561 * @par Lua函数原型
1562 * hasTcpForceSensor() -> boolean
1563 *
1564 * @par JSON-RPC请求示例
1565 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.hasTcpForceSensor","params":[],"id":1}
1566 *
1567 * @par JSON-RPC响应示例
1568 * {"id":1,"jsonrpc":"2.0","result":true}
1569 *
1570 * \endchinese
1571 * \english
1572 * Whether a TCP force sensor is installed.
1573 *
1574 * @return Returns true if installed; false otherwise.
1575 *
1576 * @throws arcs::common_interface::AuboException
1577 *
1578 * @par Python function prototype
1579 * hasTcpForceSensor(self: pyaubo_sdk.RobotConfig) -> bool
1580 *
1581 * @par Lua function prototype
1582 * hasTcpForceSensor() -> boolean
1583 *
1584 * @par JSON-RPC request example
1585 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.hasTcpForceSensor","params":[],"id":1}
1586 *
1587 * @par JSON-RPC response example
1588 * {"id":1,"jsonrpc":"2.0","result":true}
1589 *
1590 * \endenglish
1591 */
1593
1594 /**
1595 * \chinese
1596 * 设置末端力矩偏移
1597 *
1598 * @param force_offset 末端力矩偏移
1599 * @return 成功返回0; 失败返回错误码
1600 *
1601 * @throws arcs::common_interface::AuboException
1602 *
1603 * @par Python函数原型
1604 * setTcpForceOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
1605 *
1606 * @par Lua函数原型
1607 * setTcpForceOffset(force_offset: table) -> nil
1608 *
1609 * \endchinese
1610 * \english
1611 * Set the TCP force/torque offset.
1612 *
1613 * @param force_offset TCP force/torque offset
1614 * @return Returns 0 on success; error code on failure
1615 *
1616 * @throws arcs::common_interface::AuboException
1617 *
1618 * @par Python function prototype
1619 * setTcpForceOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
1620 *
1621 * @par Lua function prototype
1622 * setTcpForceOffset(force_offset: table) -> nil
1623 *
1624 * \endenglish
1625 */
1626 int setTcpForceOffset(const std::vector<double> &force_offset);
1627
1628 /**
1629 * \chinese
1630 * 获取末端力矩偏移
1631 *
1632 * @return 返回末端力矩偏移
1633 *
1634 * @throws arcs::common_interface::AuboException
1635 *
1636 * @par Python函数原型
1637 * getTcpForceOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
1638 *
1639 * @par Lua函数原型
1640 * getTcpForceOffset() -> table
1641 *
1642 * @par JSON-RPC请求示例
1643 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceOffset","params":[],"id":1}
1644 *
1645 * @par JSON-RPC响应示例
1646 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1647 * \endchinese
1648 * \english
1649 * Get the TCP force/torque offset.
1650 *
1651 * @return Returns the TCP force/torque offset.
1652 *
1653 * @throws arcs::common_interface::AuboException
1654 *
1655 * @par Python function prototype
1656 * getTcpForceOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
1657 *
1658 * @par Lua function prototype
1659 * getTcpForceOffset() -> table
1660 *
1661 * @par JSON-RPC request example
1662 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpForceOffset","params":[],"id":1}
1663 *
1664 * @par JSON-RPC response example
1665 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1666 * \endenglish
1667 */
1668 std::vector<double> getTcpForceOffset();
1669
1670 /**
1671 * \chinese
1672 * 获取可用的底座力矩传感器的名字
1673 *
1674 * @return 返回可用的底座力矩传感器的名字
1675 *
1676 * @throws arcs::common_interface::AuboException
1677 *
1678 * @par Python函数原型
1679 * getBaseForceSensorNames(self: pyaubo_sdk.RobotConfig) -> List[str]
1680 *
1681 * @par Lua函数原型
1682 * getBaseForceSensorNames() -> table
1683 *
1684 * @par JSON-RPC请求示例
1685 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getBaseForceSensorNames","params":[],"id":1}
1686 *
1687 * @par JSON-RPC响应示例
1688 * {"id":1,"jsonrpc":"2.0","result":[]}
1689 *
1690 * \endchinese
1691 * \english
1692 * Get the names of available base force sensors.
1693 *
1694 * @return Returns the names of available base force sensors.
1695 *
1696 * @throws arcs::common_interface::AuboException
1697 *
1698 * @par Python function prototype
1699 * getBaseForceSensorNames(self: pyaubo_sdk.RobotConfig) -> List[str]
1700 *
1701 * @par Lua function prototype
1702 * getBaseForceSensorNames() -> table
1703 *
1704 * @par JSON-RPC request example
1705 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getBaseForceSensorNames","params":[],"id":1}
1706 *
1707 * @par JSON-RPC response example
1708 * {"id":1,"jsonrpc":"2.0","result":[]}
1709 *
1710 * \endenglish
1711 */
1712 std::vector<std::string> getBaseForceSensorNames();
1713
1714 /**
1715 * \chinese
1716 * 设置底座力矩传感器
1717 * 如果存在内置的底座力矩传感器,默认将使用内置的力矩传感器
1718 *
1719 * @param name 底座力矩传感器的名字
1720 *
1721 * @return 成功返回0;失败返回错误码
1722 * AUBO_BUSY
1723 * AUBO_BAD_STATE
1724 * -AUBO_INVL_ARGUMENT
1725 * -AUBO_BAD_STATE
1726 *
1727 * @throws arcs::common_interface::AuboException
1728 *
1729 * @par Python函数原型
1730 * selectBaseForceSensor(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
1731 *
1732 * @par Lua函数原型
1733 * selectBaseForceSensor(name: string) -> nil
1734 * \endchinese
1735 * \english
1736 * Set the base force sensor.
1737 * If there is a built-in base force sensor, the built-in sensor will be
1738 * used by default.
1739 *
1740 * @param name Name of the base force sensor.
1741 *
1742 * @return Returns 0 on success; error code on failure.
1743 * AUBO_BUSY
1744 * AUBO_BAD_STATE
1745 * -AUBO_INVL_ARGUMENT
1746 * -AUBO_BAD_STATE
1747 *
1748 * @throws arcs::common_interface::AuboException
1749 *
1750 * @par Python function prototype
1751 * selectBaseForceSensor(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
1752 *
1753 * @par Lua function prototype
1754 * selectBaseForceSensor(name: string) -> nil
1755 * \endenglish
1756 */
1757 int selectBaseForceSensor(const std::string &name);
1758
1759 /**
1760 * \chinese
1761 * 是否安装了底座力矩传感器
1762 *
1763 * @return 安装返回true;没有安装返回false
1764 *
1765 * @throws arcs::common_interface::AuboException
1766 *
1767 * @par Python函数原型
1768 * hasBaseForceSensor(self: pyaubo_sdk.RobotConfig) -> bool
1769 *
1770 * @par Lua函数原型
1771 * hasBaseForceSensor() -> boolean
1772 *
1773 * @par JSON-RPC请求示例
1774 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.hasBaseForceSensor","params":[],"id":1}
1775 *
1776 * @par JSON-RPC响应示例
1777 * {"id":1,"jsonrpc":"2.0","result":false}
1778 *
1779 * \endchinese
1780 * \english
1781 * Whether a base force sensor is installed.
1782 *
1783 * @return Returns true if installed; false otherwise.
1784 *
1785 * @throws arcs::common_interface::AuboException
1786 *
1787 * @par Python function prototype
1788 * hasBaseForceSensor(self: pyaubo_sdk.RobotConfig) -> bool
1789 *
1790 * @par Lua function prototype
1791 * hasBaseForceSensor() -> boolean
1792 *
1793 * @par JSON-RPC request example
1794 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.hasBaseForceSensor","params":[],"id":1}
1795 *
1796 * @par JSON-RPC response example
1797 * {"id":1,"jsonrpc":"2.0","result":false}
1798 *
1799 * \endenglish
1800 */
1802
1803 /**
1804 * \chinese
1805 * 设置底座力矩偏移
1806 *
1807 * @param force_offset 底座力矩偏移
1808 *
1809 * @return 成功返回0;失败返回错误码
1810 * AUBO_BUSY
1811 * AUBO_BAD_STATE
1812 * -AUBO_INVL_ARGUMENT
1813 * -AUBO_BAD_STATE
1814 *
1815 * @throws arcs::common_interface::AuboException
1816 *
1817 * @par Python函数原型
1818 * setBaseForceOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) ->
1819 * int
1820 *
1821 * @par Lua函数原型
1822 * setBaseForceOffset(force_offset: table) -> nil
1823 * \endchinese
1824 * \english
1825 * Set the base force/torque offset.
1826 *
1827 * @param force_offset Base force/torque offset
1828 *
1829 * @return Returns 0 on success; error code on failure
1830 * AUBO_BUSY
1831 * AUBO_BAD_STATE
1832 * -AUBO_INVL_ARGUMENT
1833 * -AUBO_BAD_STATE
1834 *
1835 * @throws arcs::common_interface::AuboException
1836 *
1837 * @par Python function prototype
1838 * setBaseForceOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) ->
1839 * int
1840 *
1841 * @par Lua function prototype
1842 * setBaseForceOffset(force_offset: table) -> nil
1843 * \endenglish
1844 */
1845 int setBaseForceOffset(const std::vector<double> &force_offset);
1846
1847 /**
1848 * \chinese
1849 * 获取底座力矩偏移
1850 *
1851 * @return 返回底座力矩偏移
1852 *
1853 * @throws arcs::common_interface::AuboException
1854 *
1855 * @par Python函数原型
1856 * getBaseForceOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
1857 *
1858 * @par Lua函数原型
1859 * getBaseForceOffset() -> table
1860 *
1861 * @par JSON-RPC请求示例
1862 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getBaseForceOffset","params":[],"id":1}
1863 *
1864 * @par JSON-RPC响应示例
1865 * {"id":1,"jsonrpc":"2.0","result":[]}
1866 *
1867 * \endchinese
1868 * \english
1869 * Get the base force/torque offset.
1870 *
1871 * @return Returns the base force/torque offset.
1872 *
1873 * @throws arcs::common_interface::AuboException
1874 *
1875 * @par Python function prototype
1876 * getBaseForceOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
1877 *
1878 * @par Lua function prototype
1879 * getBaseForceOffset() -> table
1880 *
1881 * @par JSON-RPC request example
1882 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getBaseForceOffset","params":[],"id":1}
1883 *
1884 * @par JSON-RPC response example
1885 * {"id":1,"jsonrpc":"2.0","result":[]}
1886 *
1887 * \endenglish
1888 */
1889 std::vector<double> getBaseForceOffset();
1890
1891 /**
1892 * \chinese
1893 * 获取安全参数校验码 CRC32
1894 *
1895 * @return 返回安全参数校验码
1896 *
1897 * @throws arcs::common_interface::AuboException
1898 *
1899 * @par Python函数原型
1900 * getSafetyParametersCheckSum(self: pyaubo_sdk.RobotConfig) -> int
1901 *
1902 * @par Lua函数原型
1903 * getSafetyParametersCheckSum() -> number
1904 *
1905 * @par JSON-RPC请求示例
1906 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafetyParametersCheckSum","params":[],"id":1}
1907 *
1908 * @par JSON-RPC响应示例
1909 * {"id":1,"jsonrpc":"2.0","result":2033397241}
1910 *
1911 * \endchinese
1912 * \english
1913 * Get the safety parameter checksum CRC32.
1914 *
1915 * @return Returns the safety parameter checksum.
1916 *
1917 * @throws arcs::common_interface::AuboException
1918 *
1919 * @par Python function prototype
1920 * getSafetyParametersCheckSum(self: pyaubo_sdk.RobotConfig) -> int
1921 *
1922 * @par Lua function prototype
1923 * getSafetyParametersCheckSum() -> number
1924 *
1925 * @par JSON-RPC request example
1926 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafetyParametersCheckSum","params":[],"id":1}
1927 *
1928 * @par JSON-RPC response example
1929 * {"id":1,"jsonrpc":"2.0","result":2033397241}
1930 *
1931 * \endenglish
1932 */
1934
1935 /**
1936 * \chinese
1937 * 发起确认安全配置参数请求:
1938 * 将安全配置参数写入到安全接口板flash或文件
1939 *
1940 * @param parameters 安全配置参数
1941 *
1942 * @return 成功返回0;失败返回错误码
1943 * AUBO_BUSY
1944 * AUBO_BAD_STATE
1945 * -AUBO_INVL_ARGUMENT
1946 * -AUBO_BAD_STATE
1947 *
1948 * @throws arcs::common_interface::AuboException
1949 *
1950 * @par Python函数原型
1951 * confirmSafetyParameters(self: pyaubo_sdk.RobotConfig, arg0:
1952 * arcs::common_interface::RobotSafetyParameterRange) -> int
1953 *
1954 * @par Lua函数原型
1955 *
1956 * \endchinese
1957 * \english
1958 * Initiate a request to confirm safety configuration parameters:
1959 * Write safety configuration parameters to the safety interface board flash
1960 * or file.
1961 *
1962 * @param parameters Safety configuration parameters.
1963 *
1964 * @return Returns 0 on success; error code on failure.
1965 * AUBO_BUSY
1966 * AUBO_BAD_STATE
1967 * -AUBO_INVL_ARGUMENT
1968 * -AUBO_BAD_STATE
1969 *
1970 * @throws arcs::common_interface::AuboException
1971 *
1972 * @par Python function prototype
1973 * confirmSafetyParameters(self: pyaubo_sdk.RobotConfig, arg0:
1974 * arcs::common_interface::RobotSafetyParameterRange) -> int
1975 *
1976 * @par Lua function prototype
1977 *
1978 * \endenglish
1979 */
1981
1982 /**
1983 * \chinese
1984 * 计算安全参数的 CRC32 校验值
1985 *
1986 * @return crc32
1987 *
1988 * @throws arcs::common_interface::AuboException
1989 * \endchinese
1990 * \english
1991 * Calculate the CRC32 checksum of safety parameters.
1992 *
1993 * @return crc32
1994 *
1995 * @throws arcs::common_interface::AuboException
1996 * \endenglish
1997 */
1999 const RobotSafetyParameterRange &parameters);
2000
2001 /**
2002 * \chinese
2003 * 获取关节最大位置(物理极限)
2004 *
2005 * @return 返回关节最大位置
2006 *
2007 * @throws arcs::common_interface::AuboException
2008 *
2009 * @par Python函数原型
2010 * getJointMaxPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2011 *
2012 * @par Lua函数原型
2013 * getJointMaxPositions() -> table
2014 *
2015 * @par JSON-RPC请求示例
2016 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxPositions","params":[],"id":1}
2017 *
2018 * @par JSON-RPC响应示例
2019 * {"id":1,"jsonrpc":"2.0","result":[6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586]}
2020 * \endchinese
2021 * \english
2022 * Get the joint maximum positions (physical limits).
2023 *
2024 * @return Returns the joint maximum positions.
2025 *
2026 * @throws arcs::common_interface::AuboException
2027 *
2028 * @par Python function prototype
2029 * getJointMaxPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2030 *
2031 * @par Lua function prototype
2032 * getJointMaxPositions() -> table
2033 *
2034 * @par JSON-RPC request example
2035 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxPositions","params":[],"id":1}
2036 *
2037 * @par JSON-RPC response example
2038 * {"id":1,"jsonrpc":"2.0","result":[6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586,6.283185307179586]}
2039 * \endenglish
2040 */
2041 std::vector<double> getJointMaxPositions();
2042
2043 /**
2044 * \chinese
2045 * 获取关节最小位置(物理极限)
2046 *
2047 * @return 返回关节最小位置
2048 *
2049 * @throws arcs::common_interface::AuboException
2050 *
2051 * @par Python函数原型
2052 * getJointMinPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2053 *
2054 * @par Lua函数原型
2055 * getJointMinPositions() -> table
2056 *
2057 * @par JSON-RPC请求示例
2058 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMinPositions","params":[],"id":1}
2059 *
2060 * @par JSON-RPC响应示例
2061 * {"id":1,"jsonrpc":"2.0","result":[-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586]}
2062 * \endchinese
2063 * \english
2064 * Get the joint minimum positions (physical limits).
2065 *
2066 * @return Returns the joint minimum positions.
2067 *
2068 * @throws arcs::common_interface::AuboException
2069 *
2070 * @par Python function prototype
2071 * getJointMinPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2072 *
2073 * @par Lua function prototype
2074 * getJointMinPositions() -> table
2075 *
2076 * @par JSON-RPC request example
2077 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMinPositions","params":[],"id":1}
2078 *
2079 * @par JSON-RPC response example
2080 * {"id":1,"jsonrpc":"2.0","result":[-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586,-6.283185307179586]}
2081 * \endenglish
2082 */
2083 std::vector<double> getJointMinPositions();
2084
2085 /**
2086 * \chinese
2087 * 获取关节最大速度(物理极限)
2088 *
2089 * @return 返回关节最大速度
2090 *
2091 * @throws arcs::common_interface::AuboException
2092 *
2093 * @par Python函数原型
2094 * getJointMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
2095 *
2096 * @par Lua函数原型
2097 * getJointMaxSpeeds() -> table
2098 *
2099 * @par JSON-RPC请求示例
2100 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxSpeeds","params":[],"id":1}
2101 *
2102 * @par JSON-RPC响应示例
2103 * {"id":1,"jsonrpc":"2.0","result":[3.892084231947355,3.892084231947355,3.892084231947355,3.1066860685499065,3.1066860685499065,3.1066860685499065]}
2104 * \endchinese
2105 * \english
2106 * Get the joint maximum speeds (physical limits).
2107 *
2108 * @return Returns the joint maximum speeds.
2109 *
2110 * @throws arcs::common_interface::AuboException
2111 *
2112 * @par Python function prototype
2113 * getJointMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
2114 *
2115 * @par Lua function prototype
2116 * getJointMaxSpeeds() -> table
2117 *
2118 * @par JSON-RPC request example
2119 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxSpeeds","params":[],"id":1}
2120 *
2121 * @par JSON-RPC response example
2122 * {"id":1,"jsonrpc":"2.0","result":[3.892084231947355,3.892084231947355,3.892084231947355,3.1066860685499065,3.1066860685499065,3.1066860685499065]}
2123 * \endenglish
2124 */
2125 std::vector<double> getJointMaxSpeeds();
2126
2127 /**
2128 * \chinese
2129 * 获取关节最大加速度(物理极限)
2130 *
2131 * @return 返回关节最大加速度
2132 *
2133 * @throws arcs::common_interface::AuboException
2134 *
2135 * @par Python函数原型
2136 * getJointMaxAccelerations(self: pyaubo_sdk.RobotConfig) -> List[float]
2137 *
2138 * @par Lua函数原型
2139 * getJointMaxAccelerations() -> table
2140 *
2141 * @par JSON-RPC请求示例
2142 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxAccelerations","params":[],"id":1}
2143 *
2144 * @par JSON-RPC响应示例
2145 * {"id":1,"jsonrpc":"2.0","result":[31.104877758314785,31.104877758314785,31.104877758314785,20.73625684294463,20.73625684294463,20.73625684294463]}
2146 * \endchinese
2147 * \english
2148 * Get the joint maximum accelerations (physical limits).
2149 *
2150 * @return Returns the joint maximum accelerations.
2151 *
2152 * @throws arcs::common_interface::AuboException
2153 *
2154 * @par Python function prototype
2155 * getJointMaxAccelerations(self: pyaubo_sdk.RobotConfig) -> List[float]
2156 *
2157 * @par Lua function prototype
2158 * getJointMaxAccelerations() -> table
2159 *
2160 * @par JSON-RPC request example
2161 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getJointMaxAccelerations","params":[],"id":1}
2162 *
2163 * @par JSON-RPC response example
2164 * {"id":1,"jsonrpc":"2.0","result":[31.104877758314785,31.104877758314785,31.104877758314785,20.73625684294463,20.73625684294463,20.73625684294463]}
2165 * \endenglish
2166 */
2167 std::vector<double> getJointMaxAccelerations();
2168
2169 /**
2170 * \chinese
2171 * 获取TCP最大速度(物理极限)
2172 *
2173 * @return 返回TCP最大速度
2174 *
2175 * @throws arcs::common_interface::AuboException
2176 *
2177 * @par Python函数原型
2178 * getTcpMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
2179 *
2180 * @par Lua函数原型
2181 * getTcpMaxSpeeds() -> table
2182 *
2183 * @par JSON-RPC请求示例
2184 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpMaxSpeeds","params":[],"id":1}
2185 *
2186 * @par JSON-RPC响应示例
2187 * {"id":1,"jsonrpc":"2.0","result":[2.0,5.0]}
2188 * \endchinese
2189 * \english
2190 * Get the TCP maximum speed (physical limits).
2191 *
2192 * @return Returns the TCP maximum speed.
2193 *
2194 * @throws arcs::common_interface::AuboException
2195 *
2196 * @par Python function prototype
2197 * getTcpMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
2198 *
2199 * @par Lua function prototype
2200 * getTcpMaxSpeeds() -> table
2201 *
2202 * @par JSON-RPC request example
2203 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpMaxSpeeds","params":[],"id":1}
2204 *
2205 * @par JSON-RPC response example
2206 * {"id":1,"jsonrpc":"2.0","result":[2.0,5.0]}
2207 * \endenglish
2208 */
2209 std::vector<double> getTcpMaxSpeeds();
2210
2211 /**
2212 * \chinese
2213 * 获取TCP最大加速度(物理极限)
2214 *
2215 * @return 返回TCP最大加速度
2216 *
2217 * @throws arcs::common_interface::AuboException
2218 *
2219 * @par Python函数原型
2220 * getTcpMaxAccelerations(self: pyaubo_sdk.RobotConfig) -> List[float]
2221 *
2222 * @par Lua函数原型
2223 * getTcpMaxAccelerations() -> table
2224 *
2225 * @par JSON-RPC请求示例
2226 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpMaxAccelerations","params":[],"id":1}
2227 *
2228 * @par JSON-RPC响应示例
2229 * {"id":1,"jsonrpc":"2.0","result":[10.0,10.0]}
2230 *
2231 * \endchinese
2232 * \english
2233 * Get the TCP maximum acceleration (physical limits).
2234 *
2235 * @return Returns the TCP maximum acceleration.
2236 *
2237 * @throws arcs::common_interface::AuboException
2238 *
2239 * @par Python function prototype
2240 * getTcpMaxAccelerations(self: pyaubo_sdk.RobotConfig) -> List[float]
2241 *
2242 * @par Lua function prototype
2243 * getTcpMaxAccelerations() -> table
2244 *
2245 * @par JSON-RPC request example
2246 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpMaxAccelerations","params":[],"id":1}
2247 *
2248 * @par JSON-RPC response example
2249 * {"id":1,"jsonrpc":"2.0","result":[10.0,10.0]}
2250 * \endenglish
2251 */
2252 std::vector<double> getTcpMaxAccelerations();
2253
2254 /**
2255 * \chinese
2256 * 设置机器人安装姿态
2257 *
2258 * @param gravity 安装姿态
2259 *
2260 * @return 成功返回0;失败返回错误码
2261 * AUBO_BUSY
2262 * AUBO_BAD_STATE
2263 * -AUBO_INVL_ARGUMENT
2264 * -AUBO_BAD_STATE
2265 *
2266 * @throws arcs::common_interface::AuboException
2267 *
2268 * @par Python函数原型
2269 * setGravity(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
2270 *
2271 * @par Lua函数原型
2272 * setGravity(gravity: table) -> nil
2273 *
2274 * @par JSON-RPC请求示例
2275 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setGravity","params":[[0.0,0.0,-9.87654321]],"id":1}
2276 *
2277 * @par JSON-RPC响应示例
2278 * {"id":1,"jsonrpc":"2.0","result":0}
2279 * \endchinese
2280 * \english
2281 * Set the robot installation attitude (gravity vector).
2282 *
2283 * @param gravity Installation attitude (gravity vector)
2284 *
2285 * @return Returns 0 on success; error code on failure
2286 * AUBO_BUSY
2287 * AUBO_BAD_STATE
2288 * -AUBO_INVL_ARGUMENT
2289 * -AUBO_BAD_STATE
2290 *
2291 * @throws arcs::common_interface::AuboException
2292 *
2293 * @par Python function prototype
2294 * setGravity(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
2295 *
2296 * @par Lua function prototype
2297 * setGravity(gravity: table) -> nil
2298 *
2299 * @par JSON-RPC request example
2300 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setGravity","params":[[0.0,0.0,-9.87654321]],"id":1}
2301 *
2302 * @par JSON-RPC response example
2303 * {"id":1,"jsonrpc":"2.0","result":0}
2304 * \endenglish
2305 */
2306 int setGravity(const std::vector<double> &gravity);
2307
2308 /**
2309 * \chinese
2310 * 获取机器人的安装姿态
2311 *
2312 * 如果机器人底座安装了姿态传感器,则从传感器读取数据,否则按照用户设置
2313 *
2314 * @return 返回安装姿态
2315 *
2316 * @throws arcs::common_interface::AuboException
2317 *
2318 * @par Python函数原型
2319 * getGravity(self: pyaubo_sdk.RobotConfig) -> List[float]
2320 *
2321 * @par Lua函数原型
2322 * getGravity() -> table
2323 *
2324 * @par JSON-RPC请求示例
2325 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getGravity","params":[],"id":1}
2326 *
2327 * @par JSON-RPC响应示例
2328 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,-9.87654321]}
2329 *
2330 * \endchinese
2331 * \english
2332 * Get the robot's installation attitude (gravity vector).
2333 *
2334 * If the robot base is equipped with an attitude sensor, data is read from
2335 * the sensor; otherwise, the user setting is used.
2336 *
2337 * @return Returns the installation attitude.
2338 *
2339 * @throws arcs::common_interface::AuboException
2340 *
2341 * @par Python function prototype
2342 * getGravity(self: pyaubo_sdk.RobotConfig) -> List[float]
2343 *
2344 * @par Lua function prototype
2345 * getGravity() -> table
2346 *
2347 * @par JSON-RPC request example
2348 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getGravity","params":[],"id":1}
2349 *
2350 * @par JSON-RPC response example
2351 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,-9.87654321]}
2352 *
2353 * \endenglish
2354 */
2355 std::vector<double> getGravity();
2356
2357 /**
2358 * \chinese
2359 * 设置当前的TCP偏移
2360 *
2361 * TCP偏移表示形式为(x,y,z,rx,ry,rz)。
2362 * 其中x、y、z是工具中心点(TCP)在基坐标系下相对于法兰盘中心的位置偏移,单位是m。
2363 * rx、ry、rz是工具中心点(TCP)在基坐标系下相对于法兰盘中心的的姿态偏移,是ZYX欧拉角,单位是rad。
2364 *
2365 * @param offset 当前的TCP偏移,形式为(x,y,z,rx,ry,rz)
2366 *
2367 * @return 成功返回0;失败返回错误码
2368 * AUBO_BUSY
2369 * AUBO_BAD_STATE
2370 * -AUBO_INVL_ARGUMENT
2371 * -AUBO_BAD_STATE
2372 *
2373 * @throws arcs::common_interface::AuboException
2374 *
2375 * @par Python函数原型
2376 * setTcpOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
2377 *
2378 * @par Lua函数原型
2379 * setTcpOffset(offset: table) -> nil
2380 *
2381 * @par JSON-RPC请求示例
2382 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setTcpOffset","params":[[0.0,0.0,0.0,0.0,0.0,0.0]],"id":1}
2383 *
2384 * @par JSON-RPC响应示例
2385 * {"id":1,"jsonrpc":"2.0","result":0}
2386 * \endchinese
2387 * \english
2388 * Set the current TCP offset.
2389 *
2390 * The TCP offset is represented as (x, y, z, rx, ry, rz).
2391 * x, y, z are the position offsets of the Tool Center Point (TCP) relative
2392 * to the flange center in the base coordinate system, in meters. rx, ry, rz
2393 * are the orientation offsets of the TCP relative to the flange center in
2394 * the base coordinate system, as ZYX Euler angles in radians.
2395 *
2396 * @param offset The current TCP offset, in the form (x, y, z, rx, ry, rz)
2397 *
2398 * @return Returns 0 on success; error code on failure
2399 * AUBO_BUSY
2400 * AUBO_BAD_STATE
2401 * -AUBO_INVL_ARGUMENT
2402 * -AUBO_BAD_STATE
2403 *
2404 * @throws arcs::common_interface::AuboException
2405 *
2406 * @par Python function prototype
2407 * setTcpOffset(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> int
2408 *
2409 * @par Lua function prototype
2410 * setTcpOffset(offset: table) -> nil
2411 *
2412 * @par JSON-RPC request example
2413 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.setTcpOffset","params":[[0.0,0.0,0.0,0.0,0.0,0.0]],"id":1}
2414 *
2415 * @par JSON-RPC response example
2416 * {"id":1,"jsonrpc":"2.0","result":0}
2417 * \endenglish
2418 */
2419 int setTcpOffset(const std::vector<double> &offset);
2420
2421 /**
2422 * \chinese
2423 * 获取当前的TCP偏移
2424 *
2425 * TCP偏移表示形式为(x,y,z,rx,ry,rz)。
2426 * 其中x、y、z是工具中心点(TCP)在基坐标系下相对于法兰盘中心的位置偏移,单位是m。
2427 * rx、ry、rz是工具中心点(TCP)在基坐标系下相对于法兰盘中心的的姿态偏移,是ZYX欧拉角,单位是rad。
2428 *
2429 * @return 当前的TCP偏移,形式为(x,y,z,rx,ry,rz)
2430 *
2431 * @throws arcs::common_interface::AuboException
2432 *
2433 * @par Python函数原型
2434 * getTcpOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
2435 *
2436 * @par Lua函数原型
2437 * getTcpOffset() -> table
2438 *
2439 * @par JSON-RPC请求示例
2440 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpOffset","params":[],"id":1}
2441 *
2442 * @par JSON-RPC响应示例
2443 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
2444 * \endchinese
2445 * \english
2446 * Get the current TCP offset.
2447 *
2448 * The TCP offset is represented as (x, y, z, rx, ry, rz).
2449 * x, y, z are the position offsets of the Tool Center Point (TCP) relative
2450 * to the flange center in the base coordinate system, in meters. rx, ry, rz
2451 * are the orientation offsets of the TCP relative to the flange center in
2452 * the base coordinate system, as ZYX Euler angles in radians.
2453 *
2454 * @return The current TCP offset, in the form (x, y, z, rx, ry, rz)
2455 *
2456 * @throws arcs::common_interface::AuboException
2457 *
2458 * @par Python function prototype
2459 * getTcpOffset(self: pyaubo_sdk.RobotConfig) -> List[float]
2460 *
2461 * @par Lua function prototype
2462 * getTcpOffset() -> table
2463 *
2464 * @par JSON-RPC request example
2465 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getTcpOffset","params":[],"id":1}
2466 *
2467 * @par JSON-RPC response example
2468 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
2469 * \endenglish
2470 */
2471 std::vector<double> getTcpOffset();
2472
2473 /**
2474 * \chinese
2475 * 设置工具端质量、质心及惯量
2476 *
2477 * @param m 工具端质量
2478 * @param com 质心
2479 * @param inertial 惯量
2480 *
2481 * @return 成功返回0;失败返回错误码
2482 * AUBO_BUSY
2483 * AUBO_BAD_STATE
2484 * -AUBO_INVL_ARGUMENT
2485 * -AUBO_BAD_STATE
2486 *
2487 * @throws arcs::common_interface::AuboException
2488 *
2489 * @par Python函数原型
2490 * setToolInertial(self: pyaubo_sdk.RobotConfig, arg0: float, arg1:
2491 * List[float], arg2: List[float]) -> int
2492 *
2493 * @par Lua函数原型
2494 * setToolInertial(m: number, com: table, inertial: table) -> nil
2495 * \endchinese
2496 * \english
2497 * Set tool mass, center of mass, and inertia.
2498 *
2499 * @param m Tool mass
2500 * @param com Center of mass
2501 * @param inertial Inertia
2502 *
2503 * @return Returns 0 on success; error code on failure
2504 * AUBO_BUSY
2505 * AUBO_BAD_STATE
2506 * -AUBO_INVL_ARGUMENT
2507 * -AUBO_BAD_STATE
2508 *
2509 * @throws arcs::common_interface::AuboException
2510 *
2511 * @par Python function prototype
2512 * setToolInertial(self: pyaubo_sdk.RobotConfig, arg0: float, arg1:
2513 * List[float], arg2: List[float]) -> int
2514 *
2515 * @par Lua function prototype
2516 * setToolInertial(m: number, com: table, inertial: table) -> nil
2517 * \endenglish
2518 */
2519 int setToolInertial(double m, const std::vector<double> &com,
2520 const std::vector<double> &inertial);
2521
2522 /**
2523 * \chinese
2524 * 设置有效负载
2525 *
2526 * @param m 质量, 单位: kg
2527 * @param cog 重心, 单位: m, 形式为(CoGx, CoGy, CoGz)
2528 * @param aom 力矩轴的方向, 单位: rad, 形式为(rx, ry, rz)
2529 * @param inertia 惯量, 单位: kg*m^2, 形式为(Ixx, Iyy, Izz, Ixy, Ixz,
2530 * Iyz)或(Ixx, Ixy, Ixz, Iyx, Iyy, Iyz, Izx, Izy, Izz)
2531 *
2532 * @return 成功返回0;失败返回错误码
2533 * AUBO_BUSY
2534 * AUBO_BAD_STATE
2535 * -AUBO_INVL_ARGUMENT
2536 * -AUBO_BAD_STATE
2537 *
2538 * @throws arcs::common_interface::AuboException
2539 *
2540 * @par Python函数原型
2541 * setPayload(self: pyaubo_sdk.RobotConfig, arg0: float, arg1: List[float],
2542 * arg2: List[float], arg3: List[float]) -> int
2543 *
2544 * @par Lua函数原型
2545 * setPayload(m: number, cog: table, aom: table, inertia: table) -> nil
2546 *
2547 * @par Lua示例
2548 * setPayload(3, {0,0,0}, {0,0,0}, {0,0,0,0,0,0,0,0,0})
2549 *
2550 * @par JSON-RPC请求示例
2551 * {"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}
2552 *
2553 * @par JSON-RPC响应示例
2554 * {"id":1,"jsonrpc":"2.0","result":0}
2555 * \endchinese
2556 * \english
2557 * Set the payload.
2558 *
2559 * @param m Mass, unit: kg
2560 * @param cog Center of gravity, unit: m, format (CoGx, CoGy, CoGz)
2561 * @param aom Axis of moment, unit: rad, format (rx, ry, rz)
2562 * @param inertia Inertia, unit: kg*m^2, format (Ixx, Iyy, Izz, Ixy, Ixz,
2563 * Iyz) or (Ixx, Ixy, Ixz, Iyx, Iyy, Iyz, Izx, Izy, Izz)
2564 *
2565 * @return Returns 0 on success; error code on failure
2566 * AUBO_BUSY
2567 * AUBO_BAD_STATE
2568 * -AUBO_INVL_ARGUMENT
2569 * -AUBO_BAD_STATE
2570 *
2571 * @throws arcs::common_interface::AuboException
2572 *
2573 * @par Python function prototype
2574 * setPayload(self: pyaubo_sdk.RobotConfig, arg0: float, arg1: List[float],
2575 * arg2: List[float], arg3: List[float]) -> int
2576 *
2577 * @par Lua function prototype
2578 * setPayload(m: number, cog: table, aom: table, inertia: table) -> nil
2579 *
2580 * @par Lua example
2581 * setPayload(3, {0,0,0}, {0,0,0}, {0,0,0,0,0,0,0,0,0})
2582 *
2583 * @par JSON-RPC request example
2584 * {"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}
2585 *
2586 * @par JSON-RPC response example
2587 * {"id":1,"jsonrpc":"2.0","result":0}
2588 * \endenglish
2589 */
2590 int setPayload(double m, const std::vector<double> &cog,
2591 const std::vector<double> &aom,
2592 const std::vector<double> &inertia);
2593
2594 /**
2595 * \chinese
2596 * 获取有效负载
2597 *
2598 * @return 有效负载.
2599 * 第一个元素表示质量, 单位: kg;
2600 * 第二个元素表示重心, 单位: m, 形式为(CoGx, CoGy, CoGz);
2601 * 第三个元素表示力矩轴的方向, 单位: rad, 形式为(rx, ry, rz);
2602 * 第四个元素表示惯量, 单位: kg*m^2, 形式为(Ixx, Iyy, Izz, Ixy, Ixz, Iyz)
2603 *
2604 * @throws arcs::common_interface::AuboException
2605 *
2606 * @par Python函数原型
2607 * getPayload(self: pyaubo_sdk.RobotConfig) -> Tuple[float, List[float],
2608 * List[float], List[float]]
2609 *
2610 * @par Lua函数原型
2611 * getPayload() -> number, table, table, table
2612 *
2613 * @par Lua示例
2614 * m, cog, aom, inertia = getPayload()
2615 *
2616 * @par JSON-RPC请求示例
2617 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getPayload","params":[],"id":1}
2618 *
2619 * @par JSON-RPC响应示例
2620 * {"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]]}
2621 * \endchinese
2622 * \english
2623 * Get the payload.
2624 *
2625 * @return The payload.
2626 * The first element is the mass in kg;
2627 * The second element is the center of gravity in meters, format (CoGx,
2628 * CoGy, CoGz); The third element is the axis of moment in radians, format
2629 * (rx, ry, rz); The fourth element is the inertia in kg*m^2, format (Ixx,
2630 * Iyy, Izz, Ixy, Ixz, Iyz)
2631 *
2632 * @throws arcs::common_interface::AuboException
2633 *
2634 * @par Python function prototype
2635 * getPayload(self: pyaubo_sdk.RobotConfig) -> Tuple[float, List[float],
2636 * List[float], List[float]]
2637 *
2638 * @par Lua function prototype
2639 * getPayload() -> number, table, table, table
2640 *
2641 * @par Lua example
2642 * m, cog, aom, inertia = getPayload()
2643 *
2644 * @par JSON-RPC request example
2645 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getPayload","params":[],"id":1}
2646 *
2647 * @par JSON-RPC response example
2648 * {"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]]}
2649 * \endenglish
2650 */
2652
2653 /**
2654 * \chinese
2655 * 末端位姿是否在安全范围之内
2656 *
2657 * @param pose 末端位姿
2658 * @return 在安全范围内返回true; 反之返回false
2659 *
2660 * @throws arcs::common_interface::AuboException
2661 *
2662 * @par Python函数原型
2663 * toolSpaceInRange(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> bool
2664 *
2665 * @par Lua函数原型
2666 * toolSpaceInRange(pose: table) -> boolean
2667 *
2668 * @par JSON-RPC请求示例
2669 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.toolSpaceInRange","params":[[0.58712,
2670 * -0.15775, 0.48703, 2.76, 0.344, 1.432]],"id":1}
2671 *
2672 * @par JSON-RPC响应示例
2673 * {"id":1,"jsonrpc":"2.0","result":true}
2674 * \endchinese
2675 * \english
2676 * Whether the end-effector pose is within the safety range.
2677 *
2678 * @param pose End-effector pose
2679 * @return Returns true if within the safety range; otherwise returns false
2680 *
2681 * @throws arcs::common_interface::AuboException
2682 *
2683 * @par Python function prototype
2684 * toolSpaceInRange(self: pyaubo_sdk.RobotConfig, arg0: List[float]) -> bool
2685 *
2686 * @par Lua function prototype
2687 * toolSpaceInRange(pose: table) -> boolean
2688 *
2689 * @par JSON-RPC request example
2690 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.toolSpaceInRange","params":[[0.58712,
2691 * -0.15775, 0.48703, 2.76, 0.344, 1.432]],"id":1}
2692 *
2693 * @par JSON-RPC response example
2694 * {"id":1,"jsonrpc":"2.0","result":true}
2695 * \endenglish
2696 */
2697 bool toolSpaceInRange(const std::vector<double> &pose);
2698
2699 /**
2700 * \chinese
2701 * 发起固件升级请求,控制器软件将进入固件升级模式
2702 *
2703 * @param fw 固件升级路径。该路径的格式为: 固件安装包路径\#升级节点列表。
2704 * 其中固件安装包路径和升级节点列表以井号(#)分隔,升级节点以逗号(,)分隔。
2705 * 如果节点名称后带有!,则表示强制(不带版本校验)升级该节点;
2706 * 反之,则表示带校验版本地升级节点,
2707 * 即在升级该节点前,会先判断当前版本和目标版本是否相同,如果相同就不升级该节点。\n
2708 * 可以根据实际需求灵活设置需要升级的节点。\n
2709 * 例如,
2710 * /tmp/firmware_update-1.0.42-rc.5+2347b0d.firm\#master_mcu!,slace_mcu!,
2711 * base!,tool!,joint1!,joint2!,joint3!,joint4!,joint5!,joint6!
2712 * 表示强制升级接口板主板、接口板从板、基座、工具和6个关节(joint1至joint6)。\n
2713 * all表示所有的节点,例如
2714 * /tmp/firm_XXX.firm\#all 表示带校验版本地升级全部节点,
2715 * /tmp/firm_XXX.firm\#all!表示强制升级全部节点
2716 *
2717 * @return 指令下发成功返回0; 失败返回错误码。 \n
2718 * -AUBO_BAD_STATE: 运行时(RuntimeMachine)的当前状态不是Stopped,
2719 * 固件升级请求被拒绝。AUBO_BAD_STATE的值是1。 \n
2720 * -AUBO_TIMEOUT: 超时。AUBO_TIMEOUT的值是4。 \n
2721 *
2722 * @throws arcs::common_interface::AuboException
2723 *
2724 * @par Python函数原型
2725 * firmwareUpdate(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
2726 *
2727 * @par Lua函数原型
2728 * firmwareUpdate(fw: string) -> nil
2729 *
2730 * @par JSON-RPC请求示例
2731 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.firmwareUpdate","params":["/tmp/firmware_update-1.0.42-rc.12+3e33eac.firm#master_mcu"],"id":1}
2732 *
2733 * @par JSON-RPC响应示例
2734 * {"id":1,"jsonrpc":"2.0","result":0}
2735 * \endchinese
2736 * \english
2737 * Initiate a firmware upgrade request. The controller software will enter
2738 * firmware upgrade mode.
2739 *
2740 * @param fw Firmware upgrade path. The format is: firmware package
2741 * path\#upgrade node list. The firmware package path and node list are
2742 * separated by a hash (#), and nodes are separated by commas (,). If a node
2743 * name ends with !, it means to force upgrade (without version check) that
2744 * node; otherwise, the node will be upgraded only if the current version
2745 * differs from the target version. You can flexibly specify which nodes to
2746 * upgrade as needed. For example,
2747 * /tmp/firmware_update-1.0.42-rc.5+2347b0d.firm#master_mcu!,slace_mcu!,base!,tool!,joint1!,joint2!,joint3!,joint4!,joint5!,joint6!
2748 * means to force upgrade the interface board main, interface board slave,
2749 * base, tool, and joints 1-6. "all" means all nodes, e.g.
2750 * /tmp/firm_XXX.firm#all means upgrade all nodes with version check,
2751 * /tmp/firm_XXX.firm#all! means force upgrade all nodes.
2752 *
2753 * @return Returns 0 if the command is sent successfully; otherwise, returns
2754 * an error code. -AUBO_BAD_STATE: The current state of the RuntimeMachine
2755 * is not Stopped, so the firmware upgrade request is rejected.
2756 * AUBO_BAD_STATE = 1. -AUBO_TIMEOUT: Timeout. AUBO_TIMEOUT = 4.
2757 *
2758 * @throws arcs::common_interface::AuboException
2759 *
2760 * @par Python function prototype
2761 * firmwareUpdate(self: pyaubo_sdk.RobotConfig, arg0: str) -> int
2762 *
2763 * @par Lua function prototype
2764 * firmwareUpdate(fw: string) -> nil
2765 *
2766 * @par JSON-RPC request example
2767 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.firmwareUpdate","params":["/tmp/firmware_update-1.0.42-rc.12+3e33eac.firm#master_mcu"],"id":1}
2768 *
2769 * @par JSON-RPC response example
2770 * {"id":1,"jsonrpc":"2.0","result":0}
2771 * \endenglish
2772 */
2773 int firmwareUpdate(const std::string &fw);
2774
2775 /**
2776 * \chinese
2777 * 获取当前的固件升级的进程
2778 *
2779 * @return 当前的固件升级进程。 \n
2780 * 第一个元素表示步骤名称。如果是failed,则表示固件升级失败 \n
2781 * 第二个元素表示升级的进度(0~1),完成之后,返回("", 1)
2782 *
2783 * @throws arcs::common_interface::AuboException
2784 *
2785 * @par Python函数原型
2786 * getFirmwareUpdateProcess(self: pyaubo_sdk.RobotConfig) -> Tuple[str,
2787 * float]
2788 *
2789 * @par Lua函数原型
2790 * getFirmwareUpdateProcess() -> table
2791 *
2792 * @par JSON-RPC请求示例
2793 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getFirmwareUpdateProcess","params":[],"id":1}
2794 *
2795 * @par JSON-RPC响应示例
2796 * {"id":1,"jsonrpc":"2.0","result":[" ",0.0]}
2797 *
2798 * \endchinese
2799 * \english
2800 * Get the current firmware upgrade process.
2801 *
2802 * @return The current firmware upgrade process. \n
2803 * The first element is the step name. If it is "failed", the firmware
2804 * upgrade failed. \n The second element is the upgrade progress (0~1). When
2805 * finished, returns ("", 1)
2806 *
2807 * @throws arcs::common_interface::AuboException
2808 *
2809 * @par Python function prototype
2810 * getFirmwareUpdateProcess(self: pyaubo_sdk.RobotConfig) -> Tuple[str,
2811 * float]
2812 *
2813 * @par Lua function prototype
2814 * getFirmwareUpdateProcess() -> table
2815 *
2816 * @par JSON-RPC request example
2817 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getFirmwareUpdateProcess","params":[],"id":1}
2818 *
2819 * @par JSON-RPC response example
2820 * {"id":1,"jsonrpc":"2.0","result":[" ",0.0]}
2821 *
2822 * \endenglish
2823 */
2824 std::tuple<std::string, double> getFirmwareUpdateProcess();
2825
2826 /**
2827 * \chinese
2828 * 获取关节最大位置(当前正在使用的限制值)
2829 *
2830 * @return 返回关节最大位置(当前正在使用的限制值)
2831 *
2832 * @throws arcs::common_interface::AuboException
2833 *
2834 * @par Python函数原型
2835 * getLimitJointMaxPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2836 *
2837 * @par Lua函数原型
2838 * getLimitJointMaxPositions() -> table
2839 *
2840 * @par JSON-RPC请求示例
2841 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxPositions","params":[],"id":1}
2842 *
2843 * @par JSON-RPC响应示例
2844 * {"id":1,"jsonrpc":"2.0","result":[6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465]}
2845 * \endchinese
2846 * \english
2847 * Get the joint maximum positions (currently used limit values).
2848 *
2849 * @return Returns the joint maximum positions (currently used limit
2850 * values).
2851 *
2852 * @throws arcs::common_interface::AuboException
2853 *
2854 * @par Python function prototype
2855 * getLimitJointMaxPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2856 *
2857 * @par Lua function prototype
2858 * getLimitJointMaxPositions() -> table
2859 *
2860 * @par JSON-RPC request example
2861 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxPositions","params":[],"id":1}
2862 *
2863 * @par JSON-RPC response example
2864 * {"id":1,"jsonrpc":"2.0","result":[6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465,6.2831854820251465]}
2865 * \endenglish
2866 */
2867 std::vector<double> getLimitJointMaxPositions();
2868
2869 /**
2870 * \chinese
2871 * 获取关节最小位置(当前正在使用的限制值)
2872 *
2873 * @return 返回关节最小位置(当前正在使用的限制值)
2874 *
2875 * @throws arcs::common_interface::AuboException
2876 *
2877 * @par Python函数原型
2878 * getLimitJointMinPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2879 *
2880 * @par Lua函数原型
2881 * getLimitJointMinPositions() -> table
2882 *
2883 * @par JSON-RPC请求示例
2884 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMinPositions","params":[],"id":1}
2885 *
2886 * @par JSON-RPC响应示例
2887 * {"id":1,"jsonrpc":"2.0","result":[-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465]}
2888 * \endchinese
2889 * \english
2890 * Get the joint minimum positions (currently used limit values).
2891 *
2892 * @return Returns the joint minimum positions (currently used limit
2893 * values).
2894 *
2895 * @throws arcs::common_interface::AuboException
2896 *
2897 * @par Python function prototype
2898 * getLimitJointMinPositions(self: pyaubo_sdk.RobotConfig) -> List[float]
2899 *
2900 * @par Lua function prototype
2901 * getLimitJointMinPositions() -> table
2902 *
2903 * @par JSON-RPC request example
2904 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMinPositions","params":[],"id":1}
2905 *
2906 * @par JSON-RPC response example
2907 * {"id":1,"jsonrpc":"2.0","result":[-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465,-6.2831854820251465]}
2908 * \endenglish
2909 */
2910 std::vector<double> getLimitJointMinPositions();
2911
2912 /**
2913 * \chinese
2914 * 获取关节最大速度(当前正在使用的限制值)
2915 *
2916 * @return 返回关节最大速度(当前正在使用的限制值)
2917 *
2918 * @throws arcs::common_interface::AuboException
2919 *
2920 * @par Python函数原型
2921 * getLimitJointMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
2922 *
2923 * @par Lua函数原型
2924 * getLimitJointMaxSpeeds() -> table
2925 *
2926 * @par JSON-RPC请求示例
2927 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxSpeeds","params":[],"id":1}
2928 *
2929 * @par JSON-RPC响应示例
2930 * {"id":1,"jsonrpc":"2.0","result":[3.8920841217041016,3.8920841217041016,3.8920841217041016,3.1066861152648926,3.1066861152648926,3.1066861152648926]}
2931 * \endchinese
2932 * \english
2933 * Get the joint maximum speeds (currently used limit values).
2934 *
2935 * @return Returns the joint maximum speeds (currently used limit values).
2936 *
2937 * @throws arcs::common_interface::AuboException
2938 *
2939 * @par Python function prototype
2940 * getLimitJointMaxSpeeds(self: pyaubo_sdk.RobotConfig) -> List[float]
2941 *
2942 * @par Lua function prototype
2943 * getLimitJointMaxSpeeds() -> table
2944 *
2945 * @par JSON-RPC request example
2946 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxSpeeds","params":[],"id":1}
2947 *
2948 * @par JSON-RPC response example
2949 * {"id":1,"jsonrpc":"2.0","result":[3.8920841217041016,3.8920841217041016,3.8920841217041016,3.1066861152648926,3.1066861152648926,3.1066861152648926]}
2950 * \endenglish
2951 */
2952 std::vector<double> getLimitJointMaxSpeeds();
2953
2954 /**
2955 * \chinese
2956 * 获取关节最大加速度(当前正在使用的限制值)
2957 *
2958 * @return 返回关节最大加速度(当前正在使用的限制值)
2959 *
2960 * @throws arcs::common_interface::AuboException
2961 *
2962 * @par Python函数原型
2963 * getLimitJointMaxAccelerations(self: pyaubo_sdk.RobotConfig) ->
2964 * List[float]
2965 *
2966 * @par Lua函数原型
2967 * getLimitJointMaxAccelerations() -> table
2968 *
2969 * @par JSON-RPC请求示例
2970 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxAccelerations","params":[],"id":1}
2971 *
2972 * @par JSON-RPC响应示例
2973 * {"id":1,"jsonrpc":"2.0","result":[31.104877758314785,31.104877758314785,31.104877758314785,20.73625684294463,20.73625684294463,20.73625684294463]}
2974 * \endchinese
2975 * \english
2976 * Get the joint maximum accelerations (currently used limit values).
2977 *
2978 * @return Returns the joint maximum accelerations (currently used limit
2979 * values).
2980 *
2981 * @throws arcs::common_interface::AuboException
2982 *
2983 * @par Python function prototype
2984 * getLimitJointMaxAccelerations(self: pyaubo_sdk.RobotConfig) ->
2985 * List[float]
2986 *
2987 * @par Lua function prototype
2988 * getLimitJointMaxAccelerations() -> table
2989 *
2990 * @par JSON-RPC request example
2991 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitJointMaxAccelerations","params":[],"id":1}
2992 *
2993 * @par JSON-RPC response example
2994 * {"id":1,"jsonrpc":"2.0","result":[31.104877758314785,31.104877758314785,31.104877758314785,20.73625684294463,20.73625684294463,20.73625684294463]}
2995 * \endenglish
2996 */
2997 std::vector<double> getLimitJointMaxAccelerations();
2998
2999 /**
3000 * \chinese
3001 * 获取TCP最大速度(当前正在使用的限制值)
3002 *
3003 * @return 返回TCP最大速度(当前正在使用的限制值)
3004 *
3005 * @throws arcs::common_interface::AuboException
3006 *
3007 * @par Python函数原型
3008 * getLimitTcpMaxSpeed(self: pyaubo_sdk.RobotConfig) -> List[float]
3009 *
3010 * @par Lua函数原型
3011 * getLimitTcpMaxSpeed() -> table
3012 *
3013 * @par JSON-RPC请求示例
3014 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitTcpMaxSpeed","params":[],"id":1}
3015 *
3016 * @par JSON-RPC响应示例
3017 * {"id":1,"jsonrpc":"2.0","result":2.0}
3018 * \endchinese
3019 * \english
3020 * Get the TCP maximum speed (currently used limit value).
3021 *
3022 * @return Returns the TCP maximum speed (currently used limit value).
3023 *
3024 * @throws arcs::common_interface::AuboException
3025 *
3026 * @par Python function prototype
3027 * getLimitTcpMaxSpeed(self: pyaubo_sdk.RobotConfig) -> List[float]
3028 *
3029 * @par Lua function prototype
3030 * getLimitTcpMaxSpeed() -> table
3031 *
3032 * @par JSON-RPC request example
3033 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getLimitTcpMaxSpeed","params":[],"id":1}
3034 *
3035 * @par JSON-RPC response example
3036 * {"id":1,"jsonrpc":"2.0","result":2.0}
3037 * \endenglish
3038 */
3040
3041 /**
3042 * \chinese
3043 * 获取当前安全停止的类型
3044 *
3045 * @return 返回当前安全停止的类型
3046 *
3047 * @par JSON-RPC请求示例
3048 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafeguardStopType","params":[],"id":1}
3049 *
3050 * @par JSON-RPC响应示例
3051 * {"id":1,"jsonrpc":"2.0","result":"None"}
3052 * \endchinese
3053 * \english
3054 * Get the current safeguard stop type.
3055 *
3056 * @return Returns the current safeguard stop type.
3057 *
3058 * @par JSON-RPC request example
3059 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafeguardStopType","params":[],"id":1}
3060 *
3061 * @par JSON-RPC response example
3062 * {"id":1,"jsonrpc":"2.0","result":"None"}
3063 * \endenglish
3064 */
3066
3067 /**
3068 * \chinese
3069 * 按位获取完整的安全停止触发源
3070 *
3071 * @return 返回所有安全停止触发源
3072 *
3073 * 安全停止的原因:
3074 * 手动模式下可配置安全IO触发的安全停止 - 1<<0
3075 * 自动模式下可配置安全IO触发的安全停止 - 1<<1
3076 * 控制柜SI输入触发的安全停止 - 1<<2
3077 * 示教器三态开关触发的安全停止 - 1<<3
3078 * 自动切手动触发的安全停止 - 1<<4
3079 *
3080 * @par JSON-RPC请求示例
3081 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafeguardStopSource","params":[],"id":1}
3082 *
3083 * @par JSON-RPC响应示例
3084 * {"id":1,"jsonrpc":"2.0","result":0}
3085 * \endchinese
3086 * \english
3087 * Get the complete safeguard stop source as a bitmask.
3088 *
3089 * @return Returns all safeguard stop sources.
3090 *
3091 * Reasons for safeguard stop:
3092 * Safeguard stop triggered by configurable safety IO in manual mode - 1<<0
3093 * Safeguard stop triggered by configurable safety IO in automatic mode -
3094 * 1<<1 Safeguard stop triggered by control box SI input - 1<<2 Safeguard
3095 * stop triggered by teach pendant three-position switch - 1<<3 Safeguard
3096 * stop triggered by switching from auto to manual - 1<<4
3097 *
3098 * @par JSON-RPC request example
3099 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSafeguardStopSource","params":[],"id":1}
3100 *
3101 * @par JSON-RPC response example
3102 * {"id":1,"jsonrpc":"2.0","result":0}
3103 * \endenglish
3104 */
3106
3107 /**
3108 * \chinese
3109 * 按位获取完整的机器人紧急停止触发源
3110 *
3111 * @return 返回所有机器人紧急停止触发源
3112 *
3113 * 紧急停止的原因:
3114 * 控制柜紧急停止按钮触发 - 1<<0
3115 * 示教器紧急停止按钮触发 - 1<<1
3116 * 手柄紧急停止按钮触发 - 1<<2
3117 * 固定IO紧急停止触发 - 1<<3
3118 *
3119 * @par JSON-RPC请求示例
3120 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotEmergencyStopSource","params":[],"id":1}
3121 *
3122 * @par JSON-RPC响应示例
3123 * {"id":1,"jsonrpc":"2.0","result":0}
3124 * \endchinese
3125 * \english
3126 * Get the complete robot emergency stop source as a bitmask.
3127 *
3128 * @return Returns all robot emergency stop sources.
3129 *
3130 * Reasons for emergency stop:
3131 * Emergency stop triggered by control box button - 1<<0
3132 * Emergency stop triggered by teach pendant button - 1<<1
3133 * Emergency stop triggered by handle button - 1<<2
3134 * Emergency stop triggered by fixed IO - 1<<3
3135 *
3136 * @par JSON-RPC request example
3137 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getRobotEmergencyStopSource","params":[],"id":1}
3138 *
3139 * @par JSON-RPC response example
3140 * {"id":1,"jsonrpc":"2.0","result":0}
3141 * \endenglish
3142 */
3144
3145 /**
3146 * \chinese
3147 * 获取工具端力矩传感器的名字
3148 *
3149 * @return 当前工具端力矩传感器名字
3150 *
3151 * @throws arcs::common_interface::AuboException
3152 *
3153 * @par Python函数原型
3154 * getSelectedTcpForceSensorName(self: pyaubo_sdk.RobotConfig) -> str
3155 *
3156 * @par Lua函数原型
3157 * getSelectedTcpForceSensorName() -> str
3158 *
3159 * @par JSON-RPC请求示例
3160 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSelectedTcpForceSensorName","params":[],"id":1}
3161 * \endchinese
3162 * \english
3163 * Get the name of the selected TCP force sensor.
3164 *
3165 * @return The name of the currently selected TCP force sensor.
3166 *
3167 * @throws arcs::common_interface::AuboException
3168 *
3169 * @par Python function prototype
3170 * getSelectedTcpForceSensorName(self: pyaubo_sdk.RobotConfig) -> str
3171 *
3172 * @par Lua function prototype
3173 * getSelectedTcpForceSensorName() -> str
3174 *
3175 * @par JSON-RPC request example
3176 * {"jsonrpc":"2.0","method":"rob1.RobotConfig.getSelectedTcpForceSensorName","params":[],"id":1}
3177 * \endenglish
3178 */
3180
3181protected:
3182 void *d_;
3183};
3184using RobotConfigPtr = std::shared_ptr<RobotConfig>;
3185
3186} // namespace common_interface
3187} // namespace arcs
3188#endif // AUBO_SDK_ROBOT_CONFIG_H
double getDefaultJointSpeed()
获取默认的关节速度,单位rad/s
double getDefaultJointAcc()
获取默认的关节加速度,单位rad/s^2
int setHandguidDamp(const std::vector< double > &damp)
设置混合拖动阻尼
int getSafeguardStopSource()
按位获取完整的安全停止触发源
std::string getHardwareCustomParameters(const std::string &param)
获取硬件抽象层自定义参数
bool hasBaseForceSensor()
是否安装了底座力矩传感器
std::string getName()
获取机器人的名字
int setBaseForceOffset(const std::vector< double > &force_offset)
设置底座力矩偏移
int setKinematicsCompensate(const std::unordered_map< std::string, std::vector< double > > &param)
设置标准 DH 补偿到机器人
int selectTcpForceSensor(const std::string &name)
设置末端力矩传感器 如果存在内置的末端力矩传感器,默认将使用内置的力矩传感器
std::vector< double > getTcpForceSensorPose()
获取传感器安装位姿
std::vector< double > getJointMinPositions()
获取关节最小位置(物理极限)
std::vector< double > getLimitJointMaxPositions()
获取关节最大位置(当前正在使用的限制值)
int setWorkObjectData(const WObjectData &wobj)
设置工件数据,编程点位都是基于工件坐标系
std::unordered_map< std::string, std::vector< double > > getKinematicsParam(bool real)
获取机器人DH参数 alpha a d theta beta
std::vector< double > getJointMaxSpeeds()
获取关节最大速度(物理极限)
int setPersistentParameters(const std::string &param)
设置需要保存到接口板底座的参数
double getLimitTcpMaxSpeed()
获取TCP最大速度(当前正在使用的限制值)
int setCollisionLevel(int level)
设置碰撞灵敏度等级 数值越大越灵敏
int getRobotEmergencyStopSource()
按位获取完整的机器人紧急停止触发源
int setHardwareCustomParameters(const std::string &param)
设置硬件抽象层自定义参数 目的是为了做不同硬件之间的兼容
uint32_t calcSafetyParametersCheckSum(const RobotSafetyParameterRange &parameters)
计算安全参数的 CRC32 校验值
std::vector< double > getLimitJointMinPositions()
获取关节最小位置(当前正在使用的限制值)
int setTcpForceOffset(const std::vector< double > &force_offset)
设置末端力矩偏移
std::vector< std::string > getTcpForceSensorNames()
获取可用的末端力矩传感器的名字
std::vector< double > getHomePosition()
获取机器人的原点位置
double getDefaultToolSpeed()
获取默认的工具端速度,单位m/s
Payload getPayload()
获取有效负载
std::string getRobotSubType()
获取机器人子类型代码
int getCollisionLevel()
获取碰撞灵敏度等级
std::vector< double > getTcpForceOffset()
获取末端力矩偏移
std::vector< double > getFreedriveDamp()
获取拖动阻尼
std::vector< double > getJointMaxPositions()
获取关节最大位置(物理极限)
int setTcpForceSensorPose(const std::vector< double > &sensor_pose)
设置传感器安装位姿
std::unordered_map< std::string, std::vector< double > > getKinematicsCompensate(double ref_temperature)
获取指定温度下的DH参数补偿值:alpha a d theta beta
bool toolSpaceInRange(const std::vector< double > &pose)
末端位姿是否在安全范围之内
int setGravity(const std::vector< double > &gravity)
设置机器人安装姿态
SafeguedStopType getSafeguardStopType()
获取当前安全停止的类型
int setMountingPose(const std::vector< double > &pose)
设置安装位姿(机器人的基坐标系相对于世界坐标系) world->base
std::vector< double > getBaseForceOffset()
获取底座力矩偏移
std::vector< double > getTcpOffset()
获取当前的TCP偏移
int getDof()
获取机器人的自由度(从硬件抽象层读取)
int getCollisionStopType()
获取碰撞停止类型
int setHomePosition(const std::vector< double > &positions)
设置机器人的原点位置
double getCycletime()
获取机器人的伺服控制周期(从硬件抽象层读取)
std::string getControlBoxType()
获取控制柜类型代码
std::vector< std::string > getBaseForceSensorNames()
获取可用的底座力矩传感器的名字
double getSlowDownFraction(int level)
获取预设的缓速模式下的速度缩减比例
std::vector< double > getMountingPose()
获取安装位姿(机器人的基坐标系相对于世界坐标系)
std::vector< double > getLimitJointMaxAccelerations()
获取关节最大加速度(当前正在使用的限制值)
std::vector< double > getTcpMaxAccelerations()
获取TCP最大加速度(物理极限)
std::tuple< std::string, double > getFirmwareUpdateProcess()
获取当前的固件升级的进程
int setRobotZero()
设置机器人关节零位
int setSlowDownFraction(int level, double fraction)
预设缓速模式下的速度缩减比例
int firmwareUpdate(const std::string &fw)
发起固件升级请求,控制器软件将进入固件升级模式
std::string getSelectedTcpForceSensorName()
获取工具端力矩传感器的名字
std::vector< double > getLimitJointMaxSpeeds()
获取关节最大速度(当前正在使用的限制值)
double getDefaultToolAcc()
获取默认的工具端加速度,单位m/s^2
std::vector< double > getGravity()
获取机器人的安装姿态
int selectBaseForceSensor(const std::string &name)
设置底座力矩传感器 如果存在内置的底座力矩传感器,默认将使用内置的力矩传感器
std::string getRobotType()
获取机器人类型代码
int confirmSafetyParameters(const RobotSafetyParameterRange &parameters)
发起确认安全配置参数请求: 将安全配置参数写入到安全接口板flash或文件
bool hasTcpForceSensor()
是否安装了末端力矩传感器
std::vector< double > getJointMaxAccelerations()
获取关节最大加速度(物理极限)
int setCollisionStopType(int type)
设置碰撞停止类型
int setPayload(double m, const std::vector< double > &cog, const std::vector< double > &aom, const std::vector< double > &inertia)
设置有效负载
uint32_t getSafetyParametersCheckSum()
获取安全参数校验码 CRC32
int setToolInertial(double m, const std::vector< double > &com, const std::vector< double > &inertial)
设置工具端质量、质心及惯量
int setFreedriveDamp(const std::vector< double > &damp)
设置拖动阻尼
std::vector< double > getTcpMaxSpeeds()
获取TCP最大速度(物理极限)
int setTcpOffset(const std::vector< double > &offset)
设置当前的TCP偏移
std::vector< double > getHandguidDamp()
获取混合拖动阻尼
int attachRobotBaseTo(const std::string &frame)
将机器人绑定到一个坐标系,如果这个坐标系是运动的,那机器人也会跟着运动 应用于地轨或者龙门 这个函数调用的时候 frame 和 ROBOTBASE 的相对关系就固定了
std::shared_ptr< RobotConfig > RobotConfigPtr
std::tuple< double, std::vector< double >, std::vector< double >, std::vector< double > > Payload
Definition type_def.h:767
数据类型的定义