ARCS SDK API  0.24.0
motion_control.h
浏览该文件的文档.
1 /** @file motion_control.h
2  * @brief 运动控制接口
3  *
4  * The robot movements are programmed as pose-to-pose movements, that is move
5  * from the current position to a new position. The path between these two
6  * positions is then automatically calculated by the robot.
7  */
8 #ifndef AUBO_SDK_MOTION_CONTROL_INTERFACE_H
9 #define AUBO_SDK_MOTION_CONTROL_INTERFACE_H
10 
11 #include <vector>
12 #include <functional>
13 #include <thread>
14 
15 #include <aubo/global_config.h>
16 #include <aubo/type_def.h>
17 
18 namespace arcs {
19 namespace common_interface {
20 
21 /**
22  * pathBuffer类型
23  */
24 enum PathBufferType
25 {
26  PathBuffer_TOPPRA = 1, ///< 1: toppra 时间最优路径规划
27  PathBuffer_CubicSpline = 2, ///< 2: cubic_spline(录制的轨迹)
28  PathBuffer_JointSpline = 3, ///< 3: 关节B样条插值，最少三个点
29 };
30 
31 /**
32  * MotionControl类
33  */
34 class ARCS_ABI_EXPORT MotionControl
35 {
36 public:
37  MotionControl();
38  virtual ~MotionControl();
39 
40  /**
41  * 获取等效半径，单位 m
42  * moveLine/moveCircle时，末端姿态旋转的角度等效到末端位置移动
43  *
44  * @return 返回等效半径
45  *
46  * @throws arcs::common_interface::AuboException
47  *
48  * @par Python函数原型
49  * getEqradius(self: pyaubo_sdk.MotionControl) -> float
50  *
51  * @par Lua函数原型
52  * getEqradius() -> number
53  */
54  double getEqradius();
55 
56  /**
57  * 设置等效半径，单位 m
58  * moveLine/moveCircle时，末端姿态旋转的角度等效到末端位置移动
59  *
60  * @return 成功返回0; 失败返回错误码
61  * AUBO_BAD_STATE
62  * AUBO_BUSY
63  * -AUBO_INVL_ARGUMENT
64  * -AUBO_BAD_STATE
65  *
66  * @throws arcs::common_interface::AuboException
67  *
68  * @par Python函数原型
69  * setEqradius(self: pyaubo_sdk.MotionControl, arg0: float) -> int
70  *
71  * @par Lua函数原型
72  * setEqradius(eqradius: number) -> number
73  */
74  int setEqradius(double eqradius);
75 
76  /**
77  * 动态调整机器人运行速度和加速度比例 (0., 1.]
78  *
79  * @param fraction 机器人运行速度和加速度比例
80  * @return 成功返回0; 失败返回错误码
81  * AUBO_INVL_ARGUMENT
82  * AUBO_BUSY
83  * AUBO_BAD_STATE
84  * -AUBO_INVL_ARGUMENT
85  * -AUBO_BAD_STATE
86  *
87  * @throws arcs::common_interface::AuboException
88  *
89  * @par Python函数原型
90  * setSpeedFraction(self: pyaubo_sdk.MotionControl, arg0: float) -> int
91  *
92  * @par Lua函数原型
93  * setSpeedFraction(fraction: number) -> nil
94  *
95  */
96  int setSpeedFraction(double fraction);
97 
98  /**
99  * 获取速度和加速度比例，默认为 1
100  * 可以通过 setSpeedFraction 接口设置
101  *
102  * @return 返回速度和加速度比例
103  *
104  * @throws arcs::common_interface::AuboException
105  *
106  * @par Python函数原型
107  * getSpeedFraction(self: pyaubo_sdk.MotionControl) -> float
108  *
109  * @par Lua函数原型
110  * getSpeedFraction() -> number
111  *
112  */
113  double getSpeedFraction();
114 
115  /**
116  * 速度比例设置临界区，使能之后速度比例被强制设定为1. ,
117  * 失能之后恢复之前的速度比例
118  *
119  * @param enable
120  * @return 成功返回0; 失败返回错误码
121  * AUBO_BAD_STATE
122  * AUBO_BUSY
123  * -AUBO_BAD_STATE
124  *
125  * @throws arcs::common_interface::AuboException
126  *
127  */
128  int speedFractionCritical(bool enable);
129 
130  /**
131  * 是否处于速度比例设置临界区
132  *
133  * @return 处于速度比例设置临界区返回 true; 反之返回 false
134  *
135  * @throws arcs::common_interface::AuboException
136  *
137  */
138  bool isSpeedFractionCritical();
139 
140  /**
141  * 是否处交融区
142  *
143  * @return 处交融区返回 true; 反之返回 false
144  *
145  * @throws arcs::common_interface::AuboException
146  *
147  */
148  bool isBlending();
149 
150  /**
151  * 设置偏移的最大速度和最大加速度
152  * 仅对pathOffsetSet中 type=1 有效
153  * @param v 最大速度
154  * @param a 最大加速度
155  * @return 成功返回0；失败返回错误码
156  * AUBO_BUSY
157  * AUBO_BAD_STATE
158  * -AUBO_INVL_ARGUMENT
159  * -AUBO_BAD_STATE
160  *
161  * @throws arcs::common_interface::AuboException
162  *
163  * @par Python函数原型
164  * pathOffsetLimits(self: pyaubo_sdk.MotionControl, arg0: float, arg1:
165  * float)
166  * -> int
167  *
168  * @par Lua函数原型
169  * pathOffsetLimits(v: number, a: number) -> nil
170  *
171  */
172  int pathOffsetLimits(double v, double a);
173 
174  /**
175  * 设置偏移的参考坐标系
176  * 仅对pathOffsetSet中 type=1 有效
177  * @param ref_coord 参考坐标系 0-基坐标系 1-TCP
178  *
179  * @throws arcs::common_interface::AuboException
180  *
181  * @par Python函数原型
182  * pathOffsetCoordinate(self: pyaubo_sdk.MotionControl, arg0: int) -> float
183  *
184  * @par Lua函数原型
185  * pathOffsetCoordinate(ref_coord: number) -> number
186  *
187  */
188  int pathOffsetCoordinate(int ref_coord);
189 
190  /**
191  * 路径偏移使能
192  *
193  * @return 成功返回0; 失败返回错误码
194  * AUBO_BUSY
195  * AUBO_BAD_STATE
196  * -AUBO_BAD_STATE
197  *
198  * @throws arcs::common_interface::AuboException
199  *
200  * @par Python函数原型
201  * pathOffsetEnable(self: pyaubo_sdk.MotionControl) -> int
202  *
203  * @par Lua函数原型
204  * pathOffsetEnable() -> number
205  *
206  */
207  int pathOffsetEnable();
208 
209  /**
210  * 设置路径偏移
211  *
212  * @param offset 在各方向的位姿偏移
213  * @param type 运动类型 0-位置规划 1-速度规划
214  * @return 成功返回0; 失败返回错误码
215  * AUBO_BAD_STATE
216  * AUBO_BUSY
217  * -AUBO_INVL_ARGUMENT
218  * -AUBO_BAD_STATE
219  *
220  * @throws arcs::common_interface::AuboException
221  *
222  * @par Python函数原型
223  * pathOffsetSet(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
224  * int) -> int
225  *
226  * @par Lua函数原型
227  * pathOffsetSet(offset: table, type: number) -> nil
228  *
229  */
230  int pathOffsetSet(const std::vector<double> &offset, int type = 0);
231 
232  /**
233  * 路径偏移失能
234  *
235  * @return 成功返回0; 失败返回错误码
236  * AUBO_BAD_STATE
237  * AUBO_BUSY
238  * -AUBO_BAD_STATE
239  *
240  * @throws arcs::common_interface::AuboException
241  *
242  * @par Python函数原型
243  * pathOffsetDisable(self: pyaubo_sdk.MotionControl) -> int
244  *
245  * @par Lua函数原型
246  * pathOffsetDisable() -> nil
247  *
248  */
249  int pathOffsetDisable();
250 
251  /**
252  * 关节偏移使能
253  *
254  * @return 成功返回0; 失败返回错误码
255  * AUBO_BAD_STATE
256  * AUBO_BUSY
257  * -AUBO_BAD_STATE
258  *
259  * @throws arcs::common_interface::AuboException
260  *
261  * @par Python函数原型
262  * jointOffsetEnable(self: pyaubo_sdk.MotionControl) -> int
263  *
264  * @par Lua函数原型
265  * jointOffsetEnable() -> nil
266  *
267  */
268  int jointOffsetEnable();
269 
270  /**
271  * 设置关节偏移
272  *
273  * @param offset 在各关节的位姿偏移
274  * @param type
275  * @return 成功返回0; 失败返回错误码
276  * AUBO_BAD_STATE
277  * AUBO_BUSY
278  * -AUBO_INVL_ARGUMENT
279  * -AUBO_BAD_STATE
280  *
281  * @throws arcs::common_interface::AuboException
282  *
283  * @par Python函数原型
284  * jointOffsetSet(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
285  * int) -> int
286  *
287  * @par Lua函数原型
288  * jointOffsetSet(offset: table, type: number) -> nil
289  *
290  */
291  int jointOffsetSet(const std::vector<double> &offset, int type = 1);
292 
293  /**
294  * 关节偏移失能
295  *
296  * @return 成功返回0; 失败返回错误码
297  * AUBO_BAD_STATE
298  * AUBO_BUSY
299  * -AUBO_BAD_STATE
300  *
301  * @throws arcs::common_interface::AuboException
302  *
303  * @par Python函数原型
304  * jointOffsetDisable(self: pyaubo_sdk.MotionControl) -> int
305  *
306  * @par Lua函数原型
307  * jointOffsetDisable() -> nil
308  *
309  */
310  int jointOffsetDisable();
311 
312  /**
313  * 获取已经入队的指令段(INST)数量，运动指令包括
314  * moveJoint/moveLine/moveCircle 等运动指令以及 setPayload 等配置指令
315  *
316  * 指令一般会在接口宏定义里面用 _INST 指示, 比如 moveJoint
317  * _INST(MotionControl, 5, moveJoint, q, a, v, blend_radius, duration)
318  *
319  * @return 已经入队的指令段数量
320  *
321  * @throws arcs::common_interface::AuboException
322  *
323  * @par Python函数原型
324  * getQueueSize(self: pyaubo_sdk.MotionControl) -> int
325  *
326  * @par Lua函数原型
327  * getQueueSize() -> number
328  *
329  */
330  int getQueueSize();
331 
332  /**
333  * 获取已经入队的运动规划插补点数量
334  *
335  * @return 已经入队的运动规划插补点数量
336  *
337  * @throws arcs::common_interface::AuboException
338  *
339  * @par Python函数原型
340  * getTrajectoryQueueSize(self: pyaubo_sdk.MotionControl) -> int
341  *
342  * @par Lua函数原型
343  * getTrajectoryQueueSize() -> number
344  *
345  */
346  int getTrajectoryQueueSize();
347 
348  /**
349  * 获取当前正在插补的运动指令段的ID
350  *
351  * @return 当前正在插补的运动指令段的ID
352  * @retval -1 表示轨迹队列为空 \n
353  * 像movePathBuffer运动中的buffer或者规划器(moveJoint和moveLine等)里的队列都属于轨迹队列
354  *
355  * @throws arcs::common_interface::AuboException
356  *
357  * @par Python函数原型
358  * getExecId(self: pyaubo_sdk.MotionControl) -> int
359  *
360  * @par Lua函数原型
361  * getExecId() -> number
362  *
363  */
364  int getExecId();
365 
366  /**
367  * 获取指定ID的运动指令段的预期执行时间
368  *
369  * @param id 运动指令段ID
370  * @return 返回预期执行时间
371  *
372  * @throws arcs::common_interface::AuboException
373  *
374  * @par Python函数原型
375  * getDuration(self: pyaubo_sdk.MotionControl, arg0: int) -> float
376  *
377  * @par Lua函数原型
378  * getDuration(id: number) -> number
379  *
380  */
381  double getDuration(int id);
382 
383  /**
384  * 获取指定ID的运动指令段的剩余执行时间
385  *
386  * @param id 运动指令段ID
387  * @return 返回剩余执行时间
388  *
389  * @throws arcs::common_interface::AuboException
390  *
391  * @par Python函数原型
392  * getMotionLeftTime(self: pyaubo_sdk.MotionControl, arg0: int) -> float
393  *
394  * @par Lua函数原型
395  * getMotionLeftTime(id: number) -> number
396  *
397  */
398  double getMotionLeftTime(int id);
399 
400  /**
401  * StopMove is used to stop robot and external axes movements and any
402  * belonging process temporarily. If the instruction StartMove is given then
403  * the movement and process resumes.
404  *
405  * This instruction can, for example, be used in a trap routine to stop the
406  * robot temporarily when an interrupt occurs.
407  *
408  * @param quick true: Stops the robot on the path as fast as possible.
409  * Without the optional parameter \Quick, the robot stops on the path, but
410  * the braking distance is longer (same as for normal Program Stop).
411  *
412  * @return 成功返回0; 失败返回错误码
413  * AUBO_BAD_STATE
414  * AUBO_BUSY
415  * -AUBO_BAD_STATE
416  *
417  * @throws arcs::common_interface::AuboException
418  *
419  */
420  int stopMove(bool quick, bool all_tasks);
421 
422  /**
423  * StartMove is used to resume robot, external axes movement and belonging
424  * process after the movement has been stopped
425  *
426  * • by the instruction StopMove.
427  * • after execution of StorePath ... RestoPath sequence.
428  * • after asynchronously raised movements errors, such as ERR_PATH_STOP or
429  * specific process error after handling in the ERROR handler.
430  *
431  * @return 成功返回0; 失败返回错误码
432  * AUBO_BAD_STATE
433  * AUBO_BUSY
434  * -AUBO_BAD_STATE
435  *
436  * @throws arcs::common_interface::AuboException
437  *
438  */
439  int startMove();
440 
441  /**
442  * storePath
443  *
444  * @param keep_sync
445  * @return 成功返回0; 失败返回错误码
446  * AUBO_BAD_STATE
447  * AUBO_BUSY
448  * -AUBO_BAD_STATE
449  *
450  * @throws arcs::common_interface::AuboException
451  *
452  */
453  int storePath(bool keep_sync);
454 
455  /**
456  * ClearPath (Clear Path) clears the whole motion path on the current motion
457  * path level (base level or StorePath level).
458  *
459  * @return 成功返回0; 失败返回错误码
460  * AUBO_BAD_STATE
461  * AUBO_BUSY
462  * -AUBO_BAD_STATE
463  *
464  * @throws arcs::common_interface::AuboException
465  *
466  */
467  int clearPath();
468 
469  /**
470  * restoPath
471  *
472  * @return 成功返回0; 失败返回错误码
473  * AUBO_BAD_STATE
474  * AUBO_BUSY
475  * -AUBO_BAD_STATE
476  *
477  * @throws arcs::common_interface::AuboException
478  *
479  */
480  int restoPath();
481 
482  /**
483  * 获取当前运动指令段的执行进度
484  *
485  * @return 返回执行进度
486  *
487  * @throws arcs::common_interface::AuboException
488  *
489  * @par Python函数原型
490  * getProgress(self: pyaubo_sdk.MotionControl) -> float
491  *
492  * @par Lua函数原型
493  * getProgress() -> number
494  *
495  */
496  double getProgress();
497 
498  /**
499  * 当工件安装在另外一台机器人的末端或者外部轴上时，指定其名字和安装位置
500  *
501  * @note 暂未实现
502  *
503  * @param module_name 控制模块名字
504  * @param mounting_pose 抓取的相对位置，
505  * 如果是机器人，则相对于机器人末端中心点（非TCP点）
506  * @return 成功返回0; 失败返回错误码
507  * AUBO_BAD_STATE
508  * AUBO_BUSY
509  * -AUBO_INVL_ARGUMENT
510  * -AUBO_BAD_STATE
511  *
512  * @throws arcs::common_interface::AuboException
513  *
514  * @par Python函数原型
515  * setWorkObjectHold(self: pyaubo_sdk.MotionControl, arg0: str, arg1:
516  * List[float]) -> int
517  *
518  * @par Lua函数原型
519  * setWorkObjectHold(module_name: string, mounting_pose: table) -> nil
520  *
521  */
522  int setWorkObjectHold(const std::string &module_name,
523  const std::vector<double> &mounting_pose);
524 
525  /**
526  * getWorkObjectHold
527  *
528  * @note 暂未实现
529  *
530  * @return
531  *
532  * @throws arcs::common_interface::AuboException
533  *
534  * @par Python函数原型
535  * getWorkObjectHold(self: pyaubo_sdk.MotionControl) -> Tuple[str,
536  * List[float]]
537  *
538  * @par Lua函数原型
539  * getWorkObjectHold() -> table
540  *
541  */
542  std::tuple<std::string, std::vector<double>> getWorkObjectHold();
543 
544  /**
545  * getPauseJointPositions
546  *
547  * @note 获取暂停点关节位置
548  * 常用于运行工程时发生碰撞后继续运动过程中(先通过resumeMoveJoint或resumeMoveLine运动到暂停位置,再恢复工程)
549  *
550  * @return 暂停关节位置
551  *
552  * @throws arcs::common_interface::AuboException
553  *
554  * @par Python函数原型
555  * getPauseJointPositions(self: pyaubo_sdk.MotionControl) -> List[float]
556  *
557  * @par Lua函数原型
558  * getPauseJointPositions() -> table
559  */
560  std::vector<double> getPauseJointPositions();
561 
562  /**
563  * 设置伺服模式
564  * 使用 setServoModeSelect 替代
565  *
566  * @param enable 是否使能
567  * @return 成功返回0; 失败返回错误码
568  * AUBO_BAD_STATE
569  * AUBO_BUSY
570  * -AUBO_BAD_STATE
571  *
572  * @throws arcs::common_interface::AuboException
573  *
574  * @par Python函数原型
575  * setServoMode(self: pyaubo_sdk.MotionControl, arg0: bool) -> int
576  *
577  * @par Lua函数原型
578  * setServoMode(enable: boolean) -> nil
579  *
580  */
581  ARCS_DEPRECATED int setServoMode(bool enable);
582 
583  /**
584  * 判断伺服模式是否使能
585  * 使用 getServoModeSelect 替代
586  *
587  * @return 已使能返回true，反之则返回false
588  *
589  * @throws arcs::common_interface::AuboException
590  *
591  * @par Python函数原型
592  * isServoModeEnabled(self: pyaubo_sdk.MotionControl) -> bool
593  *
594  * @par Lua函数原型
595  * isServoModeEnabled() -> boolean
596  *
597  */
598  ARCS_DEPRECATED bool isServoModeEnabled();
599 
600  /**
601  * 设置伺服运动模式
602  *
603  * @param mode 0-退出伺服模式 1-规划伺服模式 2-透传模式
604  * @return
605  */
606  int setServoModeSelect(int mode);
607 
608  /**
609  * 获取伺服运动模式
610  *
611  * @return
612  */
613  int getServoModeSelect();
614 
615  /**
616  * 关节空间伺服
617  *
618  * 目前可用参数只有 q 和 t;
619  * @param q 关节角, 单位 rad,
620  * @param a 加速度, 单位 rad/s^2,
621  * @param v 速度，单位 rad/s,
622  * @param t 运行时间，单位 s \n
623  * t 值越大,机器臂运动越慢,反之，运动越快;
624  * 该参数最优值为连续调用 servoJoint 接口的间隔时间。
625  * @param lookahead_time 前瞻时间，单位 s \n
626  * 指定机器臂开始减速前要运动的时长，用前瞻时间来平滑轨迹[0.03, 0.2],
627  * 当 lookahead_time 小于一个控制周期时，越小则超调量越大,
628  * 该参数最优值为一个控制周期。
629  * @param gain 比例增益
630  * 跟踪目标位置的比例增益[100, 200],
631  * 用于控制运动的顺滑性和精度,
632  * 比例增益越大，到达目标位置的时间越长，超调量越小。
633  *
634  * @return 成功返回0；失败返回错误码，正数为警告，负数为错误。
635  * AUBO_BAD_STATE(1): 当前安全模式处于非 Normal、ReducedMode、Recovery 状态;
636  * AUBO_BUSY(3): 上一条指令正在执行中;
637  * AUBO_QUEUE_FULL(2): 轨迹队列已满;
638  * -AUBO_REQUEST_IGNORE(-13): 当前处于非 servo 模式;
639  * -AUBO_BAD_STATE(-1): 当前机器臂模式处于 Running 状态;
640  * -AUBO_INVL_ARGUMENT(-5): 轨迹位置超限或速度超限;
641  *
642  * @throws arcs::common_interface::AuboException
643  *
644  * @par Python函数原型
645  * servoJoint(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
646  * float, arg2: float, arg3: float, arg4: float, arg5: float) -> int
647  *
648  * @par Lua函数原型
649  * servoJoint(q: table, a: number, v: number, t: number, lookahead_time:
650  * number, gain: number) -> nil
651  *
652  */
653  int servoJoint(const std::vector<double> &q, double a, double v, double t,
654  double lookahead_time, double gain);
655 
656  /**
657  * 笛卡尔空间伺服
658  *
659  * 目前可用参数只有 pose 和 t;
660  * @param pose 位姿, 单位 m,
661  * @param a 加速度, 单位 m/s^2,
662  * @param v 速度，单位 m/s,
663  * @param t 运行时间，单位 s \n
664  * t 值越大,机器臂运动越慢,反之，运动越快;
665  * 该参数最优值为连续调用 servoCartesian 接口的间隔时间。
666  * @param lookahead_time 前瞻时间，单位 s \n
667  * 指定机器臂开始减速前要运动的时长，用前瞻时间来平滑轨迹[0.03, 0.2],
668  * 当 lookahead_time 小于一个控制周期时，越小则超调量越大,
669  * 该参数最优值为一个控制周期。
670  * @param gain 比例增益
671  * 跟踪目标位置的比例增益[100, 200],
672  * 用于控制运动的顺滑性和精度,
673  * 比例增益越大，到达目标位置的时间越长，超调量越小。
674  *
675  * @return 成功返回0；失败返回错误码，正数为警告，负数为错误。
676  * AUBO_BAD_STATE(1): 当前安全模式处于非 Normal、ReducedMode、Recovery 状态;
677  * AUBO_BUSY(3): 上一条指令正在执行中;
678  * AUBO_QUEUE_FULL(2): 轨迹队列已满;
679  * -AUBO_REQUEST_IGNORE(-13): 当前处于非 servo 模式;
680  * -AUBO_BAD_STATE(-1): 当前机器臂模式处于 Running 状态;
681  * -AUBO_INVL_ARGUMENT(-5): 轨迹位置超限或速度超限;
682  * -AUBO_IK_NO_CONVERGE(-23): 逆解计算不收敛，计算出错;
683  * -AUBO_IK_OUT_OF_RANGE(-24): 逆解计算超出机器人最大限制;
684  * -AUBO_IK_CONFIG_DISMATCH(-25): 逆解输入配置存在错误;
685  * -AUBO_IK_JACOBIAN_FAILED(-26): 逆解雅可比矩阵计算失败;
686  * -AUBO_IK_NO_SOLU(-27): 目标点存在解析解，但均不满足选解条件;
687  * -AUBO_IK_UNKOWN_ERROR(-28): 逆解返回未知类型错误;
688  *
689  * @throws arcs::common_interface::AuboException
690  *
691  * @par Python函数原型
692  * servoCartesian(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
693  * float, arg2: float, arg3: float, arg4: float, arg5: float) -> int
694  *
695  * @par Lua函数原型
696  * servoCartesian(pose: table, a: number, v: number, t: number,
697  * lookahead_time: number, gain: number) -> nil
698  *
699  */
700  int servoCartesian(const std::vector<double> &pose, double a, double v,
701  double t, double lookahead_time, double gain);
702 
703  /**
704  * 伺服运动（带外部轴），用于执行离线轨迹、透传用户规划轨迹等
705  *
706  * @param q
707  * @param extq
708  * @param t
709  * @param smooth_scale
710  * @param delay_sacle
711  * @return
712  */
713  int servoJointWithAxes(const std::vector<double> &q,
714  const std::vector<double> &extq, double a, double v,
715  double t, double lookahead_time, double gain);
716 
717  /**
718  * 伺服运动（带外部轴），用于执行离线轨迹、透传用户规划轨迹等
719  * 与 servoJointWithAxes 区别在于接收笛卡尔空间位姿而不是关节角度
720  * (由软件内部直接做逆解)
721  *
722  * @param pose
723  * @param extq
724  * @param t
725  * @param smooth_scale
726  * @param delay_sacle
727  * @return
728  */
729  int servoCartesianWithAxes(const std::vector<double> &pose,
730  const std::vector<double> &extq, double a,
731  double v, double t, double lookahead_time,
732  double gain);
733 
734  /**
735  * 跟踪运动，用于执行离线轨迹、透传用户规划轨迹等
736  *
737  * @param q
738  * @param smooth_scale
739  * @param delay_sacle
740  * @return
741  */
742  int trackJoint(const std::vector<double> &q, double t, double smooth_scale,
743  double delay_sacle);
744 
745  /**
746  * 跟踪运动，用于执行离线轨迹、透传用户规划轨迹等
747  * 与 trackJoint 区别在于接收笛卡尔空间位姿而不是关节角度
748  * (由软件内部直接做逆解)
749  *
750  * @param pose
751  * @param t
752  * @param smooth_scale
753  * @param delay_sacle
754  * @return
755  */
756  int trackCartesian(const std::vector<double> &pose, double t,
757  double smooth_scale, double delay_sacle);
758 
759  /**
760  * 关节空间跟随
761  *
762  * @note 暂未实现
763  *
764  * @throws arcs::common_interface::AuboException
765  *
766  * @par Python函数原型
767  * followJoint(self: pyaubo_sdk.MotionControl, arg0: List[float]) -> int
768  *
769  * @par Lua函数原型
770  * followJoint(q: table) -> nil
771  *
772  */
773  int followJoint(const std::vector<double> &q);
774 
775  /**
776  * 笛卡尔空间跟随
777  *
778  * @note 暂未实现
779  *
780  * @throws arcs::common_interface::AuboException
781  *
782  * @par Python函数原型
783  * followLine(self: pyaubo_sdk.MotionControl, arg0: List[float]) -> int
784  *
785  * @par Lua函数原型
786  * followLine(pose: table) -> nil
787  *
788  */
789  int followLine(const std::vector<double> &pose);
790 
791  /**
792  * 关节空间速度跟随
793  *
794  * 当机械臂还没达到目标速度的时候，给一个新的目标速度，机械臂会立刻达到新的目标速度
795  *
796  * @param qd 目标关节速度, 单位 rad/s
797  * @param a 主轴的加速度, 单位 rad/s^2
798  * @param t 函数返回所需要的时间, 单位 s \n
799  * 如果 t = 0，当达到目标速度的时候，函数将返回；
800  * 反之，则经过 t 时间后，函数返回，不管是否达到目标速度。\n
801  * 如果没有达到目标速度，会减速到零。
802  * 如果达到了目标速度就是按照目标速度匀速运动。
803  * @return 成功返回0; 失败返回错误码，正数为警告，负数为错误。
804  * AUBO_BAD_STATE(1): 当前安全模式处于非 Normal、ReducedMode、Recovery 状态;
805  * AUBO_BUSY(3): 上一条指令正在执行中;
806  * -AUBO_INVL_ARGUMENT(-5): 参数数组qd的长度小于当前机器臂的自由度;
807  * -AUBO_BAD_STATE(-1): 当前机器臂模式处于 Running 状态;
808  *
809  * @throws arcs::common_interface::AuboException
810  *
811  * @par Python函数原型
812  * speedJoint(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
813  * float, arg2: float) -> int
814  *
815  * @par Lua函数原型
816  * speedJoint(qd: table, a: number, t: number) -> nil
817  *
818  */
819  int speedJoint(const std::vector<double> &qd, double a, double t);
820 
821  /**
822  * 关节空间速度跟随(机械臂运行工程时发生碰撞,通过此接口移动到安全位置)
823  *
824  * 当机械臂还没达到目标速度的时候，给一个新的目标速度，机械臂会立刻达到新的目标速度
825  *
826  * @param qd 目标关节速度, 单位 rad/s
827  * @param a 主轴的加速度, 单位 rad/s^2
828  * @param t 函数返回所需要的时间, 单位 s
829  * 如果 t = 0，当达到目标速度的时候，函数将返回；
830  * 反之，则经过 t 时间后，函数返回，不管是否达到目标速度。
831  * 如果没有达到目标速度，会减速到零。
832  * 如果达到了目标速度就是按照目标速度匀速运动。
833  * @return 成功返回0; 失败返回错误码
834  * AUBO_BUSY
835  * -AUBO_INVL_ARGUMENT
836  * -AUBO_BAD_STATE
837  *
838  * @throws arcs::common_interface::AuboException
839  *
840  * @par Python函数原型
841  * resumeSpeedJoint(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
842  * float, arg2: float) -> int
843  *
844  *
845  * @par Lua函数原型
846  * resumeSpeedJoint(q: table, a: number, t: number) -> nil
847  *
848  */
849  int resumeSpeedJoint(const std::vector<double> &qd, double a, double t);
850 
851  /**
852  * 笛卡尔空间速度跟随
853  *
854  * 当机械臂还没达到目标速度的时候，给一个新的目标速度，机械臂会立刻达到新的目标速度
855  *
856  * @param xd 工具速度, 单位 m/s
857  * @param a 工具位置加速度, 单位 m/s^2
858  * @param t 函数返回所需要的时间, 单位 s \n
859  * 如果 t = 0，当达到目标速度的时候，函数将返回；
860  * 反之，则经过 t 时间后，函数返回，不管是否达到目标速度。
861  * 如果没有达到目标速度，会减速到零。
862  * 如果达到了目标速度就是按照目标速度匀速运动。
863  * @return 成功返回0; 失败返回错误码
864  * AUBO_BUSY(3): 上一条指令正在执行中;
865  * AUBO_BAD_STATE(1): 当前安全模式处于非 Normal、ReducedMode、Recovery 状态;
866  * -AUBO_BAD_STATE(-1): 当前机器臂模式处于 Running 状态;
867  *
868  * @throws arcs::common_interface::AuboException
869  *
870  * @par Python函数原型
871  * speedLine(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1: float,
872  * arg2: float) -> int
873  *
874  * @par Lua函数原型
875  * speedLine(pose: table, a: number, t: number) -> nil
876  *
877  */
878  int speedLine(const std::vector<double> &xd, double a, double t);
879 
880  /**
881  * 笛卡尔空间速度跟随(机械臂运行工程时发生碰撞,通过此接口移动到安全位置)
882  *
883  * 当机械臂还没达到目标速度的时候，给一个新的目标速度，机械臂会立刻达到新的目标速度
884  *
885  * @param xd 工具速度, 单位 m/s
886  * @param a 工具位置加速度, 单位 m/s^2
887  * @param t 函数返回所需要的时间, 单位 s \n
888  * 如果 t = 0，当达到目标速度的时候，函数将返回；
889  * 反之，则经过 t 时间后，函数返回，不管是否达到目标速度。
890  * 如果没有达到目标速度，会减速到零。
891  * 如果达到了目标速度就是按照目标速度匀速运动。
892  * @return 成功返回0; 失败返回错误码
893  * -AUBO_BAD_STATE
894  *
895  * @throws arcs::common_interface::AuboException
896  *
897  * @par Python函数原型
898  * resumeSpeedLine(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
899  * float, arg2: float) -> int
900  *
901  * @par Lua函数原型
902  * resumeSpeedLine(pose: table, a: number, t: number) -> nil
903  *
904  */
905  int resumeSpeedLine(const std::vector<double> &xd, double a, double t);
906 
907  /**
908  * 在关节空间做样条插值
909  *
910  * @param q 关节角度，如果传入参数维度为0，表示样条运动结束
911  * @param a 加速度, 单位 rad/s^2,
912  * 最大值可通过RobotConfig类中的接口getJointMaxAccelerations()来获取
913  * @param v 速度， 单位 rad/s,
914  * 最大值可通过RobotConfig类中的接口getJointMaxSpeeds()来获取
915  * @param duration
916  * @return 成功返回0; 失败返回错误码
917  * AUBO_BUSY
918  * AUBO_BAD_STATE
919  * -AUBO_BAD_STATE
920  *
921  * @throws arcs::common_interface::AuboException
922  *
923  * @par Python函数原型
924  * moveSpline(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
925  * float, arg2: float, arg3: float) -> int
926  *
927  * @par Lua函数原型
928  * moveSpline(q: table, a: number, v: number, duration: number) -> nil
929  *
930  */
931  int moveSpline(const std::vector<double> &q, double a, double v,
932  double duration);
933 
934  /**
935  * 添加关节运动
936  *
937  * @param q 关节角, 单位 rad
938  * @param a 加速度, 单位 rad/s^2,
939  * 最大值可通过RobotConfig类中的接口getJointMaxAccelerations()来获取
940  * @param v 速度， 单位 rad/s,
941  * 最大值可通过RobotConfig类中的接口getJointMaxSpeeds()来获取
942  * @param blend_radius 交融半径, 单位 m
943  * @param duration 运行时间，单位 s \n
944  * 通常当给定了速度和加速度，便能够确定轨迹的运行时间。
945  * 如果想延长轨迹的运行时间，便要设置 duration 这个参数。
946  * duration 可以延长轨迹运动的时间，但是不能缩短轨迹时间。\n
947  * 当 duration = 0的时候，
948  * 表示不指定运行时间，即没有明确完成运动的时间，将根据速度与加速度计算运行时间。
949  * 如果duration不等于0，a 和 v 的值将被忽略。
950  * @return 成功返回0；失败返回错误码，正数为警告，负数为错误。
951  * AUBO_BAD_STATE(1): 当前安全模式处于非 Normal、ReducedMode、Recovery 状态;
952  * AUBO_BUSY(3): 上一条指令正在执行中;
953  * -AUBO_INVL_ARGUMENT(-5): 参数数组q的长度小于当前机器臂的自由度;
954  * -AUBO_BAD_STATE(-1): 当前机器臂模式处于 Running 状态;
955  *
956  * @throws arcs::common_interface::AuboException
957  *
958  * @par Python函数原型
959  * moveJoint(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1: float,
960  * arg2: float, arg3: float, arg4: float) -> int
961  *
962  * @par Lua函数原型
963  * moveJoint(q: table, a: number, v: number, blend_radius: number, duration:
964  * number) -> nil
965  *
966  * @par JSON-RPC请求示例
967  * {"jsonrpc":"2.0","method":"rob1.MotionControl.moveJoint","params":[[-2.05177,
968  * -0.400292, 1.19625, 0.0285152, 1.57033, -2.28774],0.3,0.3,0,0],"id":1}
969  *
970  * @par JSON-RPC响应示例
971  * {"id":1,"jsonrpc":"2.0","result":0}
972  */
973  int moveJoint(const std::vector<double> &q, double a, double v,
974  double blend_radius, double duration);
975 
976  /**
977  * 通过关节运动移动到暂停点的位置
978  *
979  * @param q 关节角, 单位 rad
980  * @param a 加速度, 单位 rad/s^2
981  * @param v 速度， 单位 rad/s
982  * @param duration 运行时间，单位 s \n
983  * 通常当给定了速度和加速度，便能够确定轨迹的运行时间。
984  * 如果想延长轨迹的运行时间，便要设置 duration 这个参数。
985  * duration 可以延长轨迹运动的时间，但是不能缩短轨迹时间。\n
986  * 当 duration = 0的时候，
987  * 表示不指定运行时间，即没有明确完成运动的时间，将根据速度与加速度计算运行时间。
988  * 如果duration不等于0，a 和 v 的值将被忽略。
989  * @return 成功返回0；失败返回错误码
990  * -AUBO_INVL_ARGUMENT
991  * -AUBO_BAD_STATE
992  *
993  * @throws arcs::common_interface::AuboException
994  *
995  * @par Python函数原型
996  * resumeMoveJoint(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
997  * float, arg2: float, arg3: float) -> int
998  *
999  * @par Lua函数原型
1000  * resumeMoveJoint(q: table, a: number, v: number, duration: number) -> nil
1001  *
1002  */
1003  int resumeMoveJoint(const std::vector<double> &q, double a, double v,
1004  double duration);
1005 
1006  /**
1007  * 添加直线运动
1008  *
1009  * @param pose 目标位姿
1010  * @param a 加速度(如果位置变化小于1mm,姿态变化大于 1e-4
1011  * rad,此加速度会被作为角加速度,单位 rad/s^2.否则为线加速度,单位 m/s^2)
1012  * 最大值可通过RobotConfig类中的接口getTcpMaxAccelerations()来获取
1013  * @param v 速度(如果位置变化小于1mm,姿态变化大于 1e-4
1014  * rad,此速度会被作为角速度,单位 rad/s.否则为线速度,单位 m/s)
1015  * 最大值可通过RobotConfig类中的接口getTcpMaxSpeeds()来获取
1016  * @param blend_radius 交融半径，单位 m，值介于0.001和1之间
1017  * @param duration 运行时间，单位 s \n
1018  * 通常当给定了速度和加速度，便能够确定轨迹的运行时间。
1019  * 如果想延长轨迹的运行时间，便要设置 duration 这个参数。
1020  * duration 可以延长轨迹运动的时间，但是不能缩短轨迹时间。\n
1021  * 当 duration = 0的时候，
1022  * 表示不指定运行时间，即没有明确完成运动的时间，将根据速度与加速度计算运行时间。
1023  * 如果duration不等于0，a 和 v 的值将被忽略。
1024  * @return 成功返回0；失败返回错误码，正数为警告，负数为错误。
1025  * AUBO_BAD_STATE(1): 当前安全模式处于非 Normal、ReducedMode、Recovery 状态;
1026  * AUBO_BUSY(3): 上一条指令正在执行中;
1027  * -AUBO_INVL_ARGUMENT(-5): 参数数组 pose 的长度小于当前机器臂的自由度;
1028  * -AUBO_BAD_STATE(-1): 当前机器臂模式处于 Running 状态;
1029  *
1030  * @throws arcs::common_interface::AuboException
1031  *
1032  * @par Python函数原型
1033  * moveLine(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1: float,
1034  * arg2: float, arg3: float, arg4: float) -> int
1035  *
1036  * @par Lua函数原型
1037  * moveLine(pose: table, a: number, v: number, blend_radius: number,
1038  * duration: number) -> nil
1039  *
1040  */
1041  int moveLine(const std::vector<double> &pose, double a, double v,
1042  double blend_radius, double duration);
1043 
1044  /**
1045  * 添加工艺运动
1046  *
1047  * @param pose
1048  * @param a
1049  * @param v
1050  * @param blend_radius
1051  * @return 成功返回0；失败返回错误码
1052  * AUBO_BAD_STATE
1053  * AUBO_BUSY
1054  * -AUBO_INVL_ARGUMENT
1055  * -AUBO_BAD_STATE
1056  *
1057  * @throws arcs::common_interface::AuboException
1058  *
1059  */
1060  int moveProcess(const std::vector<double> &pose, double a, double v,
1061  double blend_radius);
1062 
1063  /**
1064  * 通过直线运动移动到暂停点的位置
1065  *
1066  * @param pose 目标位姿
1067  * @param a 加速度, 单位 m/s^2
1068  * @param v 速度, 单位 m/s
1069  * @param duration 运行时间，单位 s \n
1070  * 通常当给定了速度和加速度，便能够确定轨迹的运行时间。
1071  * 如果想延长轨迹的运行时间，便要设置 duration 这个参数。
1072  * duration 可以延长轨迹运动的时间，但是不能缩短轨迹时间。\n
1073  * 当 duration = 0的时候，
1074  * 表示不指定运行时间，即没有明确完成运动的时间，将根据速度与加速度计算运行时间。
1075  * 如果duration不等于0，a 和 v 的值将被忽略。
1076  * @return 成功返回0；失败返回错误码
1077  * -AUBO_INVL_ARGUMENT
1078  * -AUBO_BAD_STATE
1079  *
1080  * @throws arcs::common_interface::AuboException
1081  *
1082  * @par Python函数原型
1083  * resumeMoveLine(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
1084  * float, arg2: float, arg3: float) -> int
1085  *
1086  * @par Lua函数原型
1087  * resumeMoveLine(pose: table, a: number, v: number,duration: number) -> nil
1088  *
1089  */
1090  int resumeMoveLine(const std::vector<double> &pose, double a, double v,
1091  double duration);
1092 
1093  /**
1094  * 添加圆弧运动
1095  *
1096  * @todo 可以由多段圆弧组成圆周运动
1097  *
1098  * @param via_pose 圆弧运动途中点的位姿
1099  * @param end_pose 圆弧运动结束点的位姿
1100  * @param a 加速度(如果via_pose与上一个路点位置变化小于1mm,姿态变化大于 1e-4
1101  * rad, 此加速度会被作为角加速度,单位 rad/s^2.否则为线加速度,单位 m/s^2)
1102  * @param v 速度(如果via_pose与上一个路点位置变化小于1mm, 姿态变化大于 1e-4
1103  * rad, 此速度会被作为角速度, 单位 rad / s.否则为线速度, 单位 m / s)
1104  * @param blend_radius 交融半径，单位: m
1105  * @param duration 运行时间，单位: s \n
1106  * 通常当给定了速度和加速度，便能够确定轨迹的运行时间。
1107  * 如果想延长轨迹的运行时间，便要设置 duration 这个参数。
1108  * duration 可以延长轨迹运动的时间，但是不能缩短轨迹时间。\n
1109  * 当 duration = 0 的时候，
1110  * 表示不指定运行时间，即没有明确完成运动的时间，将根据速度与加速度计算运行时间。
1111  * 如果duration不等于0，a 和 v 的值将被忽略。
1112  * @return 成功返回0；失败返回错误码
1113  * AUBO_BAD_STATE
1114  * AUBO_BUSY
1115  * -AUBO_INVL_ARGUMENT
1116  * -AUBO_BAD_STATE
1117  *
1118  * @throws arcs::common_interface::AuboException
1119  *
1120  * @par Python函数原型
1121  * moveCircle(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
1122  * List[float], arg2: float, arg3: float, arg4: float, arg5: float) -> int
1123  *
1124  * @par Lua函数原型
1125  * moveCircle(via_pose: table, end_pose: table, a: number, v: number,
1126  * blend_radius: number, duration: number) -> nil
1127  *
1128  */
1129  int moveCircle(const std::vector<double> &via_pose,
1130  const std::vector<double> &end_pose, double a, double v,
1131  double blend_radius, double duration);
1132 
1133  /**
1134  * 设置圆弧路径模式
1135  *
1136  * @param mode 模式 \n
1137  * 0:工具姿态相对于圆弧路径点坐标系保持不变 \n
1138  * 1:姿态线性变化,绕着空间定轴转动,从起始点姿态变化到目标点姿态 \n
1139  * 2:从起点姿态开始经过中间点姿态,变化到目标点姿态
1140  * @return 成功返回0；失败返回错误码
1141  * AUBO_BAD_STATE
1142  * AUBO_BUSY
1143  * -AUBO_INVL_ARGUMENT
1144  * -AUBO_BAD_STATE
1145  *
1146  * @throws arcs::common_interface::AuboException
1147  *
1148  * @par Python函数原型
1149  * setCirclePathMode(self: pyaubo_sdk.MotionControl, arg0: int) -> int
1150  *
1151  * @par Lua函数原型
1152  * setCirclePathMode(mode: number) -> nil
1153  *
1154  */
1155  int setCirclePathMode(int mode);
1156 
1157  /**
1158  * 高级圆弧或者圆周运动
1159  *
1160  * @param param 圆周运动参数
1161  * @return 成功返回0；失败返回错误码
1162  * AUBO_BAD_STATE
1163  * AUBO_BUSY
1164  * -AUBO_INVL_ARGUMENT
1165  * -AUBO_BAD_STATE
1166  *
1167  * @throws arcs::common_interface::AuboException
1168  *
1169  * @par Python函数原型
1170  * moveCircle2(self: pyaubo_sdk.MotionControl, arg0:
1171  * arcs::common_interface::CircleParameters) -> int
1172  *
1173  * @par Lua函数原型
1174  * moveCircle2(param: table) -> nil
1175  *
1176  */
1177  int moveCircle2(const CircleParameters &param);
1178 
1179  /**
1180  * 新建一个路径点缓存
1181  *
1182  * @param name 指定路径的名字
1183  * @param type 路径的类型 \n
1184  * 1: toppra 时间最优路径规划 \n
1185  * 2: cubic_spline(录制的轨迹) \n
1186  * 3: 关节B样条插值，最少三个点
1187  * @param size 缓存区大小
1188  * @return 新建成功返回 AUBO_OK(0)
1189  *
1190  * @throws arcs::common_interface::AuboException
1191  *
1192  * @par Python函数原型
1193  * pathBufferAlloc(self: pyaubo_sdk.MotionControl, arg0: str, arg1: int,
1194  * arg2: int) -> int
1195  *
1196  * @par Lua函数原型
1197  * pathBufferAlloc(name: string, type: number, size: number) -> nil
1198  *
1199  */
1200  int pathBufferAlloc(const std::string &name, int type, int size);
1201 
1202  /**
1203  * 向路径缓存添加路点
1204  *
1205  * @param name 路径缓存的名字
1206  * @param waypoints 路点
1207  * @return 成功返回0；失败返回错误码
1208  * -AUBO_INVL_ARGUMENT
1209  * -AUBO_BAD_STATE
1210  *
1211  * @throws arcs::common_interface::AuboException
1212  *
1213  * @par Python函数原型
1214  * pathBufferAppend(self: pyaubo_sdk.MotionControl, arg0: str, arg1:
1215  * List[List[float]]) -> int
1216  *
1217  * @par Lua函数原型
1218  * pathBufferAppend(name: string, waypoints: table) -> nil
1219  *
1220  */
1221  int pathBufferAppend(const std::string &name,
1222  const std::vector<std::vector<double>> &waypoints);
1223 
1224  /**
1225  * 计算、优化等耗时操作，传入的参数相同时不会重新计算
1226  *
1227  * @param name 通过pathBufferAlloc新建的路径点缓存的名字
1228  * @param a 关节加速度限制,需要和机器人自由度大小相同,单位 m/s^2
1229  * @param v 关节速度限制,需要和机器人自由度大小相同,单位 m/s
1230  * @param t 时间 \n
1231  * pathBufferAlloc 这个接口分配内存的时候要指定类型，
1232  * 根据pathBufferAlloc这个接口的类型:\n
1233  * 类型为1时,表示运动持续时间\n
1234  * 类型为2时,表示采样时间间隔\n
1235  * 类型为3时,t参数设置为0
1236  * @return 成功返回0；失败返回错误码
1237  * -AUBO_INVL_ARGUMENT
1238  * -AUBO_BAD_STATE
1239  *
1240  * @throws arcs::common_interface::AuboException
1241  *
1242  * @par Python函数原型
1243  * pathBufferEval(self: pyaubo_sdk.MotionControl, arg0: str, arg1:
1244  * List[float], arg2: List[float], arg3: float) -> int
1245  *
1246  * @par Lua函数原型
1247  * pathBufferEval(name: string, a: table, v: table, t: number) -> nil
1248  *
1249  */
1250  int pathBufferEval(const std::string &name, const std::vector<double> &a,
1251  const std::vector<double> &v, double t);
1252 
1253  /**
1254  * 指定名字的buffer是否有效
1255  *
1256  * buffer需要满足三个条件有效: \n
1257  * 1、buffer存在，已经分配过内存 \n
1258  * 2、传进buffer的点要大于等于buffer的大小 \n
1259  * 3、要执行一次pathBufferEval
1260  *
1261  * @param name buffer的名字
1262  * @return 有效返回true; 无效返回false
1263  *
1264  * @throws arcs::common_interface::AuboException
1265  *
1266  * @par Python函数原型
1267  * pathBufferValid(self: pyaubo_sdk.MotionControl, arg0: str) -> bool
1268  *
1269  * @par Lua函数原型
1270  * pathBufferValid(name: string) -> boolean
1271  *
1272  */
1273  bool pathBufferValid(const std::string &name);
1274 
1275  /**
1276  * 释放路径缓存
1277  *
1278  * @param name 缓存路径的名字
1279  * @return 成功返回0；失败返回错误码
1280  * -AUBO_INVL_ARGUMENT
1281  * -AUBO_BAD_STATE
1282  *
1283  * @throws arcs::common_interface::AuboException
1284  *
1285  * @par Python函数原型
1286  * pathBufferFree(self: pyaubo_sdk.MotionControl, arg0: str) -> int
1287  *
1288  * @par Lua函数原型
1289  * pathBufferFree(name: string) -> nil
1290  *
1291  */
1292  int pathBufferFree(const std::string &name);
1293 
1294  /**
1295  * 列出所有缓存路径的名字
1296  *
1297  * @return 返回所有缓存路径的名字
1298  *
1299  * @throws arcs::common_interface::AuboException
1300  *
1301  * @par Python函数原型
1302  * pathBufferList(self: pyaubo_sdk.MotionControl) -> List[str]
1303  *
1304  * @par Lua函数原型
1305  * pathBufferList() -> table
1306  *
1307  */
1308  std::vector<std::string> pathBufferList();
1309 
1310  /**
1311  * 执行缓存的路径
1312  *
1313  * @param name 缓存路径的名字
1314  * @return 成功返回0；失败返回错误码
1315  * -AUBO_INVL_ARGUMENT
1316  * -AUBO_BAD_STATE
1317  *
1318  * @throws arcs::common_interface::AuboException
1319  *
1320  * @par Python函数原型
1321  * movePathBuffer(self: pyaubo_sdk.MotionControl, arg0: str) -> int
1322  *
1323  * @par Lua函数原型
1324  * movePathBuffer(name: string) -> nil
1325  *
1326  */
1327  int movePathBuffer(const std::string &name);
1328 
1329  /**
1330  * 相贯线接口
1331  *
1332  * @param pose由三个示教位姿组成(首先需要运动到起始点,起始点的要求:过主圆柱
1333  * 柱体轴心且与子圆柱体轴线平行的平面与子圆柱体在底部的交点)
1334  * p1:过子圆柱体轴线且与大圆柱体轴线平行的平面,与小圆柱体在左侧顶部的交点
1335  * p2:过子圆柱体轴线且与大圆柱体轴线平行的平面,与大圆柱体在左侧底部的交点
1336  * p3:过子圆柱体轴线且与大圆柱体轴线平行的平面,与大圆柱体在右侧底部的交点
1337  * @param v:速度
1338  * @param a:加速度
1339  * @param main_pipe_radius: 主圆柱体半径
1340  * @param sub_pipe_radius: 子圆柱体半径
1341  * @param normal_distance: 两圆柱体轴线距离
1342  * @param normal_alpha: 两圆柱体轴线的夹角
1343  *
1344  * @return 成功返回0；失败返回错误码
1345  * AUBO_BUSY
1346  * AUBO_BAD_STATE
1347  * -AUBO_INVL_ARGUMENT
1348  * -AUBO_BAD_STATE
1349  *
1350  * @throws arcs::common_interface::AuboException
1351  *
1352  * @par Python函数原型
1353  * moveIntersection(self: pyaubo_sdk.MotionControl, arg0: List[float], arg1:
1354  float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float) ->
1355  int
1356  *
1357  * @par Lua函数原型
1358  * moveIntersection(poses: table, a: number, v: number,
1359  * main_pipe_radius:number, sub_pipe_radius: number,normal_distance:
1360  * number,normal_alpha: number,) -> nil
1361  */
1362  int moveIntersection(const std::vector<std::vector<double>> &poses,
1363  double a, double v, double main_pipe_radius,
1364  double sub_pipe_radius, double normal_distance,
1365  double normal_alpha);
1366  /**
1367  * 关节空间停止运动
1368  *
1369  * @param acc 关节加速度，单位: rad/s^2
1370  * @return 成功返回0；失败返回错误码
1371  * AUBO_BUSY
1372  * AUBO_BAD_STATE
1373  * -AUBO_INVL_ARGUMENT
1374  * -AUBO_BAD_STATE
1375  *
1376  * @throws arcs::common_interface::AuboException
1377  *
1378  * @par Python函数原型
1379  * stopJoint(self: pyaubo_sdk.MotionControl, arg0: float) -> int
1380  *
1381  * @par Lua函数原型
1382  * stopJoint(acc: number) -> nil
1383  *
1384  */
1385  int stopJoint(double acc);
1386 
1387  /**
1388  * 关节空间停止运动(机械臂运行工程时发生碰撞,通过resumeSpeedJoint接口移动到安全位置后需要停止时调用此接口)
1389  *
1390  * @param acc 关节加速度，单位: rad/s^2
1391  * @return 成功返回0；失败返回错误码
1392  * AUBO_BUSY
1393  * AUBO_BAD_STATE
1394  * -AUBO_INVL_ARGUMENT
1395  * -AUBO_BAD_STATE
1396  *
1397  * @throws arcs::common_interface::AuboException
1398  *
1399  * @par Python函数原型
1400  * resumeStopJoint(self: pyaubo_sdk.MotionControl, arg0: float) -> int
1401  *
1402  * @par Lua函数原型
1403  * resumeStopJoint(acc: number) -> nil
1404  *
1405  */
1406  int resumeStopJoint(double acc);
1407 
1408  /**
1409  * 笛卡尔空间停止运动
1410  *
1411  * @param acc 工具加速度, 单位: m/s^2
1412  * @param acc_rot
1413  * @return 成功返回0；失败返回错误码
1414  * AUBO_BUSY
1415  * AUBO_BAD_STATE
1416  * -AUBO_INVL_ARGUMENT
1417  * -AUBO_BAD_STATE
1418  *
1419  * @throws arcs::common_interface::AuboException
1420  *
1421  * @par Python函数原型
1422  * stopLine(self: pyaubo_sdk.MotionControl, arg0: float, arg1: float) -> int
1423  *
1424  * @par Lua函数原型
1425  * stopLine(acc: number, acc_rot: number) -> nil
1426  *
1427  */
1428  int stopLine(double acc, double acc_rot);
1429 
1430  /**
1431  * 笛卡尔空间停止运动(机械臂运行工程时发生碰撞,通过resumeSpeedLine接口移动到安全位置后需要停止时调用此接口)
1432  *
1433  * @param acc 位置加速度, 单位: m/s^2
1434  * @param acc_rot 姿态加速度，单位: rad/s^2
1435  * @return 成功返回0；失败返回错误码
1436  * AUBO_BUSY
1437  * AUBO_BAD_STATE
1438  * -AUBO_INVL_ARGUMENT
1439  * -AUBO_BAD_STATE
1440  *
1441  * @throws arcs::common_interface::AuboException
1442  *
1443  * @par Python函数原型
1444  * resumeStopLine(self: pyaubo_sdk.MotionControl, arg0: float, arg1: float)
1445  * -> int
1446  *
1447  * @par Lua函数原型
1448  * resumeStopLine(acc: number, acc_rot: number) -> nil
1449  *
1450  */
1451  int resumeStopLine(double acc, double acc_rot);
1452 
1453  /**
1454  * 开始摆动: weaveStart 和 weaveEnd 的 moveLine/moveCircle 将根据 params
1455  * 进行摆动
1456  *
1457  * @param params Json字符串用于定义摆动参数
1458  * {
1459  * "type": <string>, // "SINE" "SPIRAL" "TRIANGLE" "TRAPEZOIDAL"
1460  * "step": <num>,
1461  * "amplitude": {<num>,<num>},
1462  * "hold_distance": {<num>,<num>},
1463  * "angle": <num>
1464  * "direction": <num>
1465  * }
1466  * @return 成功返回0；失败返回错误码
1467  * AUBO_BUSY
1468  * AUBO_BAD_STATE
1469  * -AUBO_INVL_ARGUMENT
1470  * -AUBO_BAD_STATE
1471  *
1472  * @throws arcs::common_interface::AuboException
1473  *
1474  */
1475  int weaveStart(const std::string &params);
1476 
1477  /**
1478  * 结束摆动
1479  *
1480  * @return 成功返回0；失败返回错误码
1481  * AUBO_BUSY
1482  * AUBO_BAD_STATE
1483  * -AUBO_BAD_STATE
1484  *
1485  * @throws arcs::common_interface::AuboException
1486  *
1487  */
1488  int weaveEnd();
1489 
1490  /**
1491  * 设置未来路径上点的采样时间间隔
1492  *
1493  * @param sample_time 采样时间间隔 单位: m/s^2
1494  * @return 成功返回0；失败返回错误码
1495  * AUBO_BUSY
1496  * AUBO_BAD_STATE
1497  * -AUBO_INVL_ARGUMENT
1498  * -AUBO_BAD_STATE
1499  *
1500  * @throws arcs::common_interface::AuboException
1501  *
1502  */
1503  int setFuturePointSamplePeriod(double sample_time);
1504 
1505  /**
1506  * 获取未来路径上的轨迹点
1507  *
1508  * @return 路点(100ms * 10)
1509  *
1510  * @throws arcs::common_interface::AuboException
1511  *
1512  */
1513  std::vector<std::vector<double>> getFuturePathPointsJoint();
1514 
1515  /**
1516  * 圆形传送带跟随
1517  *
1518  * @note 暂未实现
1519  *
1520  * @param encoder_id 预留
1521  * @param center
1522  * @param tick_per_revo
1523  * @param rotate_tool
1524  * @return
1525  *
1526  * @throws arcs::common_interface::AuboException
1527  *
1528  */
1529  int conveyorTrackCircle(int encoder_id, const std::vector<double> &center,
1530  int tick_per_revo, bool rotate_tool);
1531 
1532  /**
1533  * 线性传送带跟随
1534  *
1535  * @note 暂未实现
1536  *
1537  * @param encoder_id 预留
1538  * @param direction
1539  * @param tick_per_meter
1540  * @return
1541  *
1542  * @throws arcs::common_interface::AuboException
1543  *
1544  */
1545  int conveyorTrackLine(int encoder_id, const std::vector<double> &direction,
1546  int tick_per_meter);
1547 
1548  /**
1549  * 终止传送带跟随
1550  *
1551  * @note 暂未实现
1552  *
1553  * @param a
1554  * @return
1555  *
1556  * @throws arcs::common_interface::AuboException
1557  *
1558  */
1559  int conveyorTrackStop(double a);
1560 
1561  /**
1562  * 螺旋线运动
1563  *
1564  * @param param 封装的参数
1565  * @param blend_radius
1566  * @param v
1567  * @param a
1568  * @param t
1569  * @return 成功返回0；失败返回错误码
1570  * AUBO_BUSY
1571  * AUBO_BAD_STATE
1572  * -AUBO_INVL_ARGUMENT
1573  * -AUBO_BAD_STATE
1574  *
1575  * @throws arcs::common_interface::AuboException
1576  *
1577  */
1578  int moveSpiral(const SpiralParameters &param, double blend_radius, double v,
1579  double a, double t);
1580 
1581  /**
1582  * 获取前瞻段数
1583  *
1584  * @return 返回前瞻段数
1585  *
1586  * @throws arcs::common_interface::AuboException
1587  *
1588  * @par Python函数原型
1589  * getLookAheadSize(self: pyaubo_sdk.MotionControl) -> int
1590  *
1591  * @par Lua函数原型
1592  * getLookAheadSize() -> number
1593  */
1594  int getLookAheadSize();
1595 
1596  /**
1597  * 设置前瞻段数
1598  * 1.对于有较高速度平稳性要求的任务,如数控加工,涂胶,焊接等匀速需求,较长的前瞻段数可以提供更优的速度规划,产生的运动会更加平滑;
1599  * 2.对于快速响应的抓取类任务,更倾向于较短的前瞻段数,以提高反应速度,但可能因为进给的路径不够及时导致速度波动很大.
1600  *
1601  * @return 成功返回0
1602  *
1603  * @throws arcs::common_interface::AuboException
1604  *
1605  * @par Python函数原型
1606  * setLookAheadSize(self: pyaubo_sdk.MotionControl, arg0: int) -> int
1607  *
1608  * @par Lua函数原型
1609  * setLookAheadSize(eqradius: number) -> number
1610  */
1611  int setLookAheadSize(int size);
1612 
1613 protected:
1614  void *d_;
1615 };
1616 using MotionControlPtr = std::shared_ptr<MotionControl>;
1617 
1618 // clang-format off
1619 #define MotionControl_DECLARES \
1620  _FUNC(MotionControl, 0, getEqradius) \
1621  _FUNC(MotionControl, 1, setEqradius,eqradius) \
1622  _FUNC(MotionControl, 0, getSpeedFraction) \
1623  _FUNC(MotionControl, 1, setSpeedFraction, fraction) \
1624  _INST(MotionControl, 1, speedFractionCritical, enable) \
1625  _FUNC(MotionControl, 0, isSpeedFractionCritical) \
1626  _FUNC(MotionControl, 0, isBlending) \
1627  _INST(MotionControl, 0, pathOffsetEnable) \
1628  _INST(MotionControl, 2, pathOffsetSet, offset, type) \
1629  _INST(MotionControl, 0, pathOffsetDisable) \
1630  _INST(MotionControl, 0, jointOffsetEnable) \
1631  _INST(MotionControl, 2, jointOffsetSet, offset, type) \
1632  _INST(MotionControl, 0, jointOffsetDisable) \
1633  _FUNC(MotionControl, 0, getTrajectoryQueueSize) \
1634  _FUNC(MotionControl, 0, getQueueSize) \
1635  _FUNC(MotionControl, 0, getExecId) \
1636  _FUNC(MotionControl, 1, getDuration, id) \
1637  _FUNC(MotionControl, 1, getMotionLeftTime, id) \
1638  _FUNC(MotionControl, 0, getProgress) \
1639  _INST(MotionControl, 2, setWorkObjectHold, module_name, mounting_pose) \
1640  _FUNC(MotionControl, 0, getWorkObjectHold) \
1641  _FUNC(MotionControl, 0, getPauseJointPositions) \
1642  _FUNC(MotionControl, 1, setServoMode, enable) \
1643  _FUNC(MotionControl, 0, isServoModeEnabled) \
1644  _FUNC(MotionControl, 1, setServoModeSelect, mode) \
1645  _FUNC(MotionControl, 0, getServoModeSelect) \
1646  _FUNC(MotionControl, 6, servoJoint, q, a, v, t, lookahead_time, gain) \
1647  _FUNC(MotionControl, 6, servoCartesian, pose, a, v, t, lookahead_time, gain)\
1648  _INST(MotionControl, 7, servoJointWithAxes, q, extq, a, v, t, lookahead_time, gain) \
1649  _INST(MotionControl, 7, servoCartesianWithAxes, pose, extq, a, v, t, lookahead_time, gain) \
1650  _INST(MotionControl, 4, trackJoint, q, t, smooth_scale, delay_sacle) \
1651  _INST(MotionControl, 4, trackCartesian, pose, t, smooth_scale, delay_sacle) \
1652  _INST(MotionControl, 1, followJoint, q) \
1653  _INST(MotionControl, 1, followLine, pose) \
1654  _INST(MotionControl, 3, speedJoint, qd, a, t) \
1655  _FUNC(MotionControl, 3, resumeSpeedJoint, qd, a, t) \
1656  _INST(MotionControl, 3, speedLine, xd, a, t) \
1657  _FUNC(MotionControl, 3, resumeSpeedLine, xd, a, t) \
1658  _INST(MotionControl, 4, moveSpline, q, a, v, duration) \
1659  _INST(MotionControl, 5, moveJoint, q, a, v, blend_radius, duration) \
1660  _FUNC(MotionControl, 4, resumeMoveJoint, q, a, v, duration) \
1661  _INST(MotionControl, 5, moveLine, pose, a, v, blend_radius, duration) \
1662  _INST(MotionControl, 4, moveProcess, pose, a, v, blend_radius) \
1663  _FUNC(MotionControl, 4, resumeMoveLine, pose, a, v, duration) \
1664  _INST(MotionControl, 6, moveCircle, via_pose, end_pose, a, v, \
1665  blend_radius, duration) \
1666  _INST(MotionControl, 1, setCirclePathMode, mode) \
1667  _INST(MotionControl, 1, moveCircle2, param) \
1668  _FUNC(MotionControl, 3, pathBufferAlloc, name, type, size) \
1669  _FUNC(MotionControl, 2, pathBufferAppend, name, waypoints) \
1670  _FUNC(MotionControl, 4, pathBufferEval, name, a, v, t) \
1671  _FUNC(MotionControl, 1, pathBufferValid, name) \
1672  _FUNC(MotionControl, 1, pathBufferFree, name) \
1673  _FUNC(MotionControl, 0, pathBufferList) \
1674  _INST(MotionControl, 1, movePathBuffer, name) \
1675  _INST(MotionControl, 7, moveIntersection, poses, a, v, main_pipe_radius, sub_pipe_radius, normal_distance, normal_alpha)\
1676  _FUNC(MotionControl, 1, stopJoint, acc) \
1677  _FUNC(MotionControl, 1, resumeStopJoint, acc) \
1678  _FUNC(MotionControl, 2, stopLine, acc, acc_rot) \
1679  _FUNC(MotionControl, 2, resumeStopLine, acc, acc_rot) \
1680  _INST(MotionControl, 1, weaveStart, params) \
1681  _INST(MotionControl, 0, weaveEnd) \
1682  _FUNC(MotionControl, 1, storePath, keep_sync) \
1683  _FUNC(MotionControl, 2, stopMove, quick, all_tasks) \
1684  _FUNC(MotionControl, 0, startMove) \
1685  _FUNC(MotionControl, 0, clearPath) \
1686  _FUNC(MotionControl, 0, restoPath) \
1687  _FUNC(MotionControl, 1, setFuturePointSamplePeriod, sample_time) \
1688  _FUNC(MotionControl, 0, getFuturePathPointsJoint) \
1689  _INST(MotionControl, 4, conveyorTrackCircle, encoder_id, center, tick_per_revo, rotate_tool) \
1690  _INST(MotionControl, 3, conveyorTrackLine, encoder_id, direction, tick_per_meter) \
1691  _INST(MotionControl, 1, conveyorTrackStop, a) \
1692  _INST(MotionControl, 5, moveSpiral, param, blend_radius, v, a, t) \
1693  _INST(MotionControl, 2, pathOffsetLimits, v, a) \
1694  _INST(MotionControl, 1, pathOffsetCoordinate, ref_coord) \
1695  _FUNC(MotionControl, 0, getLookAheadSize) \
1696  _INST(MotionControl, 1, setLookAheadSize, size)
1697 
1698 // clang-format on
1699 } // namespace common_interface
1700 } // namespace arcs
1701 
1702 #endif // AUBO_SDK_MOTION_CONTROL_INTERFACE_H
type_def.h
数据类型的定义
arcs::common_interface::SpiralParameters
Definition: type_def.h:611
arcs::common_interface::MotionControlPtr
std::shared_ptr< MotionControl > MotionControlPtr
Definition: motion_control.h:1616
arcs::common_interface::PathBuffer_TOPPRA
1: toppra 时间最优路径规划
Definition: motion_control.h:26
arcs::common_interface::PathBuffer_JointSpline
3: 关节B样条插值，最少三个点
Definition: motion_control.h:28
arcs::common_interface::PathBufferType
PathBufferType
pathBuffer类型
Definition: motion_control.h:24
arcs::common_interface::MotionControl::d_
void * d_
Definition: motion_control.h:1614
arcs::common_interface::PathBuffer_CubicSpline
2: cubic_spline(录制的轨迹)
Definition: motion_control.h:27
arcs::common_interface::MotionControl
MotionControl类
Definition: motion_control.h:34
arcs
Definition: aubo_api.h:17
arcs::common_interface::CircleParameters
圆周运动参数定义
Definition: type_def.h:592
制作者   doxygen 1.8.11