AUBO SDK  0.25.0
载入中...
搜索中...
未找到
robot_state.h
浏览该文件的文档.
1/** @file robot_state.h
2 * @brief 获取机器人状态接口,如关节速度、关节角度、固件/硬件版本
3 */
4#ifndef AUBO_SDK_ROBOT_STATE_INTERFACE_H
5#define AUBO_SDK_ROBOT_STATE_INTERFACE_H
6
7#include <vector>
8
9#include <aubo/global_config.h>
10#include <aubo/type_def.h>
11
12namespace arcs {
13namespace common_interface {
14
15class ARCS_ABI_EXPORT RobotState
16{
17public:
19 virtual ~RobotState();
20
21 /**
22 * \chinese
23 * 获取机器人的模式状态
24 *
25 * @return 机器人的模式状态
26 *
27 * @throws arcs::common_interface::AuboException
28 *
29 * @par Python函数原型
30 * getRobotModeType(self: pyaubo_sdk.RobotState) ->
31 * arcs::common_interface::RobotModeType
32 *
33 * @par Lua函数原型
34 * getRobotModeType() -> number
35 *
36 * @par JSON-RPC请求示例
37 * {"jsonrpc":"2.0","method":"rob1.RobotState.getRobotModeType","params":[],"id":1}
38 *
39 * @par JSON-RPC响应示例
40 * {"id":1,"jsonrpc":"2.0","result":"Running"}
41 *
42 *\endchinese
43 *\english
44 * Get the robot mode state
45 *
46 * @return The robot's mode state
47 *
48 * @throws arcs::common_interface::AuboException
49 *
50 * @par Python function prototype
51 * getRobotModeType(self: pyaubo_sdk.RobotState) ->
52 * arcs::common_interface::RobotModeType
53 *
54 * @par Lua function prototype
55 * getRobotModeType() -> number
56 *
57 * @par JSON-RPC request example
58 * {"jsonrpc":"2.0","method":"rob1.RobotState.getRobotModeType","params":[],"id":1}
59 *
60 * @par JSON-RPC response example
61 * {"id":1,"jsonrpc":"2.0","result":"Running"}
62 *\endenglish
63 */
64
66
67 /**
68 * \chinese
69 * 获取安全模式
70 *
71 * @return 安全模式
72 *
73 * @throws arcs::common_interface::AuboException
74 *
75 * @par Python函数原型
76 * getSafetyModeType(self: pyaubo_sdk.RobotState) ->
77 * arcs::common_interface::SafetyModeType
78 *
79 * @par Lua函数原型
80 * getSafetyModeType() -> number
81 *
82 * @par JSON-RPC请求示例
83 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSafetyModeType","params":[],"id":1}
84 *
85 * @par JSON-RPC响应示例
86 * {"id":1,"jsonrpc":"2.0","result":"Normal"}
87 * \endchinese
88 * \english
89 * Get the safety mode
90 *
91 * @return The safety mode
92 *
93 * @throws arcs::common_interface::AuboException
94 *
95 * @par Python function prototype
96 * getSafetyModeType(self: pyaubo_sdk.RobotState) ->
97 * arcs::common_interface::SafetyModeType
98 *
99 * @par Lua function prototype
100 * getSafetyModeType() -> number
101 *
102 * @par JSON-RPC request example
103 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSafetyModeType","params":[],"id":1}
104 *
105 * @par JSON-RPC response example
106 * {"id":1,"jsonrpc":"2.0","result":"Normal"}
107 * \endenglish
108 */
110
111 /**
112 * \chinese
113 * 获取机器人通电状态
114 *
115 * @return 机器人通电返回 true; 反之返回 false
116 *
117 * @throws arcs::common_interface::AuboException
118 *
119 * @par JSON-RPC请求示例
120 * {"jsonrpc":"2.0","method":"rob1.RobotState.isPowerOn","params":[],"id":1}
121 *
122 * @par JSON-RPC响应示例
123 * {"id":1,"jsonrpc":"2.0","result":true}
124 * \endchinese
125 * \english
126 * Get the robot power-on state
127 *
128 * @return Returns true if the robot is powered on; otherwise returns false
129 *
130 * @throws arcs::common_interface::AuboException
131 *
132 * @par JSON-RPC request example
133 * {"jsonrpc":"2.0","method":"rob1.RobotState.isPowerOn","params":[],"id":1}
134 *
135 * @par JSON-RPC response example
136 * {"id":1,"jsonrpc":"2.0","result":true}
137 * \endenglish
138 */
139 bool isPowerOn();
140
141 /**
142 * \chinese
143 * 机器人是否已经停止下来
144 *
145 * @return 停止返回true; 反之返回false
146 *
147 * @throws arcs::common_interface::AuboException
148 *
149 * @par Python函数原型
150 * isSteady(self: pyaubo_sdk.RobotState) -> bool
151 *
152 * @par Lua函数原型
153 * isSteady() -> boolean
154 *
155 * @par JSON-RPC请求示例
156 * {"jsonrpc":"2.0","method":"rob1.RobotState.isSteady","params":[],"id":1}
157 *
158 * @par JSON-RPC响应示例
159 * {"id":1,"jsonrpc":"2.0","result":true}
160 * \endchinese
161 * \english
162 * Whether the robot has stopped
163 *
164 * @return Returns true if stopped; otherwise returns false
165 *
166 * @throws arcs::common_interface::AuboException
167 *
168 * @par Python function prototype
169 * isSteady(self: pyaubo_sdk.RobotState) -> bool
170 *
171 * @par Lua function prototype
172 * isSteady() -> boolean
173 *
174 * @par JSON-RPC request example
175 * {"jsonrpc":"2.0","method":"rob1.RobotState.isSteady","params":[],"id":1}
176 *
177 * @par JSON-RPC response example
178 * {"id":1,"jsonrpc":"2.0","result":true}
179 * \endenglish
180 */
181 bool isSteady();
182
183 /**
184 * \chinese
185 * 机器人是否发生了碰撞
186 *
187 * @return 发生碰撞返回 true; 反之返回 false
188 *
189 * @throws arcs::common_interface::AuboException
190 *
191 * @par JSON-RPC请求示例
192 * {"jsonrpc":"2.0","method":"rob1.RobotState.isCollisionOccurred","params":[],"id":1}
193 *
194 * @par JSON-RPC响应示例
195 * {"id":1,"jsonrpc":"2.0","result":false}
196 * \endchinese
197 * \english
198 * Whether a collision has occurred
199 *
200 * @return Returns true if a collision occurred; otherwise returns false
201 *
202 * @throws arcs::common_interface::AuboException
203 *
204 * @par JSON-RPC request example
205 * {"jsonrpc":"2.0","method":"rob1.RobotState.isCollisionOccurred","params":[],"id":1}
206 *
207 * @par JSON-RPC response example
208 * {"id":1,"jsonrpc":"2.0","result":false}
209 * \endenglish
210 */
212
213 /**
214 * \chinese
215 * 机器人是否已经在安全限制之内
216 *
217 * @return 在安全限制之内返回true; 反之返回false
218 *
219 * @throws arcs::common_interface::AuboException
220 *
221 * @par Python函数原型
222 * isWithinSafetyLimits(self: pyaubo_sdk.RobotState) -> bool
223 *
224 * @par Lua函数原型
225 * isWithinSafetyLimits() -> boolean
226 *
227 * @par JSON-RPC请求示例
228 * {"jsonrpc":"2.0","method":"rob1.RobotState.isWithinSafetyLimits","params":[],"id":1}
229 *
230 * @par JSON-RPC响应示例
231 * {"id":1,"jsonrpc":"2.0","result":true}
232 * \endchinese
233 * \english
234 * Whether the robot is within safety limits
235 *
236 * @return Returns true if within safety limits; otherwise returns false
237 *
238 * @throws arcs::common_interface::AuboException
239 *
240 * @par Python function prototype
241 * isWithinSafetyLimits(self: pyaubo_sdk.RobotState) -> bool
242 *
243 * @par Lua function prototype
244 * isWithinSafetyLimits() -> boolean
245 *
246 * @par JSON-RPC request example
247 * {"jsonrpc":"2.0","method":"rob1.RobotState.isWithinSafetyLimits","params":[],"id":1}
248 *
249 * @par JSON-RPC response example
250 * {"id":1,"jsonrpc":"2.0","result":true}
251 * \endenglish
252 */
254
255 /**
256 * \chinese
257 * 获取当前的TCP位姿,其 TCP 偏移可以通过 getActualTcpOffset 获取
258 *
259 * 位姿表示形式为(x,y,z,rx,ry,rz)。
260 * 其中x、y、z是工具中心点(TCP)在基坐标系下的位置,单位是m。
261 * rx、ry、rz是工具中心点(TCP)在基坐标系下的姿态,是ZYX欧拉角,单位是rad。
262 *
263 * @return TCP的位姿,形式为(x,y,z,rx,ry,rz)
264 *
265 * @throws arcs::common_interface::AuboException
266 *
267 * @par Python函数原型
268 * getTcpPose(self: pyaubo_sdk.RobotState) -> List[float]
269 *
270 * @par Lua函数原型
271 * getTcpPose() -> table
272 *
273 * @par JSON-RPC请求示例
274 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpPose","params":[],"id":1}
275 *
276 * @par JSON-RPC响应示例
277 * {"id":1,"jsonrpc":"2.0","result":[0.41777839846910425,-0.13250000000000012,0.20928451364415995,3.1415792312578987,0.0,1.5707963267948963]}
278 * \endchinese
279 * \english
280 * Get the current TCP pose. The TCP offset can be obtained by getActualTcpOffset.
281 *
282 * The pose is represented as (x, y, z, rx, ry, rz).
283 * x, y, z are the position of the Tool Center Point (TCP) in the base coordinate system, in meters.
284 * rx, ry, rz are the orientation of the TCP in the base coordinate system, as ZYX Euler angles in radians.
285 *
286 * @return The TCP pose, in the form (x, y, z, rx, ry, rz)
287 *
288 * @throws arcs::common_interface::AuboException
289 *
290 * @par Python function prototype
291 * getTcpPose(self: pyaubo_sdk.RobotState) -> List[float]
292 *
293 * @par Lua function prototype
294 * getTcpPose() -> table
295 *
296 * @par JSON-RPC request example
297 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpPose","params":[],"id":1}
298 *
299 * @par JSON-RPC response example
300 * {"id":1,"jsonrpc":"2.0","result":[0.41777839846910425,-0.13250000000000012,0.20928451364415995,3.1415792312578987,0.0,1.5707963267948963]}
301 * \endenglish
302 */
303 std::vector<double> getTcpPose();
304
305 /**
306 * \chinese
307 * 获取当前的 TCP 偏移,也就是 getTcpPose 返回的 pose 用到的 TCP 偏移
308 *
309 * @return 当前的 TCP 偏移
310 * \endchinese
311 * \english
312 * Get the current TCP offset, which is the TCP offset used by the pose returned from getTcpPose
313 *
314 * @return The current TCP offset
315 * \endenglish
316 */
317 std::vector<double> getActualTcpOffset();
318
319 /**
320 * \chinese
321 * 获取下一个目标路点
322 * 注意与 getTcpTargetPose 的区别,此处定义存在歧义,命名需要优化
323 *
324 * 位姿表示形式为(x,y,z,rx,ry,rz)。
325 * 其中x、y、z是工具中心点(TCP)在基坐标系下的目标位置,单位是m。
326 * rx、ry、rz是工具中心点(TCP)在基坐标系下的目标姿态,是ZYX欧拉角,单位是rad。
327 *
328 * @return 当前目标位姿,形式为(x,y,z,rx,ry,rz)
329 *
330 * @throws arcs::common_interface::AuboException
331 *
332 * @par Python函数原型
333 * getTargetTcpPose(self: pyaubo_sdk.RobotState) -> List[float]
334 *
335 * @par Lua函数原型
336 * getTargetTcpPose() -> table
337 *
338 * @par JSON-RPC请求示例
339 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTargetTcpPose","params":[],"id":1}
340 *
341 * @par JSON-RPC响应示例
342 * {"id":1,"jsonrpc":"2.0","result":[0.4173932217619493,-0.13250000000000012,0.43296496133045825,3.141577313781914,0.0,1.5707963267948963]}
343 * \endchinese
344 * \english
345 * Get the next target waypoint.
346 * Note the difference from getTcpTargetPose; the definition here is ambiguous and the naming needs improvement.
347 *
348 * The pose is represented as (x, y, z, rx, ry, rz).
349 * x, y, z are the target position of the Tool Center Point (TCP) in the base coordinate system, in meters.
350 * rx, ry, rz are the target orientation of the TCP in the base coordinate system, as ZYX Euler angles in radians.
351 *
352 * @return The current target pose, in the form (x, y, z, rx, ry, rz)
353 *
354 * @throws arcs::common_interface::AuboException
355 *
356 * @par Python function prototype
357 * getTargetTcpPose(self: pyaubo_sdk.RobotState) -> List[float]
358 *
359 * @par Lua function prototype
360 * getTargetTcpPose() -> table
361 *
362 * @par JSON-RPC request example
363 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTargetTcpPose","params":[],"id":1}
364 *
365 * @par JSON-RPC response example
366 * {"id":1,"jsonrpc":"2.0","result":[0.4173932217619493,-0.13250000000000012,0.43296496133045825,3.141577313781914,0.0,1.5707963267948963]}
367 * \endenglish
368 */
369 std::vector<double> getTargetTcpPose();
370
371 /**
372 * \chinese
373 * 获取工具端的位姿(不带TCP偏移)
374 *
375 * 位姿表示形式为(x,y,z,rx,ry,rz)。
376 * 其中x、y、z是法兰盘中心在基坐标系下的目标位置,单位是m。
377 * rx、ry、rz是法兰盘中心在基坐标系下的目标姿态,是ZYX欧拉角,单位是rad。
378 *
379 * @return 工具端的位姿,形式为(x,y,z,rx,ry,rz)
380 *
381 * @throws arcs::common_interface::AuboException
382 *
383 * @par Python函数原型
384 * getToolPose(self: pyaubo_sdk.RobotState) -> List[float]
385 *
386 * @par Lua函数原型
387 * getToolPose() -> table
388 *
389 * @par JSON-RPC请求示例
390 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolPose","params":[],"id":1}
391 *
392 * @par JSON-RPC响应示例
393 * {"id":1,"jsonrpc":"2.0","result":[0.41777820858878617,-0.13250000000000012,0.20928410288421018,3.141579231257899,0.0,1.5707963267948963]}
394 * \endchinese
395 * \english
396 * Get the tool pose (without TCP offset)
397 *
398 * The pose is represented as (x, y, z, rx, ry, rz).
399 * x, y, z are the target position of the flange center in the base coordinate system, in meters.
400 * rx, ry, rz are the target orientation of the flange center in the base coordinate system, as ZYX Euler angles in radians.
401 *
402 * @return The tool pose, in the form (x, y, z, rx, ry, rz)
403 *
404 * @throws arcs::common_interface::AuboException
405 *
406 * @par Python function prototype
407 * getToolPose(self: pyaubo_sdk.RobotState) -> List[float]
408 *
409 * @par Lua function prototype
410 * getToolPose() -> table
411 *
412 * @par JSON-RPC request example
413 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolPose","params":[],"id":1}
414 *
415 * @par JSON-RPC response example
416 * {"id":1,"jsonrpc":"2.0","result":[0.41777820858878617,-0.13250000000000012,0.20928410288421018,3.141579231257899,0.0,1.5707963267948963]}
417 * \endenglish
418 */
419 std::vector<double> getToolPose();
420
421 /**
422 * \chinese
423 * 获取TCP速度
424 *
425 * @return TCP速度
426 *
427 * @throws arcs::common_interface::AuboException
428 *
429 * @par Python函数原型
430 * getTcpSpeed(self: pyaubo_sdk.RobotState) -> List[float]
431 *
432 * @par Lua函数原型
433 * getTcpSpeed() -> table
434 *
435 * @par JSON-RPC请求示例
436 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpSpeed","params":[],"id":1}
437 *
438 * @par JSON-RPC响应示例
439 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
440 * \endchinese
441 * \english
442 * Get the TCP speed
443 *
444 * @return TCP speed
445 *
446 * @throws arcs::common_interface::AuboException
447 *
448 * @par Python function prototype
449 * getTcpSpeed(self: pyaubo_sdk.RobotState) -> List[float]
450 *
451 * @par Lua function prototype
452 * getTcpSpeed() -> table
453 *
454 * @par JSON-RPC request example
455 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpSpeed","params":[],"id":1}
456 *
457 * @par JSON-RPC response example
458 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
459 * \endenglish
460 */
461 std::vector<double> getTcpSpeed();
462
463 /**
464 * \chinese
465 * 获取TCP的力/力矩
466 *
467 * @return TCP的力/力矩
468 *
469 * @par Python函数原型
470 * getTcpForce(self: pyaubo_sdk.RobotState) -> List[float]
471 *
472 * @par Lua函数原型
473 * getTcpForce() -> table
474 *
475 * @par JSON-RPC请求示例
476 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpForce","params":[],"id":1}
477 *
478 * @par JSON-RPC响应示例
479 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
480 * \endchinese
481 * \english
482 * Get the TCP force/torque
483 *
484 * @return TCP force/torque
485 *
486 * @par Python function prototype
487 * getTcpForce(self: pyaubo_sdk.RobotState) -> List[float]
488 *
489 * @par Lua function prototype
490 * getTcpForce() -> table
491 *
492 * @par JSON-RPC request example
493 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpForce","params":[],"id":1}
494 *
495 * @par JSON-RPC response example
496 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
497 * \endenglish
498 */
499 std::vector<double> getTcpForce();
500
501 /**
502 * \chinese
503 * 获取肘部的位置
504 *
505 * @return 肘部的位置
506 *
507 * @throws arcs::common_interface::AuboException
508 *
509 * @par Python函数原型
510 * getElbowPosistion(self: pyaubo_sdk.RobotState) -> List[float]
511 *
512 * @par Lua函数原型
513 * getElbowPosistion() -> table
514 *
515 * @par JSON-RPC请求示例
516 * {"jsonrpc":"2.0","method":"rob1.RobotState.getElbowPosistion","params":[],"id":1}
517 *
518 * @par JSON-RPC响应示例
519 * {"id":1,"jsonrpc":"2.0","result":[0.07355755887512408,-0.1325,0.43200874126125227,-1.5707963267948968,0.433006344376404,0.0]}
520 * \endchinese
521 * \english
522 * Get the position of the elbow
523 *
524 * @return The position of the elbow
525 *
526 * @throws arcs::common_interface::AuboException
527 *
528 * @par Python function prototype
529 * getElbowPosistion(self: pyaubo_sdk.RobotState) -> List[float]
530 *
531 * @par Lua function prototype
532 * getElbowPosistion() -> table
533 *
534 * @par JSON-RPC request example
535 * {"jsonrpc":"2.0","method":"rob1.RobotState.getElbowPosistion","params":[],"id":1}
536 *
537 * @par JSON-RPC response example
538 * {"id":1,"jsonrpc":"2.0","result":[0.07355755887512408,-0.1325,0.43200874126125227,-1.5707963267948968,0.433006344376404,0.0]}
539 * \endenglish
540 */
541 std::vector<double> getElbowPosistion();
542
543 /**
544 * \chinese
545 * 获取肘部速度
546 *
547 * @return 肘部速度
548 *
549 * @throws arcs::common_interface::AuboException
550 *
551 * @par Python函数原型
552 * getElbowVelocity(self: pyaubo_sdk.RobotState) -> List[float]
553 *
554 * @par Lua函数原型
555 * getElbowVelocity() -> table
556 *
557 * @par JSON-RPC请求示例
558 * {"jsonrpc":"2.0","method":"rob1.RobotState.getElbowVelocity","params":[],"id":1}
559 *
560 * @par JSON-RPC响应示例
561 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
562 * \endchinese
563 * \english
564 * Get the elbow velocity
565 *
566 * @return Elbow velocity
567 *
568 * @throws arcs::common_interface::AuboException
569 *
570 * @par Python function prototype
571 * getElbowVelocity(self: pyaubo_sdk.RobotState) -> List[float]
572 *
573 * @par Lua function prototype
574 * getElbowVelocity() -> table
575 *
576 * @par JSON-RPC request example
577 * {"jsonrpc":"2.0","method":"rob1.RobotState.getElbowVelocity","params":[],"id":1}
578 *
579 * @par JSON-RPC response example
580 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
581 * \endenglish
582 */
583 std::vector<double> getElbowVelocity();
584
585 /**
586 * \chinese
587 * 获取基座力/力矩
588 *
589 * @return 基座力/力矩
590 *
591 * @throws arcs::common_interface::AuboException
592 *
593 * @par Python函数原型
594 * getBaseForce(self: pyaubo_sdk.RobotState) -> List[float]
595 *
596 * @par Lua函数原型
597 * getBaseForce() -> table
598 *
599 * @par JSON-RPC请求示例
600 * {"jsonrpc":"2.0","method":"rob1.RobotState.getBaseForce","params":[],"id":1}
601 *
602 * @par JSON-RPC响应示例
603 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
604 * \endchinese
605 * \english
606 * Get the base force/torque
607 *
608 * @return Base force/torque
609 *
610 * @throws arcs::common_interface::AuboException
611 *
612 * @par Python function prototype
613 * getBaseForce(self: pyaubo_sdk.RobotState) -> List[float]
614 *
615 * @par Lua function prototype
616 * getBaseForce() -> table
617 *
618 * @par JSON-RPC request example
619 * {"jsonrpc":"2.0","method":"rob1.RobotState.getBaseForce","params":[],"id":1}
620 *
621 * @par JSON-RPC response example
622 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
623 * \endenglish
624 */
625 std::vector<double> getBaseForce();
626
627 /**
628 * \chinese
629 * 获取上一次发送的TCP目标位姿
630 *
631 * @return TCP目标位姿
632 *
633 * @throws arcs::common_interface::AuboException
634 *
635 * @par Python函数原型
636 * getTcpTargetPose(self: pyaubo_sdk.RobotState) -> List[float]
637 *
638 * @par Lua函数原型
639 * getTcpTargetPose() -> table
640 *
641 * @par JSON-RPC请求示例
642 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpTargetPose","params":[],"id":1}
643 *
644 * @par JSON-RPC响应示例
645 * {"id":1,"jsonrpc":"2.0","result":[0.41777829240862013,-0.13250000000000012,0.2092832117232601,3.1415812372223217,0.0,1.5707963267948963]}
646 * \endchinese
647 * \english
648 * Get the last sent TCP target pose
649 *
650 * @return TCP target pose
651 *
652 * @throws arcs::common_interface::AuboException
653 *
654 * @par Python function prototype
655 * getTcpTargetPose(self: pyaubo_sdk.RobotState) -> List[float]
656 *
657 * @par Lua function prototype
658 * getTcpTargetPose() -> table
659 *
660 * @par JSON-RPC request example
661 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpTargetPose","params":[],"id":1}
662 *
663 * @par JSON-RPC response example
664 * {"id":1,"jsonrpc":"2.0","result":[0.41777829240862013,-0.13250000000000012,0.2092832117232601,3.1415812372223217,0.0,1.5707963267948963]}
665 * \endenglish
666 */
667 std::vector<double> getTcpTargetPose();
668
669 /**
670 * \chinese
671 * 获取TCP目标速度
672 *
673 * @return TCP目标速度
674 *
675 * @throws arcs::common_interface::AuboException
676 *
677 * @par Python函数原型
678 * getTcpTargetSpeed(self: pyaubo_sdk.RobotState) -> List[float]
679 *
680 * @par Lua函数原型
681 * getTcpTargetSpeed() -> table
682 *
683 * @par JSON-RPC请求示例
684 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpTargetSpeed","params":[],"id":1}
685 *
686 * @par JSON-RPC响应示例
687 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
688 * \endchinese
689 * \english
690 * Get the TCP target speed
691 *
692 * @return TCP target speed
693 *
694 * @throws arcs::common_interface::AuboException
695 *
696 * @par Python function prototype
697 * getTcpTargetSpeed(self: pyaubo_sdk.RobotState) -> List[float]
698 *
699 * @par Lua function prototype
700 * getTcpTargetSpeed() -> table
701 *
702 * @par JSON-RPC request example
703 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpTargetSpeed","params":[],"id":1}
704 *
705 * @par JSON-RPC response example
706 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
707 * \endenglish
708 */
709 std::vector<double> getTcpTargetSpeed();
710
711 /**
712 * \chinese
713 * 获取TCP目标力/力矩
714 *
715 * @return TCP目标力/力矩
716 *
717 * @throws arcs::common_interface::AuboException
718 *
719 * @par Python函数原型
720 * getTcpTargetForce(self: pyaubo_sdk.RobotState) -> List[float]
721 *
722 * @par Lua函数原型
723 * getTcpTargetForce() -> table
724 *
725 * @par JSON-RPC请求示例
726 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpTargetForce","params":[],"id":1}
727 *
728 * @par JSON-RPC响应示例
729 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
730 * \endchinese
731 * \english
732 * Get the TCP target force/torque
733 *
734 * @return TCP target force/torque
735 *
736 * @throws arcs::common_interface::AuboException
737 *
738 * @par Python function prototype
739 * getTcpTargetForce(self: pyaubo_sdk.RobotState) -> List[float]
740 *
741 * @par Lua function prototype
742 * getTcpTargetForce() -> table
743 *
744 * @par JSON-RPC request example
745 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpTargetForce","params":[],"id":1}
746 *
747 * @par JSON-RPC response example
748 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
749 * \endenglish
750 */
751 std::vector<double> getTcpTargetForce();
752
753 /**
754 * \chinese
755 * 获取机械臂关节标志
756 *
757 * @return 机械臂关节标志
758 *
759 * @throws arcs::common_interface::AuboException
760 *
761 * @par Python函数原型
762 * getJointState(self: pyaubo_sdk.RobotState) ->
763 * List[arcs::common_interface::JointStateType]
764 *
765 * @par Lua函数原型
766 * getJointState() -> table
767 *
768 * @par JSON-RPC请求示例
769 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointState","params":[],"id":1}
770 *
771 * @par JSON-RPC响应示例
772 * {"id":1,"jsonrpc":"2.0","result":["Running","Running","Running","Running","Running","Running"]}
773 * \endchinese
774 * \english
775 * Get the joint state of the manipulator
776 *
777 * @return Joint state of the manipulator
778 *
779 * @throws arcs::common_interface::AuboException
780 *
781 * @par Python function prototype
782 * getJointState(self: pyaubo_sdk.RobotState) ->
783 * List[arcs::common_interface::JointStateType]
784 *
785 * @par Lua function prototype
786 * getJointState() -> table
787 *
788 * @par JSON-RPC request example
789 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointState","params":[],"id":1}
790 *
791 * @par JSON-RPC response example
792 * {"id":1,"jsonrpc":"2.0","result":["Running","Running","Running","Running","Running","Running"]}
793 * \endenglish
794 */
795 std::vector<JointStateType> getJointState();
796
797 /**
798 * \chinese
799 * 获取关节的伺服状态
800 *
801 * @return 关节的伺服状态
802 *
803 * @throws arcs::common_interface::AuboException
804 *
805 * @par Python函数原型
806 * getJointServoMode(self: pyaubo_sdk.RobotState) ->
807 * List[arcs::common_interface::JointServoModeType]
808 *
809 * @par Lua函数原型
810 * getJointServoMode() -> table
811 *
812 * @par JSON-RPC请求示例
813 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointServoMode","params":[],"id":1}
814 *
815 * @par JSON-RPC响应示例
816 * {"id":1,"jsonrpc":"2.0","result":["Position","Position","Position","Position","Position","Position"]}
817 * \endchinese
818 * \english
819 * Get the servo state of the joints
820 *
821 * @return The servo state of the joints
822 *
823 * @throws arcs::common_interface::AuboException
824 *
825 * @par Python function prototype
826 * getJointServoMode(self: pyaubo_sdk.RobotState) ->
827 * List[arcs::common_interface::JointServoModeType]
828 *
829 * @par Lua function prototype
830 * getJointServoMode() -> table
831 *
832 * @par JSON-RPC request example
833 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointServoMode","params":[],"id":1}
834 *
835 * @par JSON-RPC response example
836 * {"id":1,"jsonrpc":"2.0","result":["Position","Position","Position","Position","Position","Position"]}
837 * \endenglish
838 */
839 std::vector<JointServoModeType> getJointServoMode();
840
841 /**
842 * \chinese
843 * 获取机械臂关节角度
844 *
845 * @return 机械臂关节角度
846 *
847 * @throws arcs::common_interface::AuboException
848 *
849 * @par Python函数原型
850 * getJointPositions(self: pyaubo_sdk.RobotState) -> List[float]
851 *
852 * @par Lua函数原型
853 * getJointPositions() -> table
854 *
855 * @par JSON-RPC请求示例
856 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointPositions","params":[],"id":1}
857 *
858 * @par JSON-RPC响应示例
859 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.26199241371495835,1.7418102574563423,0.4330197667082982,1.5707963267948966,0.0]}
860 * \endchinese
861 * \english
862 * Get the joint positions of the manipulator
863 *
864 * @return Joint positions of the manipulator
865 *
866 * @throws arcs::common_interface::AuboException
867 *
868 * @par Python function prototype
869 * getJointPositions(self: pyaubo_sdk.RobotState) -> List[float]
870 *
871 * @par Lua function prototype
872 * getJointPositions() -> table
873 *
874 * @par JSON-RPC request example
875 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointPositions","params":[],"id":1}
876 *
877 * @par JSON-RPC response example
878 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.26199241371495835,1.7418102574563423,0.4330197667082982,1.5707963267948966,0.0]}
879 * \endenglish
880 */
881 std::vector<double> getJointPositions();
882
883 /**
884 * \chinese
885 * 获取机械臂历史关节角度
886 *
887 * @param steps 步数
888 * @return 机械臂历史关节角度
889 * \endchinese
890 * \english
891 * Get the historical joint positions of the manipulator
892 *
893 * @param steps Number of steps
894 * @return Historical joint positions of the manipulator
895 * \endenglish
896 */
897 std::vector<double> getJointPositionsHistory(int steps);
898
899 /**
900 * \chinese
901 * 获取机械臂关节速度
902 *
903 * @return 机械臂关节速度
904 *
905 * @throws arcs::common_interface::AuboException
906 *
907 * @par Python函数原型
908 * getJointSpeeds(self: pyaubo_sdk.RobotState) -> List[float]
909 *
910 * @par Lua函数原型
911 * getJointSpeeds() -> table
912 *
913 * @par JSON-RPC请求示例
914 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointSpeeds","params":[],"id":1}
915 *
916 * @par JSON-RPC响应示例
917 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
918 * \endchinese
919 * \english
920 * Get the joint speeds of the manipulator
921 *
922 * @return Joint speeds of the manipulator
923 *
924 * @throws arcs::common_interface::AuboException
925 *
926 * @par Python function prototype
927 * getJointSpeeds(self: pyaubo_sdk.RobotState) -> List[float]
928 *
929 * @par Lua function prototype
930 * getJointSpeeds() -> table
931 *
932 * @par JSON-RPC request example
933 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointSpeeds","params":[],"id":1}
934 *
935 * @par JSON-RPC response example
936 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
937 * \endenglish
938 */
939 std::vector<double> getJointSpeeds();
940
941 /**
942 * \chinese
943 * 获取机械臂关节加速度
944 *
945 * @return 机械臂关节加速度
946 *
947 * @throws arcs::common_interface::AuboException
948 *
949 * @par Python函数原型
950 * getJointAccelerations(self: pyaubo_sdk.RobotState) -> List[float]
951 *
952 * @par Lua函数原型
953 * getJointAccelerations() -> table
954 *
955 * @par JSON-RPC请求示例
956 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointAccelerations","params":[],"id":1}
957 *
958 * @par JSON-RPC响应示例
959 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
960 * \endchinese
961 * \english
962 * Get the joint accelerations of the manipulator
963 *
964 * @return Joint accelerations of the manipulator
965 *
966 * @throws arcs::common_interface::AuboException
967 *
968 * @par Python function prototype
969 * getJointAccelerations(self: pyaubo_sdk.RobotState) -> List[float]
970 *
971 * @par Lua function prototype
972 * getJointAccelerations() -> table
973 *
974 * @par JSON-RPC request example
975 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointAccelerations","params":[],"id":1}
976 *
977 * @par JSON-RPC response example
978 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
979 * \endenglish
980 */
981 std::vector<double> getJointAccelerations();
982
983 /**
984 * \chinese
985 * 获取机械臂关节力矩
986 *
987 * @return 机械臂关节力矩
988 *
989 * @throws arcs::common_interface::AuboException
990 *
991 * @par Python函数原型
992 * getJointTorqueSensors(self: pyaubo_sdk.RobotState) -> List[float]
993 *
994 * @par Lua函数原型
995 * getJointTorqueSensors() -> table
996 *
997 * @par JSON-RPC请求示例
998 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTorqueSensors","params":[],"id":1}
999 *
1000 * @par JSON-RPC响应示例
1001 * {"id":1,"jsonrpc":"2.0","result":[0.0,6275.367736816406,-7704.2816162109375,3586.9766235351563,503.0364990234375,1506.0882568359375]}
1002 * \endchinese
1003 * \english
1004 * Get the joint torques of the manipulator
1005 *
1006 * @return Joint torques of the manipulator
1007 *
1008 * @throws arcs::common_interface::AuboException
1009 *
1010 * @par Python function prototype
1011 * getJointTorqueSensors(self: pyaubo_sdk.RobotState) -> List[float]
1012 *
1013 * @par Lua function prototype
1014 * getJointTorqueSensors() -> table
1015 *
1016 * @par JSON-RPC request example
1017 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTorqueSensors","params":[],"id":1}
1018 *
1019 * @par JSON-RPC response example
1020 * {"id":1,"jsonrpc":"2.0","result":[0.0,6275.367736816406,-7704.2816162109375,3586.9766235351563,503.0364990234375,1506.0882568359375]}
1021 * \endenglish
1022 */
1023 std::vector<double> getJointTorqueSensors();
1024
1025 /**
1026 * \chinese
1027 * 获取机械臂关节接触力矩(外力距)
1028 *
1029 * @return 机械臂关节接触力矩
1030 *
1031 * @throws arcs::common_interface::AuboException
1032 *
1033 * @par Python函数原型
1034 * getJointContactTorques(self: pyaubo_sdk.RobotState) -> List[float]
1035 *
1036 * @par Lua函数原型
1037 * getJointContactTorques() -> table
1038 *
1039 * @par JSON-RPC请求示例
1040 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointContactTorques","params":[],"id":1}
1041 *
1042 * @par JSON-RPC响应示例
1043 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1044 * \endchinese
1045 * \english
1046 * Get the joint contact torques (external torques) of the manipulator
1047 *
1048 * @return Joint contact torques of the manipulator
1049 *
1050 * @throws arcs::common_interface::AuboException
1051 *
1052 * @par Python function prototype
1053 * getJointContactTorques(self: pyaubo_sdk.RobotState) -> List[float]
1054 *
1055 * @par Lua function prototype
1056 * getJointContactTorques() -> table
1057 *
1058 * @par JSON-RPC request example
1059 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointContactTorques","params":[],"id":1}
1060 *
1061 * @par JSON-RPC response example
1062 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1063 * \endenglish
1064 */
1065 std::vector<double> getJointContactTorques();
1066
1067 /**
1068 * \chinese
1069 * 获取底座力传感器读数
1070 *
1071 * @return 底座力传感器读数
1072 *
1073 * @throws arcs::common_interface::AuboException
1074 *
1075 * @par Python函数原型
1076 * getBaseForceSensor(self: pyaubo_sdk.RobotState) -> List[float]
1077 *
1078 * @par Lua函数原型
1079 * getBaseForceSensor() -> table
1080 *
1081 * @par JSON-RPC请求示例
1082 * {"jsonrpc":"2.0","method":"rob1.RobotState.getBaseForceSensor","params":[],"id":1}
1083 *
1084 * @par JSON-RPC响应示例
1085 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1086 * \endchinese
1087 * \english
1088 * Get the base force sensor readings
1089 *
1090 * @return Base force sensor readings
1091 *
1092 * @throws arcs::common_interface::AuboException
1093 *
1094 * @par Python function prototype
1095 * getBaseForceSensor(self: pyaubo_sdk.RobotState) -> List[float]
1096 *
1097 * @par Lua function prototype
1098 * getBaseForceSensor() -> table
1099 *
1100 * @par JSON-RPC request example
1101 * {"jsonrpc":"2.0","method":"rob1.RobotState.getBaseForceSensor","params":[],"id":1}
1102 *
1103 * @par JSON-RPC response example
1104 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1105 * \endenglish
1106 */
1107 std::vector<double> getBaseForceSensor();
1108
1109 /**
1110 * \chinese
1111 * 获取TCP力传感器读数
1112 *
1113 * @return TCP力传感器读数
1114 *
1115 * @throws arcs::common_interface::AuboException
1116 *
1117 * @par Python函数原型
1118 * getTcpForceSensors(self: pyaubo_sdk.RobotState) -> List[float]
1119 *
1120 * @par Lua函数原型
1121 * getTcpForceSensors() -> table
1122 *
1123 * @par JSON-RPC请求示例
1124 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpForceSensors","params":[],"id":1}
1125 *
1126 * @par JSON-RPC响应示例
1127 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1128 * \endchinese
1129 * \english
1130 * Get the TCP force sensor readings
1131 *
1132 * @return TCP force sensor readings
1133 *
1134 * @throws arcs::common_interface::AuboException
1135 *
1136 * @par Python function prototype
1137 * getTcpForceSensors(self: pyaubo_sdk.RobotState) -> List[float]
1138 *
1139 * @par Lua function prototype
1140 * getTcpForceSensors() -> table
1141 *
1142 * @par JSON-RPC request example
1143 * {"jsonrpc":"2.0","method":"rob1.RobotState.getTcpForceSensors","params":[],"id":1}
1144 *
1145 * @par JSON-RPC response example
1146 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
1147 * \endenglish
1148 */
1149 std::vector<double> getTcpForceSensors();
1150
1151 /**
1152 * \chinese
1153 * 获取机械臂关节电流
1154 *
1155 * @return 机械臂关节电流
1156 *
1157 * @throws arcs::common_interface::AuboException
1158 *
1159 * @par Python函数原型
1160 * getJointCurrents(self: pyaubo_sdk.RobotState) -> List[float]
1161 *
1162 * @par Lua函数原型
1163 * getJointCurrents() -> table
1164 *
1165 * @par JSON-RPC请求示例
1166 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointCurrents","params":[],"id":1}
1167 *
1168 * @par JSON-RPC响应示例
1169 * {"id":1,"jsonrpc":"2.0","result":[0.0,1.25885009765625,-1.5289306640625,0.71868896484375,0.1007080078125,0.3021240234375]}
1170 * \endchinese
1171 * \english
1172 * Get the joint currents of the manipulator
1173 *
1174 * @return Joint currents of the manipulator
1175 *
1176 * @throws arcs::common_interface::AuboException
1177 *
1178 * @par Python function prototype
1179 * getJointCurrents(self: pyaubo_sdk.RobotState) -> List[float]
1180 *
1181 * @par Lua function prototype
1182 * getJointCurrents() -> table
1183 *
1184 * @par JSON-RPC request example
1185 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointCurrents","params":[],"id":1}
1186 *
1187 * @par JSON-RPC response example
1188 * {"id":1,"jsonrpc":"2.0","result":[0.0,1.25885009765625,-1.5289306640625,0.71868896484375,0.1007080078125,0.3021240234375]}
1189 * \endenglish
1190 */
1191 std::vector<double> getJointCurrents();
1192
1193 /**
1194 * \chinese
1195 * 获取机械臂关节电压
1196 *
1197 * @return 机械臂关节电压
1198 *
1199 * @throws arcs::common_interface::AuboException
1200 *
1201 * @par Python函数原型
1202 * getJointVoltages(self: pyaubo_sdk.RobotState) -> List[float]
1203 *
1204 * @par Lua函数原型
1205 * getJointVoltages() -> table
1206 *
1207 * @par JSON-RPC请求示例
1208 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointVoltages","params":[],"id":1}
1209 *
1210 * @par JSON-RPC响应示例
1211 * {"id":1,"jsonrpc":"2.0","result":[2.0,2.5,3.0,2.0,2.5,2.0]}
1212 * \endchinese
1213 * \english
1214 * Get the joint voltages of the manipulator
1215 *
1216 * @return Joint voltages of the manipulator
1217 *
1218 * @throws arcs::common_interface::AuboException
1219 *
1220 * @par Python function prototype
1221 * getJointVoltages(self: pyaubo_sdk.RobotState) -> List[float]
1222 *
1223 * @par Lua function prototype
1224 * getJointVoltages() -> table
1225 *
1226 * @par JSON-RPC request example
1227 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointVoltages","params":[],"id":1}
1228 *
1229 * @par JSON-RPC response example
1230 * {"id":1,"jsonrpc":"2.0","result":[2.0,2.5,3.0,2.0,2.5,2.0]}
1231 * \endenglish
1232 */
1233 std::vector<double> getJointVoltages();
1234
1235 /**
1236 * \chinese
1237 * 获取机械臂关节温度
1238 *
1239 * @return 机械臂关节温度
1240 *
1241 * @throws arcs::common_interface::AuboException
1242 *
1243 * @par Python函数原型
1244 * getJointTemperatures(self: pyaubo_sdk.RobotState) -> List[float]
1245 *
1246 * @par Lua函数原型
1247 * getJointTemperatures() -> table
1248 *
1249 * @par JSON-RPC请求示例
1250 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTemperatures","params":[],"id":1}
1251 *
1252 * @par JSON-RPC响应示例
1253 * {"id":1,"jsonrpc":"2.0","result":[38.0,38.0,38.0,39.0,38.0,39.0]}
1254 * \endchinese
1255 * \english
1256 * Get the joint temperatures of the manipulator
1257 *
1258 * @return Joint temperatures of the manipulator
1259 *
1260 * @throws arcs::common_interface::AuboException
1261 *
1262 * @par Python function prototype
1263 * getJointTemperatures(self: pyaubo_sdk.RobotState) -> List[float]
1264 *
1265 * @par Lua function prototype
1266 * getJointTemperatures() -> table
1267 *
1268 * @par JSON-RPC request example
1269 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTemperatures","params":[],"id":1}
1270 *
1271 * @par JSON-RPC response example
1272 * {"id":1,"jsonrpc":"2.0","result":[38.0,38.0,38.0,39.0,38.0,39.0]}
1273 * \endenglish
1274 */
1275 std::vector<double> getJointTemperatures();
1276
1277 /**
1278 * \chinese
1279 * 获取关节全球唯一ID
1280 *
1281 * @return 关节全球唯一ID
1282 *
1283 * @throws arcs::common_interface::AuboException
1284 *
1285 * @par Python函数原型
1286 * getJointUniqueIds(self: pyaubo_sdk.RobotState) -> List[str]
1287 *
1288 * @par Lua函数原型
1289 * getJointUniqueIds() -> table
1290 *
1291 * @par JSON-RPC请求示例
1292 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointUniqueIds","params":[],"id":1}
1293 *
1294 * @par JSON-RPC响应示例
1295 * {"id":1,"jsonrpc":"2.0","result":["00800020ffffffff31405153","00800020ffffffff3e3f5153","00800020ffffffff414b5153","00800020ffffffff31065153","00800020ffffffff41535153","00800020ffffffff41545153"]}
1296 * \endchinese
1297 * \english
1298 * Get the globally unique IDs of the joints
1299 *
1300 * @return Globally unique IDs of the joints
1301 *
1302 * @throws arcs::common_interface::AuboException
1303 *
1304 * @par Python function prototype
1305 * getJointUniqueIds(self: pyaubo_sdk.RobotState) -> List[str]
1306 *
1307 * @par Lua function prototype
1308 * getJointUniqueIds() -> table
1309 *
1310 * @par JSON-RPC request example
1311 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointUniqueIds","params":[],"id":1}
1312 *
1313 * @par JSON-RPC response example
1314 * {"id":1,"jsonrpc":"2.0","result":["00800020ffffffff31405153","00800020ffffffff3e3f5153","00800020ffffffff414b5153","00800020ffffffff31065153","00800020ffffffff41535153","00800020ffffffff41545153"]}
1315 * \endenglish
1316 */
1317 std::vector<std::string> getJointUniqueIds();
1318
1319 /**
1320 * \chinese
1321 * 获取关节固件版本
1322 *
1323 * @return 关节固件版本
1324 *
1325 * @throws arcs::common_interface::AuboException
1326 *
1327 * @par Python函数原型
1328 * getJointFirmwareVersions(self: pyaubo_sdk.RobotState) -> List[int]
1329 *
1330 * @par Lua函数原型
1331 * getJointFirmwareVersions() -> table
1332 *
1333 * @par JSON-RPC请求示例
1334 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointFirmwareVersions","params":[],"id":1}
1335 *
1336 * @par JSON-RPC响应示例
1337 * {"id":1,"jsonrpc":"2.0","result":[1000010,1000010,1000010,1000010,1000010,1000010]}
1338 * \endchinese
1339 * \english
1340 * Get the joint firmware versions
1341 *
1342 * @return Joint firmware versions
1343 *
1344 * @throws arcs::common_interface::AuboException
1345 *
1346 * @par Python function prototype
1347 * getJointFirmwareVersions(self: pyaubo_sdk.RobotState) -> List[int]
1348 *
1349 * @par Lua function prototype
1350 * getJointFirmwareVersions() -> table
1351 *
1352 * @par JSON-RPC request example
1353 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointFirmwareVersions","params":[],"id":1}
1354 *
1355 * @par JSON-RPC response example
1356 * {"id":1,"jsonrpc":"2.0","result":[1000010,1000010,1000010,1000010,1000010,1000010]}
1357 * \endenglish
1358 */
1359 std::vector<int> getJointFirmwareVersions();
1360
1361 /**
1362 * \chinese
1363 * 获取关节硬件版本
1364 *
1365 * @return 关节硬件版本
1366 *
1367 * @throws arcs::common_interface::AuboException
1368 *
1369 * @par Python函数原型
1370 * getJointHardwareVersions(self: pyaubo_sdk.RobotState) -> List[int]
1371 *
1372 * @par Lua函数原型
1373 * getJointHardwareVersions() -> table
1374 *
1375 * @par JSON-RPC请求示例
1376 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointHardwareVersions","params":[],"id":1}
1377 *
1378 * @par JSON-RPC响应示例
1379 * {"id":1,"jsonrpc":"2.0","result":[1000000,1000000,1004000,1004000,1004000,1004000]}
1380 * \endchinese
1381 * \english
1382 * Get the joint hardware versions
1383 *
1384 * @return Joint hardware versions
1385 *
1386 * @throws arcs::common_interface::AuboException
1387 *
1388 * @par Python function prototype
1389 * getJointHardwareVersions(self: pyaubo_sdk.RobotState) -> List[int]
1390 *
1391 * @par Lua function prototype
1392 * getJointHardwareVersions() -> table
1393 *
1394 * @par JSON-RPC request example
1395 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointHardwareVersions","params":[],"id":1}
1396 *
1397 * @par JSON-RPC response example
1398 * {"id":1,"jsonrpc":"2.0","result":[1000000,1000000,1004000,1004000,1004000,1004000]}
1399 * \endenglish
1400 */
1401 std::vector<int> getJointHardwareVersions();
1402
1403 /**
1404 * \chinese
1405 * 获取MasterBoard全球唯一ID
1406 *
1407 * @return MasterBoard全球唯一ID
1408 *
1409 * @throws arcs::common_interface::AuboException
1410 *
1411 * @par Python函数原型
1412 * getMasterBoardUniqueId(self: pyaubo_sdk.RobotState) -> str
1413 *
1414 * @par Lua函数原型
1415 * getMasterBoardUniqueId() -> string
1416 *
1417 * @par JSON-RPC请求示例
1418 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMasterBoardUniqueId","params":[],"id":1}
1419 *
1420 * @par JSON-RPC响应示例
1421 * {"id":1,"jsonrpc":"2.0","result":"001e0044510f343037323637"}
1422 * \endchinese
1423 * \english
1424 * Get the globally unique ID of the MasterBoard
1425 *
1426 * @return Globally unique ID of the MasterBoard
1427 *
1428 * @throws arcs::common_interface::AuboException
1429 *
1430 * @par Python function prototype
1431 * getMasterBoardUniqueId(self: pyaubo_sdk.RobotState) -> str
1432 *
1433 * @par Lua function prototype
1434 * getMasterBoardUniqueId() -> string
1435 *
1436 * @par JSON-RPC request example
1437 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMasterBoardUniqueId","params":[],"id":1}
1438 *
1439 * @par JSON-RPC response example
1440 * {"id":1,"jsonrpc":"2.0","result":"001e0044510f343037323637"}
1441 * \endenglish
1442 */
1444
1445 /**
1446 * \chinese
1447 * 获取MasterBoard固件版本
1448 *
1449 * @return MasterBoard固件版本
1450 *
1451 * @throws arcs::common_interface::AuboException
1452 *
1453 * @par Python函数原型
1454 * getMasterBoardFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1455 *
1456 * @par Lua函数原型
1457 * getMasterBoardFirmwareVersion() -> number
1458 *
1459 * @par JSON-RPC请求示例
1460 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMasterBoardFirmwareVersion","params":[],"id":1}
1461 *
1462 * @par JSON-RPC响应示例
1463 * {"id":1,"jsonrpc":"2.0","result":1000004}
1464 * \endchinese
1465 * \english
1466 * Get the MasterBoard firmware version
1467 *
1468 * @return MasterBoard firmware version
1469 *
1470 * @throws arcs::common_interface::AuboException
1471 *
1472 * @par Python function prototype
1473 * getMasterBoardFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1474 *
1475 * @par Lua function prototype
1476 * getMasterBoardFirmwareVersion() -> number
1477 *
1478 * @par JSON-RPC request example
1479 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMasterBoardFirmwareVersion","params":[],"id":1}
1480 *
1481 * @par JSON-RPC response example
1482 * {"id":1,"jsonrpc":"2.0","result":1000004}
1483 * \endenglish
1484 */
1486 /**
1487 * \chinese
1488 * 获取MasterBoard硬件版本
1489 *
1490 * @return MasterBoard硬件版本
1491 *
1492 * @throws arcs::common_interface::AuboException
1493 *
1494 * @par Python函数原型
1495 * getMasterBoardHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1496 *
1497 * @par Lua函数原型
1498 * getMasterBoardHardwareVersion() -> number
1499 *
1500 * @par JSON-RPC请求示例
1501 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMasterBoardHardwareVersion","params":[],"id":1}
1502 *
1503 * @par JSON-RPC响应示例
1504 * {"id":1,"jsonrpc":"2.0","result":1000000}
1505 * \endchinese
1506 * \english
1507 * Get the MasterBoard hardware version
1508 *
1509 * @return MasterBoard hardware version
1510 *
1511 * @throws arcs::common_interface::AuboException
1512 *
1513 * @par Python function prototype
1514 * getMasterBoardHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1515 *
1516 * @par Lua function prototype
1517 * getMasterBoardHardwareVersion() -> number
1518 *
1519 * @par JSON-RPC request example
1520 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMasterBoardHardwareVersion","params":[],"id":1}
1521 *
1522 * @par JSON-RPC response example
1523 * {"id":1,"jsonrpc":"2.0","result":1000000}
1524 * \endenglish
1525 */
1527
1528 /**
1529 * \chinese
1530 * 获取SlaveBoard全球唯一ID
1531 *
1532 * @return SlaveBoard全球唯一ID
1533 *
1534 * @throws arcs::common_interface::AuboException
1535 *
1536 * @par Python函数原型
1537 * getSlaveBoardUniqueId(self: pyaubo_sdk.RobotState) -> str
1538 *
1539 * @par Lua函数原型
1540 * getSlaveBoardUniqueId() -> string
1541 *
1542 * @par JSON-RPC请求示例
1543 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlaveBoardUniqueId","params":[],"id":1}
1544 *
1545 * @par JSON-RPC响应示例
1546 * {"id":1,"jsonrpc":"2.0","result":"736572630080000000000000"}
1547 * \endchinese
1548 * \english
1549 * Get the globally unique ID of the SlaveBoard
1550 *
1551 * @return Globally unique ID of the SlaveBoard
1552 *
1553 * @throws arcs::common_interface::AuboException
1554 *
1555 * @par Python function prototype
1556 * getSlaveBoardUniqueId(self: pyaubo_sdk.RobotState) -> str
1557 *
1558 * @par Lua function prototype
1559 * getSlaveBoardUniqueId() -> string
1560 *
1561 * @par JSON-RPC request example
1562 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlaveBoardUniqueId","params":[],"id":1}
1563 *
1564 * @par JSON-RPC response example
1565 * {"id":1,"jsonrpc":"2.0","result":"736572630080000000000000"}
1566 * \endenglish
1567 */
1569
1570 /**
1571 * \chinese
1572 * 获取SlaveBoard固件版本
1573 *
1574 * @return SlaveBoard固件版本
1575 *
1576 * @throws arcs::common_interface::AuboException
1577 *
1578 * @par Python函数原型
1579 * getSlaveBoardFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1580 *
1581 * @par Lua函数原型
1582 * getSlaveBoardFirmwareVersion() -> number
1583 *
1584 * @par JSON-RPC请求示例
1585 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlaveBoardFirmwareVersion","params":[],"id":1}
1586 *
1587 * @par JSON-RPC响应示例
1588 * {"id":1,"jsonrpc":"2.0","result":0}
1589 * \endchinese
1590 * \english
1591 * Get the SlaveBoard firmware version
1592 *
1593 * @return SlaveBoard firmware version
1594 *
1595 * @throws arcs::common_interface::AuboException
1596 *
1597 * @par Python function prototype
1598 * getSlaveBoardFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1599 *
1600 * @par Lua function prototype
1601 * getSlaveBoardFirmwareVersion() -> number
1602 *
1603 * @par JSON-RPC request example
1604 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlaveBoardFirmwareVersion","params":[],"id":1}
1605 *
1606 * @par JSON-RPC response example
1607 * {"id":1,"jsonrpc":"2.0","result":0}
1608 * \endenglish
1609 */
1611
1612 /**
1613 * \chinese
1614 * 获取SlaveBoard硬件版本
1615 *
1616 * @return SlaveBoard硬件版本
1617 *
1618 * @throws arcs::common_interface::AuboException
1619 *
1620 * @par Python函数原型
1621 * getSlaveBoardHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1622 *
1623 * @par Lua函数原型
1624 * getSlaveBoardHardwareVersion() -> number
1625 *
1626 * @par JSON-RPC请求示例
1627 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlaveBoardHardwareVersion","params":[],"id":1}
1628 *
1629 * @par JSON-RPC响应示例
1630 * {"id":1,"jsonrpc":"2.0","result":6030098}
1631 * \endchinese
1632 * \english
1633 * Get the SlaveBoard hardware version
1634 *
1635 * @return SlaveBoard hardware version
1636 *
1637 * @throws arcs::common_interface::AuboException
1638 *
1639 * @par Python function prototype
1640 * getSlaveBoardHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1641 *
1642 * @par Lua function prototype
1643 * getSlaveBoardHardwareVersion() -> number
1644 *
1645 * @par JSON-RPC request example
1646 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlaveBoardHardwareVersion","params":[],"id":1}
1647 *
1648 * @par JSON-RPC response example
1649 * {"id":1,"jsonrpc":"2.0","result":6030098}
1650 * \endenglish
1651 */
1653
1654 /**
1655 * \chinese
1656 * 获取工具端全球唯一ID
1657 *
1658 * @return 工具端全球唯一ID
1659 *
1660 * @throws arcs::common_interface::AuboException
1661 *
1662 * @par Python函数原型
1663 * getToolUniqueId(self: pyaubo_sdk.RobotState) -> str
1664 *
1665 * @par Lua函数原型
1666 * getToolUniqueId() -> string
1667 *
1668 * @par JSON-RPC请求示例
1669 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolUniqueId","params":[],"id":1}
1670 *
1671 * @par JSON-RPC响应示例
1672 * {"id":1,"jsonrpc":"2.0","result":"397d4e5331541252314d3042"}
1673 * \endchinese
1674 * \english
1675 * Get the globally unique ID of the tool
1676 *
1677 * @return Globally unique ID of the tool
1678 *
1679 * @throws arcs::common_interface::AuboException
1680 *
1681 * @par Python function prototype
1682 * getToolUniqueId(self: pyaubo_sdk.RobotState) -> str
1683 *
1684 * @par Lua function prototype
1685 * getToolUniqueId() -> string
1686 *
1687 * @par JSON-RPC request example
1688 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolUniqueId","params":[],"id":1}
1689 *
1690 * @par JSON-RPC response example
1691 * {"id":1,"jsonrpc":"2.0","result":"397d4e5331541252314d3042"}
1692 * \endenglish
1693 */
1694 std::string getToolUniqueId();
1695
1696 /**
1697 * \chinese
1698 * 获取工具端固件版本
1699 *
1700 * @return 工具端固件版本
1701 *
1702 * @throws arcs::common_interface::AuboException
1703 *
1704 * @par Python函数原型
1705 * getToolFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1706 *
1707 * @par Lua函数原型
1708 * getToolFirmwareVersion() -> number
1709 *
1710 * @par JSON-RPC请求示例
1711 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolFirmwareVersion","params":[],"id":1}
1712 *
1713 * @par JSON-RPC响应示例
1714 * {"id":1,"jsonrpc":"2.0","result":1001003}
1715 * \endchinese
1716 * \english
1717 * Get the tool firmware version
1718 *
1719 * @return Tool firmware version
1720 *
1721 * @throws arcs::common_interface::AuboException
1722 *
1723 * @par Python function prototype
1724 * getToolFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1725 *
1726 * @par Lua function prototype
1727 * getToolFirmwareVersion() -> number
1728 *
1729 * @par JSON-RPC request example
1730 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolFirmwareVersion","params":[],"id":1}
1731 *
1732 * @par JSON-RPC response example
1733 * {"id":1,"jsonrpc":"2.0","result":1001003}
1734 * \endenglish
1735 */
1737
1738 /**
1739 * \chinese
1740 * 获取工具端硬件版本
1741 *
1742 * @return 工具端硬件版本
1743 *
1744 * @throws arcs::common_interface::AuboException
1745 *
1746 * @par Python函数原型
1747 * getToolHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1748 *
1749 * @par Lua函数原型
1750 * getToolHardwareVersion() -> number
1751 *
1752 * @par JSON-RPC请求示例
1753 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolHardwareVersion","params":[],"id":1}
1754 *
1755 * @par JSON-RPC响应示例
1756 * {"id":1,"jsonrpc":"2.0","result":1000000}
1757 * \endchinese
1758 * \english
1759 * Get the tool hardware version
1760 *
1761 * @return Tool hardware version
1762 *
1763 * @throws arcs::common_interface::AuboException
1764 *
1765 * @par Python function prototype
1766 * getToolHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1767 *
1768 * @par Lua function prototype
1769 * getToolHardwareVersion() -> number
1770 *
1771 * @par JSON-RPC request example
1772 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolHardwareVersion","params":[],"id":1}
1773 *
1774 * @par JSON-RPC response example
1775 * {"id":1,"jsonrpc":"2.0","result":1000000}
1776 * \endenglish
1777 */
1779
1780 /**
1781 * \chinese
1782 * 获取末端通信模式
1783 *
1784 * @return 末端通信模式
1785 * 0: 表示无串口
1786 * 1: 表示只有串口
1787 * 2: 表示带力传感器和串口
1788 *
1789 * @throws arcs::common_interface::AuboException
1790 *
1791 * @par Python函数原型
1792 * getToolCommMode(self: pyaubo_sdk.RobotState) -> int
1793 *
1794 * @par Lua函数原型
1795 * getToolCommMode() -> number
1796 *
1797 * @par JSON-RPC请求示例
1798 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolCommMode","params":[],"id":1}
1799 *
1800 * @par JSON-RPC响应示例
1801 * {"id":1,"jsonrpc":"2.0","result":1}
1802 * \endchinese
1803 * \english
1804 * Get the tool communication mode
1805 *
1806 * @return Tool communication mode
1807 * 0: No serial port
1808 * 1: Serial port only
1809 * 2: With force sensor and serial port
1810 *
1811 * @throws arcs::common_interface::AuboException
1812 *
1813 * @par Python function prototype
1814 * getToolCommMode(self: pyaubo_sdk.RobotState) -> int
1815 *
1816 * @par Lua function prototype
1817 * getToolCommMode() -> number
1818 *
1819 * @par JSON-RPC request example
1820 * {"jsonrpc":"2.0","method":"rob1.RobotState.getToolCommMode","params":[],"id":1}
1821 *
1822 * @par JSON-RPC response example
1823 * {"id":1,"jsonrpc":"2.0","result":1}
1824 * \endenglish
1825 */
1827
1828 /**
1829 * \chinese
1830 * 获取底座全球唯一ID
1831 *
1832 * @return 底座全球唯一ID
1833 *
1834 * @throws arcs::common_interface::AuboException
1835 *
1836 * @par Python函数原型
1837 * getPedestalUniqueId(self: pyaubo_sdk.RobotState) -> str
1838 *
1839 * @par Lua函数原型
1840 * getPedestalUniqueId() -> string
1841 *
1842 * @par JSON-RPC请求示例
1843 * {"jsonrpc":"2.0","method":"rob1.RobotState.getPedestalUniqueId","params":[],"id":1}
1844 *
1845 * @par JSON-RPC响应示例
1846 * {"id":1,"jsonrpc":"2.0","result":"205257533543065248544339"}
1847 * \endchinese
1848 * \english
1849 * Get the globally unique ID of the pedestal
1850 *
1851 * @return Globally unique ID of the pedestal
1852 *
1853 * @throws arcs::common_interface::AuboException
1854 *
1855 * @par Python function prototype
1856 * getPedestalUniqueId(self: pyaubo_sdk.RobotState) -> str
1857 *
1858 * @par Lua function prototype
1859 * getPedestalUniqueId() -> string
1860 *
1861 * @par JSON-RPC request example
1862 * {"jsonrpc":"2.0","method":"rob1.RobotState.getPedestalUniqueId","params":[],"id":1}
1863 *
1864 * @par JSON-RPC response example
1865 * {"id":1,"jsonrpc":"2.0","result":"205257533543065248544339"}
1866 * \endenglish
1867 */
1868 std::string getPedestalUniqueId();
1869
1870 /**
1871 * \chinese
1872 * 获取底座固件版本
1873 *
1874 * @return 底座固件版本
1875 *
1876 * @throws arcs::common_interface::AuboException
1877 *
1878 * @par Python函数原型
1879 * getPedestalFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1880 *
1881 * @par Lua函数原型
1882 * getPedestalFirmwareVersion() -> number
1883 *
1884 * @par JSON-RPC请求示例
1885 * {"jsonrpc":"2.0","method":"rob1.RobotState.getPedestalFirmwareVersion","params":[],"id":1}
1886 *
1887 * @par JSON-RPC响应示例
1888 * {"id":1,"jsonrpc":"2.0","result":1000004}
1889 * \endchinese
1890 * \english
1891 * Get the pedestal firmware version
1892 *
1893 * @return Pedestal firmware version
1894 *
1895 * @throws arcs::common_interface::AuboException
1896 *
1897 * @par Python function prototype
1898 * getPedestalFirmwareVersion(self: pyaubo_sdk.RobotState) -> int
1899 *
1900 * @par Lua function prototype
1901 * getPedestalFirmwareVersion() -> number
1902 *
1903 * @par JSON-RPC request example
1904 * {"jsonrpc":"2.0","method":"rob1.RobotState.getPedestalFirmwareVersion","params":[],"id":1}
1905 *
1906 * @par JSON-RPC response example
1907 * {"id":1,"jsonrpc":"2.0","result":1000004}
1908 * \endenglish
1909 */
1911
1912 /**
1913 * \chinese
1914 * 获取底座硬件版本
1915 *
1916 * @return 底座硬件版本
1917 *
1918 * @throws arcs::common_interface::AuboException
1919 *
1920 * @par Python函数原型
1921 * getPedestalHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1922 *
1923 * @par Lua函数原型
1924 * getPedestalHardwareVersion() -> number
1925 *
1926 * @par JSON-RPC请求示例
1927 * {"jsonrpc":"2.0","method":"rob1.RobotState.getPedestalHardwareVersion","params":[],"id":1}
1928 *
1929 * @par JSON-RPC响应示例
1930 * {"id":1,"jsonrpc":"2.0","result":1007000}
1931 * \endchinese
1932 * \english
1933 * Get the pedestal hardware version
1934 *
1935 * @return Pedestal hardware version
1936 *
1937 * @throws arcs::common_interface::AuboException
1938 *
1939 * @par Python function prototype
1940 * getPedestalHardwareVersion(self: pyaubo_sdk.RobotState) -> int
1941 *
1942 * @par Lua function prototype
1943 * getPedestalHardwareVersion() -> number
1944 *
1945 * @par JSON-RPC request example
1946 * {"jsonrpc":"2.0","method":"rob1.RobotState.getPedestalHardwareVersion","params":[],"id":1}
1947 *
1948 * @par JSON-RPC response example
1949 * {"id":1,"jsonrpc":"2.0","result":1007000}
1950 * \endenglish
1951 */
1953
1954 /**
1955 * \chinese
1956 * 获取机械臂关节目标位置角度
1957 *
1958 * @return 机械臂关节目标位置角度
1959 *
1960 * @throws arcs::common_interface::AuboException
1961 *
1962 * @par Python函数原型
1963 * getJointTargetPositions(self: pyaubo_sdk.RobotState) -> List[float]
1964 *
1965 * @par Lua函数原型
1966 * getJointTargetPositions() -> table
1967 *
1968 * @par JSON-RPC请求示例
1969 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetPositions","params":[],"id":1}
1970 *
1971 * @par JSON-RPC响应示例
1972 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.2619944355631239,1.7418124015308052,0.4330219266665035,1.5707963267948966,0.0]}
1973 * \endchinese
1974 * \english
1975 * Get the target joint positions (angles) of the manipulator
1976 *
1977 * @return Target joint positions (angles) of the manipulator
1978 *
1979 * @throws arcs::common_interface::AuboException
1980 *
1981 * @par Python function prototype
1982 * getJointTargetPositions(self: pyaubo_sdk.RobotState) -> List[float]
1983 *
1984 * @par Lua function prototype
1985 * getJointTargetPositions() -> table
1986 *
1987 * @par JSON-RPC request example
1988 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetPositions","params":[],"id":1}
1989 *
1990 * @par JSON-RPC response example
1991 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.2619944355631239,1.7418124015308052,0.4330219266665035,1.5707963267948966,0.0]}
1992 * \endenglish
1993 */
1994 std::vector<double> getJointTargetPositions();
1995
1996 /**
1997 * \chinese
1998 * 获取机械臂关节目标速度
1999 *
2000 * @return 机械臂关节目标速度
2001 *
2002 * @throws arcs::common_interface::AuboException
2003 *
2004 * @par Python函数原型
2005 * getJointTargetSpeeds(self: pyaubo_sdk.RobotState) -> List[float]
2006 *
2007 * @par Lua函数原型
2008 * getJointTargetSpeeds() -> table
2009 *
2010 * @par JSON-RPC请求示例
2011 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetSpeeds","params":[],"id":1}
2012 *
2013 * @par JSON-RPC响应示例
2014 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.00024227101509399773,0.0016521760307419697,0.0026521060731088397,0.0,0.0]}
2015 * \endchinese
2016 * \english
2017 * Get the target joint speeds of the manipulator
2018 *
2019 * @return Target joint speeds of the manipulator
2020 *
2021 * @throws arcs::common_interface::AuboException
2022 *
2023 * @par Python function prototype
2024 * getJointTargetSpeeds(self: pyaubo_sdk.RobotState) -> List[float]
2025 *
2026 * @par Lua function prototype
2027 * getJointTargetSpeeds() -> table
2028 *
2029 * @par JSON-RPC request example
2030 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetSpeeds","params":[],"id":1}
2031 *
2032 * @par JSON-RPC response example
2033 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.00024227101509399773,0.0016521760307419697,0.0026521060731088397,0.0,0.0]}
2034 * \endenglish
2035 */
2036 std::vector<double> getJointTargetSpeeds();
2037
2038 /**
2039 * \chinese
2040 * 获取机械臂关节目标加速度
2041 *
2042 * @return 机械臂关节目标加速度
2043 *
2044 * @throws arcs::common_interface::AuboException
2045 *
2046 * @par Python函数原型
2047 * getJointTargetAccelerations(self: pyaubo_sdk.RobotState) -> List[float]
2048 *
2049 * @par Lua函数原型
2050 * getJointTargetAccelerations() -> table
2051 *
2052 * @par JSON-RPC请求示例
2053 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetAccelerations","params":[],"id":1}
2054 *
2055 * @par JSON-RPC响应示例
2056 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.6737932929246071,-12.610253240108449,0.0,0.0,0.0]}
2057 * \endchinese
2058 * \english
2059 * Get the target joint accelerations of the manipulator
2060 *
2061 * @return Target joint accelerations of the manipulator
2062 *
2063 * @throws arcs::common_interface::AuboException
2064 *
2065 * @par Python function prototype
2066 * getJointTargetAccelerations(self: pyaubo_sdk.RobotState) -> List[float]
2067 *
2068 * @par Lua function prototype
2069 * getJointTargetAccelerations() -> table
2070 *
2071 * @par JSON-RPC request example
2072 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetAccelerations","params":[],"id":1}
2073 *
2074 * @par JSON-RPC response example
2075 * {"id":1,"jsonrpc":"2.0","result":[0.0,-0.6737932929246071,-12.610253240108449,0.0,0.0,0.0]}
2076 * \endenglish
2077 */
2078 std::vector<double> getJointTargetAccelerations();
2079
2080 /**
2081 * \chinese
2082 * 获取机械臂关节目标力矩
2083 *
2084 * @return 机械臂关节目标力矩
2085 *
2086 * @throws arcs::common_interface::AuboException
2087 *
2088 * @par Python函数原型
2089 * getJointTargetTorques(self: pyaubo_sdk.RobotState) -> List[float]
2090 *
2091 * @par Lua函数原型
2092 * getJointTargetTorques() -> table
2093 *
2094 * @par JSON-RPC请求示例
2095 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetTorques","params":[],"id":1}
2096 *
2097 * @par JSON-RPC响应示例
2098 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
2099 * \endchinese
2100 * \english
2101 * Get the target joint torques of the manipulator
2102 *
2103 * @return Target joint torques of the manipulator
2104 *
2105 * @throws arcs::common_interface::AuboException
2106 *
2107 * @par Python function prototype
2108 * getJointTargetTorques(self: pyaubo_sdk.RobotState) -> List[float]
2109 *
2110 * @par Lua function prototype
2111 * getJointTargetTorques() -> table
2112 *
2113 * @par JSON-RPC request example
2114 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetTorques","params":[],"id":1}
2115 *
2116 * @par JSON-RPC response example
2117 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
2118 * \endenglish
2119 */
2120 std::vector<double> getJointTargetTorques();
2121
2122 /**
2123 * \chinese
2124 * 获取机械臂关节目标电流
2125 *
2126 * @return 机械臂关节目标电流
2127 *
2128 * @throws arcs::common_interface::AuboException
2129 *
2130 * @par Python函数原型
2131 * getJointTargetCurrents(self: pyaubo_sdk.RobotState) -> List[float]
2132 *
2133 * @par Lua函数原型
2134 * getJointTargetCurrents() -> table
2135 *
2136 * @par JSON-RPC请求示例
2137 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetCurrents","params":[],"id":1}
2138 *
2139 * @par JSON-RPC响应示例
2140 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
2141 * \endchinese
2142 * \english
2143 * Get the target joint currents of the manipulator
2144 *
2145 * @return Target joint currents of the manipulator
2146 *
2147 * @throws arcs::common_interface::AuboException
2148 *
2149 * @par Python function prototype
2150 * getJointTargetCurrents(self: pyaubo_sdk.RobotState) -> List[float]
2151 *
2152 * @par Lua function prototype
2153 * getJointTargetCurrents() -> table
2154 *
2155 * @par JSON-RPC request example
2156 * {"jsonrpc":"2.0","method":"rob1.RobotState.getJointTargetCurrents","params":[],"id":1}
2157 *
2158 * @par JSON-RPC response example
2159 * {"id":1,"jsonrpc":"2.0","result":[0.0,0.0,0.0,0.0,0.0,0.0]}
2160 * \endenglish
2161 */
2162 std::vector<double> getJointTargetCurrents();
2163
2164 /**
2165 * \chinese
2166 * 获取控制柜温度
2167 *
2168 * @return 控制柜温度
2169 *
2170 * @throws arcs::common_interface::AuboException
2171 *
2172 * @par Python函数原型
2173 * getControlBoxTemperature(self: pyaubo_sdk.RobotState) -> float
2174 *
2175 * @par Lua函数原型
2176 * getControlBoxTemperature() -> number
2177 *
2178 * @par JSON-RPC请求示例
2179 * {"jsonrpc":"2.0","method":"rob1.RobotState.getControlBoxTemperature","params":[],"id":1}
2180 *
2181 * @par JSON-RPC响应示例
2182 * {"id":1,"jsonrpc":"2.0","result":25.0}
2183 * \endchinese
2184 * \english
2185 * Get the control box temperature
2186 *
2187 * @return Control box temperature
2188 *
2189 * @throws arcs::common_interface::AuboException
2190 *
2191 * @par Python function prototype
2192 * getControlBoxTemperature(self: pyaubo_sdk.RobotState) -> float
2193 *
2194 * @par Lua function prototype
2195 * getControlBoxTemperature() -> number
2196 *
2197 * @par JSON-RPC request example
2198 * {"jsonrpc":"2.0","method":"rob1.RobotState.getControlBoxTemperature","params":[],"id":1}
2199 *
2200 * @par JSON-RPC response example
2201 * {"id":1,"jsonrpc":"2.0","result":25.0}
2202 * \endenglish
2203 */
2205
2206 /**
2207 * \chinese
2208 * 获取控制柜湿度
2209 *
2210 * @return 控制柜湿度
2211 *
2212 * @throws arcs::common_interface::AuboException
2213 *
2214 * @par Python函数原型
2215 * getControlBoxHumidity(self: pyaubo_sdk.RobotState) -> float
2216 *
2217 * @par Lua函数原型
2218 * getControlBoxHumidity() -> number
2219 *
2220 * @par JSON-RPC请求示例
2221 * {"jsonrpc":"2.0","method":"rob1.RobotState.getControlBoxHumidity","params":[],"id":1}
2222 *
2223 * @par JSON-RPC响应示例
2224 * {"id":1,"jsonrpc":"2.0","result":20.0}
2225 * \endchinese
2226 * \english
2227 * Get the control box humidity
2228 *
2229 * @return Control box humidity
2230 *
2231 * @throws arcs::common_interface::AuboException
2232 *
2233 * @par Python function prototype
2234 * getControlBoxHumidity(self: pyaubo_sdk.RobotState) -> float
2235 *
2236 * @par Lua function prototype
2237 * getControlBoxHumidity() -> number
2238 *
2239 * @par JSON-RPC request example
2240 * {"jsonrpc":"2.0","method":"rob1.RobotState.getControlBoxHumidity","params":[],"id":1}
2241 *
2242 * @par JSON-RPC response example
2243 * {"id":1,"jsonrpc":"2.0","result":20.0}
2244 * \endenglish
2245 */
2247
2248 /**
2249 * \chinese
2250 * 获取母线电压
2251 *
2252 * @return 母线电压
2253 *
2254 * @throws arcs::common_interface::AuboException
2255 *
2256 * @par Python函数原型
2257 * getMainVoltage(self: pyaubo_sdk.RobotState) -> float
2258 *
2259 * @par Lua函数原型
2260 * getMainVoltage() -> number
2261 *
2262 * @par JSON-RPC请求示例
2263 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMainVoltage","params":[],"id":1}
2264 *
2265 * @par JSON-RPC响应示例
2266 * {"id":1,"jsonrpc":"2.0","result":52.75}
2267 * \endchinese
2268 * \english
2269 * Get the main bus voltage
2270 *
2271 * @return Main bus voltage
2272 *
2273 * @throws arcs::common_interface::AuboException
2274 *
2275 * @par Python function prototype
2276 * getMainVoltage(self: pyaubo_sdk.RobotState) -> float
2277 *
2278 * @par Lua function prototype
2279 * getMainVoltage() -> number
2280 *
2281 * @par JSON-RPC request example
2282 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMainVoltage","params":[],"id":1}
2283 *
2284 * @par JSON-RPC response example
2285 * {"id":1,"jsonrpc":"2.0","result":52.75}
2286 * \endenglish
2287 */
2289
2290 /**
2291 * \chinese
2292 * 获取母线电流
2293 *
2294 * @return 母线电流
2295 *
2296 * @throws arcs::common_interface::AuboException
2297 *
2298 * @par Python函数原型
2299 * getMainCurrent(self: pyaubo_sdk.RobotState) -> float
2300 *
2301 * @par Lua函数原型
2302 * getMainCurrent() -> number
2303 *
2304 * @par JSON-RPC请求示例
2305 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMainCurrent","params":[],"id":1}
2306 *
2307 * @par JSON-RPC响应示例
2308 * {"id":1,"jsonrpc":"2.0","result":0.3204345703125}
2309 * \endchinese
2310 * \english
2311 * Get the main bus current
2312 *
2313 * @return Main bus current
2314 *
2315 * @throws arcs::common_interface::AuboException
2316 *
2317 * @par Python function prototype
2318 * getMainCurrent(self: pyaubo_sdk.RobotState) -> float
2319 *
2320 * @par Lua function prototype
2321 * getMainCurrent() -> number
2322 *
2323 * @par JSON-RPC request example
2324 * {"jsonrpc":"2.0","method":"rob1.RobotState.getMainCurrent","params":[],"id":1}
2325 *
2326 * @par JSON-RPC response example
2327 * {"id":1,"jsonrpc":"2.0","result":0.3204345703125}
2328 * \endenglish
2329 */
2331
2332 /**
2333 * \chinese
2334 * 获取机器人电压
2335 *
2336 * @return 机器人电压
2337 *
2338 * @throws arcs::common_interface::AuboException
2339 *
2340 * @par Python函数原型
2341 * getRobotVoltage(self: pyaubo_sdk.RobotState) -> float
2342 *
2343 * @par Lua函数原型
2344 * getRobotVoltage() -> number
2345 *
2346 * @par JSON-RPC请求示例
2347 * {"jsonrpc":"2.0","method":"rob1.RobotState.getRobotVoltage","params":[],"id":1}
2348 *
2349 * @par JSON-RPC响应示例
2350 * {"id":1,"jsonrpc":"2.0","result":52.75}
2351 * \endchinese
2352 * \english
2353 * Get the robot voltage
2354 *
2355 * @return Robot voltage
2356 *
2357 * @throws arcs::common_interface::AuboException
2358 *
2359 * @par Python function prototype
2360 * getRobotVoltage(self: pyaubo_sdk.RobotState) -> float
2361 *
2362 * @par Lua function prototype
2363 * getRobotVoltage() -> number
2364 *
2365 * @par JSON-RPC request example
2366 * {"jsonrpc":"2.0","method":"rob1.RobotState.getRobotVoltage","params":[],"id":1}
2367 *
2368 * @par JSON-RPC response example
2369 * {"id":1,"jsonrpc":"2.0","result":52.75}
2370 * \endenglish
2371 */
2373
2374 /**
2375 * \chinese
2376 * 获取机器人电流
2377 *
2378 * @return 机器人电流
2379 *
2380 * @throws arcs::common_interface::AuboException
2381 *
2382 * @par Python函数原型
2383 * getRobotCurrent(self: pyaubo_sdk.RobotState) -> float
2384 *
2385 * @par Lua函数原型
2386 * getRobotCurrent() -> number
2387 *
2388 * @par JSON-RPC请求示例
2389 * {"jsonrpc":"2.0","method":"rob1.RobotState.getRobotCurrent","params":[],"id":1}
2390 *
2391 * @par JSON-RPC响应示例
2392 * {"id":1,"jsonrpc":"2.0","result":0.3204345703125}
2393 * \endchinese
2394 * \english
2395 * Get the robot current
2396 *
2397 * @return Robot current
2398 *
2399 * @throws arcs::common_interface::AuboException
2400 *
2401 * @par Python function prototype
2402 * getRobotCurrent(self: pyaubo_sdk.RobotState) -> float
2403 *
2404 * @par Lua function prototype
2405 * getRobotCurrent() -> number
2406 *
2407 * @par JSON-RPC request example
2408 * {"jsonrpc":"2.0","method":"rob1.RobotState.getRobotCurrent","params":[],"id":1}
2409 *
2410 * @par JSON-RPC response example
2411 * {"id":1,"jsonrpc":"2.0","result":0.3204345703125}
2412 * \endenglish
2413 */
2415
2416 /**
2417 * \chinese
2418 * 获取机器人缓速等级
2419 *
2420 * @return 机器人缓速等级
2421 *
2422 * @throws arcs::common_interface::AuboException
2423 *
2424 * @par JSON-RPC请求示例
2425 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlowDownLevel","params":[],"id":1}
2426 *
2427 * @par JSON-RPC响应示例
2428 * {"id":1,"jsonrpc":"2.0","result":0}
2429 * \endchinese
2430 * \english
2431 * Get the robot slow down level
2432 *
2433 * @return Robot slow down level
2434 *
2435 * @throws arcs::common_interface::AuboException
2436 *
2437 * @par JSON-RPC request example
2438 * {"jsonrpc":"2.0","method":"rob1.RobotState.getSlowDownLevel","params":[],"id":1}
2439 *
2440 * @par JSON-RPC response example
2441 * {"id":1,"jsonrpc":"2.0","result":0}
2442 * \endenglish
2443 */
2445
2446protected:
2447 void *d_;
2448};
2449using RobotStatePtr = std::shared_ptr<RobotState>;
2450} // namespace common_interface
2451} // namespace arcs
2452#endif // AUBO_SDK_ROBOT_STATE_INTERFACE_H
std::string getToolUniqueId()
获取工具端全球唯一ID
int getToolFirmwareVersion()
获取工具端固件版本
std::vector< double > getJointTargetAccelerations()
获取机械臂关节目标加速度
std::vector< double > getJointTargetTorques()
获取机械臂关节目标力矩
std::vector< double > getJointTargetCurrents()
获取机械臂关节目标电流
std::vector< double > getTcpSpeed()
获取TCP速度
std::vector< JointServoModeType > getJointServoMode()
获取关节的伺服状态
int getSlowDownLevel()
获取机器人缓速等级
std::vector< double > getBaseForce()
获取基座力/力矩
std::vector< double > getTcpForce()
获取TCP的力/力矩
std::vector< double > getJointTargetPositions()
获取机械臂关节目标位置角度
std::vector< double > getJointSpeeds()
获取机械臂关节速度
bool isWithinSafetyLimits()
机器人是否已经在安全限制之内
std::vector< double > getJointTargetSpeeds()
获取机械臂关节目标速度
std::vector< double > getJointCurrents()
获取机械臂关节电流
int getPedestalFirmwareVersion()
获取底座固件版本
double getRobotVoltage()
获取机器人电压
std::vector< double > getTcpTargetPose()
获取上一次发送的TCP目标位姿
double getMainCurrent()
获取母线电流
std::vector< double > getJointPositionsHistory(int steps)
获取机械臂历史关节角度
SafetyModeType getSafetyModeType()
获取安全模式
double getControlBoxHumidity()
获取控制柜湿度
bool isSteady()
机器人是否已经停止下来
std::string getSlaveBoardUniqueId()
获取SlaveBoard全球唯一ID
bool isPowerOn()
获取机器人通电状态
std::vector< double > getActualTcpOffset()
获取当前的 TCP 偏移,也就是 getTcpPose 返回的 pose 用到的 TCP 偏移
int getToolHardwareVersion()
获取工具端硬件版本
bool isCollisionOccurred()
机器人是否发生了碰撞
std::vector< std::string > getJointUniqueIds()
获取关节全球唯一ID
std::vector< double > getTargetTcpPose()
获取下一个目标路点 注意与 getTcpTargetPose 的区别,此处定义存在歧义,命名需要优化
int getMasterBoardFirmwareVersion()
获取MasterBoard固件版本
std::vector< double > getToolPose()
获取工具端的位姿(不带TCP偏移)
int getSlaveBoardFirmwareVersion()
获取SlaveBoard固件版本
int getToolCommMode()
获取末端通信模式
std::string getPedestalUniqueId()
获取底座全球唯一ID
std::vector< JointStateType > getJointState()
获取机械臂关节标志
std::vector< double > getElbowPosistion()
获取肘部的位置
double getControlBoxTemperature()
获取控制柜温度
std::vector< double > getJointAccelerations()
获取机械臂关节加速度
std::vector< double > getElbowVelocity()
获取肘部速度
std::vector< double > getJointContactTorques()
获取机械臂关节接触力矩(外力距)
std::vector< double > getBaseForceSensor()
获取底座力传感器读数
std::vector< double > getTcpTargetSpeed()
获取TCP目标速度
double getRobotCurrent()
获取机器人电流
double getMainVoltage()
获取母线电压
std::vector< double > getTcpForceSensors()
获取TCP力传感器读数
std::vector< double > getJointTemperatures()
获取机械臂关节温度
int getPedestalHardwareVersion()
获取底座硬件版本
int getMasterBoardHardwareVersion()
获取MasterBoard硬件版本
std::vector< double > getJointPositions()
获取机械臂关节角度
std::vector< double > getTcpPose()
获取当前的TCP位姿,其 TCP 偏移可以通过 getActualTcpOffset 获取
std::vector< int > getJointHardwareVersions()
获取关节硬件版本
std::vector< double > getTcpTargetForce()
获取TCP目标力/力矩
int getSlaveBoardHardwareVersion()
获取SlaveBoard硬件版本
std::string getMasterBoardUniqueId()
获取MasterBoard全球唯一ID
RobotModeType getRobotModeType()
获取机器人的模式状态
std::vector< double > getJointTorqueSensors()
获取机械臂关节力矩
std::vector< double > getJointVoltages()
获取机械臂关节电压
std::vector< int > getJointFirmwareVersions()
获取关节固件版本
SafetyModeType
安全状态:
Definition type_def.h:482
std::shared_ptr< RobotState > RobotStatePtr
数据类型的定义