ARCS SDK API  0.24.0
io_control.h
浏览该文件的文档.
1 /** @file io_control.h
2  * @brief IO控制接口
3  */
4 #ifndef AUBO_SDK_IO_CONTROL_INTERFACE_H
5 #define AUBO_SDK_IO_CONTROL_INTERFACE_H
6 
7 #include <vector>
8 #include <thread>
9 
10 #include <aubo/global_config.h>
11 #include <aubo/type_def.h>
12 
13 namespace arcs {
14 namespace common_interface {
15 
16 /**
17  * IoControl类提供了一系列的接口对机器人标配的一些数字、模拟IO进行配置，输出状态设置、读取
18  *
19  * 1. 获取各种IO的数量 \n
20  * 2. 配置IO的输入输出功能 \n
21  * 3. 可配置IO的配置 \n
22  * 4. 模拟IO的输入输出范围设置、读取
23  *
24  * 标准数字输入输出：控制柜IO面板上的标准IO \n
25  * 工具端数字输入输出：通过工具末端航插暴露的数字IO \n
26  * 可配置输入输出：可以配置为安全IO或者普通数字IO \n
27  */
28 class ARCS_ABI_EXPORT IoControl
29 {
30 public:
31  IoControl();
32  virtual ~IoControl();
33 
34  /**
35  * 获取标准数字输入数量
36  *
37  * @return 标准数字输入数量
38  *
39  * @throws arcs::common_interface::AuboException
40  *
41  * @par Python函数原型
42  * getStandardDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
43  *
44  * @par Lua函数原型
45  * getStandardDigitalInputNum() -> number
46  *
47  * @par JSON-RPC请求示例
48  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputNum","params":[],"id":1}
49  *
50  * @par JSON-RPC响应示例
51  * {"id":1,"jsonrpc":"2.0","result":16}
52  *
53  */
54  int getStandardDigitalInputNum();
55 
56  /**
57  * 获取工具端数字IO数量(包括数字输入和数字输出)
58  *
59  * @return 工具端数字IO数量(包括数字输入和数字输出)
60  *
61  * @throws arcs::common_interface::AuboException
62  *
63  * @par Python函数原型
64  * getToolDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
65  *
66  * @par Lua函数原型
67  * getToolDigitalInputNum() -> number
68  *
69  * @par JSON-RPC请求示例
70  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputNum","params":[],"id":1}
71  *
72  * @par JSON-RPC响应示例
73  * {"id":1,"jsonrpc":"2.0","result":4}
74  *
75  */
76  int getToolDigitalInputNum();
77 
78  /**
79  * 获取可配置数字输入数量
80  *
81  * @return 可配置数字输入数量
82  *
83  * @throws arcs::common_interface::AuboException
84  *
85  * @par Python函数原型
86  * getConfigurableDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
87  *
88  * @par Lua函数原型
89  * getConfigurableDigitalInputNum() -> number
90  *
91  * @par JSON-RPC请求示例
92  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputNum","params":[],"id":1}
93  *
94  * @par JSON-RPC响应示例
95  * {"id":1,"jsonrpc":"2.0","result":16}
96  *
97  */
98  int getConfigurableDigitalInputNum();
99 
100  /**
101  * 获取标准数字输出数量
102  *
103  * @return 标准数字输出数量
104  *
105  * @throws arcs::common_interface::AuboException
106  *
107  * @par Python函数原型
108  * getStandardDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
109  *
110  * @par Lua函数原型
111  * getStandardDigitalOutputNum() -> number
112  *
113  * @par JSON-RPC请求示例
114  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputNum","params":[],"id":1}
115  *
116  * @par JSON-RPC响应示例
117  * {"id":1,"jsonrpc":"2.0","result":8}
118  *
119  */
120  int getStandardDigitalOutputNum();
121 
122  /**
123  * 获取工具端数字IO数量(包括数字输入和数字输出)
124  *
125  * @return 工具端数字IO数量(包括数字输入和数字输出)
126  *
127  * @throws arcs::common_interface::AuboException
128  *
129  * @par Python函数原型
130  * getToolDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
131  *
132  * @par Lua函数原型
133  * getToolDigitalOutputNum() -> number
134  *
135  * @par JSON-RPC请求示例
136  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputNum","params":[],"id":1}
137  *
138  * @par JSON-RPC响应示例
139  * {"id":1,"jsonrpc":"2.0","result":4}
140  *
141  */
142  int getToolDigitalOutputNum();
143 
144  /**
145  * 设置指定的工具端数字IO为输入或输出
146  *
147  * 工具端数字IO比较特殊，IO可以配置为输入或者输出
148  *
149  * @param index: 表示IO口的管脚，管脚编号从0开始。
150  * 例如，0表示第一个管脚。
151  * @param input: 表示指定IO是否为输入。
152  * input 为true时，设置指定IO为输入，否则为输出
153  * @return 成功返回0；失败返回错误码
154  * AUBO_BUSY
155  * AUBO_BAD_STATE
156  * -AUBO_INVL_ARGUMENT
157  * -AUBO_BAD_STATE
158  *
159  * @throws arcs::common_interface::AuboException
160  *
161  * @par Python函数原型
162  * setToolIoInput(self: pyaubo_sdk.IoControl, arg0: int, arg1: bool) -> int
163  *
164  * @par Lua函数原型
165  * setToolIoInput(index: number, input: boolean) -> nil
166  *
167  * @par JSON-RPC请求示例
168  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolIoInput","params":[0,true],"id":1}
169  *
170  * @par JSON-RPC响应示例
171  * {"id":1,"jsonrpc":"2.0","result":0}
172  *
173  */
174  int setToolIoInput(int index, bool input);
175 
176  /**
177  * 判断指定的工具端数字IO类型是否为输入
178  *
179  * @param index: 表示IO口的管脚，管脚编号从0开始。
180  * 例如，0表示第一个管脚。
181  * @return 当指定的IO为输入时返回 true, 否则为 false
182  *
183  * @throws arcs::common_interface::AuboException
184  *
185  * @par Python函数原型
186  * isToolIoInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
187  *
188  * @par Lua函数原型
189  * isToolIoInput(index: number) -> boolean
190  *
191  * @par JSON-RPC请求示例
192  * {"jsonrpc":"2.0","method":"rob1.IoControl.isToolIoInput","params":[0],"id":1}
193  *
194  * @par JSON-RPC响应示例
195  * {"id":1,"jsonrpc":"2.0","result":true}
196  *
197  */
198  bool isToolIoInput(int index);
199 
200  /**
201  * 获取可配置数字输出数量
202  *
203  * @return 可配置数字输出数量
204  *
205  * @throws arcs::common_interface::AuboException
206  *
207  * @par Python函数原型
208  * getConfigurableDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
209  *
210  * @par Lua函数原型
211  * getConfigurableDigitalOutputNum() -> number
212  *
213  * @par JSON-RPC请求示例
214  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputNum","params":[],"id":1}
215  *
216  * @par JSON-RPC响应示例
217  * {"id":1,"jsonrpc":"2.0","result":16}
218  *
219  */
220  int getConfigurableDigitalOutputNum();
221 
222  /**
223  * 获取标准模拟输入数量
224  *
225  * @return 标准模拟输入数量
226  *
227  * @throws arcs::common_interface::AuboException
228  *
229  * @par Python函数原型
230  * getStandardAnalogInputNum(self: pyaubo_sdk.IoControl) -> int
231  *
232  * @par Lua函数原型
233  * getStandardAnalogInputNum() -> number
234  *
235  * @par JSON-RPC请求示例
236  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInputNum","params":[],"id":1}
237  *
238  * @par JSON-RPC响应示例
239  * {"id":1,"jsonrpc":"2.0","result":2}
240  *
241  */
242  int getStandardAnalogInputNum();
243 
244  /**
245  * 获取工具端模拟输入数量
246  *
247  * @return 工具端模拟输入数量
248  *
249  * @throws arcs::common_interface::AuboException
250  *
251  * @par Python函数原型
252  * getToolAnalogInputNum(self: pyaubo_sdk.IoControl) -> int
253  *
254  * @par Lua函数原型
255  * getToolAnalogInputNum() -> number
256  *
257  * @par JSON-RPC请求示例
258  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInputNum","params":[],"id":1}
259  *
260  * @par JSON-RPC响应示例
261  * {"id":1,"jsonrpc":"2.0","result":2}
262  *
263  */
264  int getToolAnalogInputNum();
265 
266  /**
267  * 获取标准模拟输出数量
268  *
269  * @return 标准模拟输出数量
270  *
271  * @throws arcs::common_interface::AuboException
272  *
273  * @par Python函数原型
274  * getStandardAnalogOutputNum(self: pyaubo_sdk.IoControl) -> int
275  *
276  * @par Lua函数原型
277  * getStandardAnalogOutputNum() -> number
278  *
279  * @par JSON-RPC请求示例
280  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputNum","params":[],"id":1}
281  *
282  * @par JSON-RPC响应示例
283  * {"id":1,"jsonrpc":"2.0","result":2}
284  *
285  */
286  int getStandardAnalogOutputNum();
287 
288  /**
289  * 获取工具端模拟输出数量
290  *
291  * @return 工具端模拟输出数量
292  *
293  * @throws arcs::common_interface::AuboException
294  *
295  * @par Python函数原型
296  * getToolAnalogOutputNum(self: pyaubo_sdk.IoControl) -> int
297  *
298  * @par Lua函数原型
299  * getToolAnalogOutputNum() -> number
300  *
301  * @par JSON-RPC请求示例
302  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputNum","params":[],"id":1}
303  *
304  * @par JSON-RPC响应示例
305  * {"id":1,"jsonrpc":"2.0","result":0}
306  *
307  */
308  int getToolAnalogOutputNum();
309 
310  /**
311  * 设置所有数字输入动作为无触发
312  *
313  * @note
314  * 当输入动作为无触发时，用户设置数字输入值为高电平，不会触发机器人发生动作
315  *
316  * @return 成功返回0；失败返回错误码
317  * AUBO_BUSY
318  * AUBO_BAD_STATE
319  * -AUBO_BAD_STATE
320  *
321  * @throws arcs::common_interface::AuboException
322  *
323  * @par Python函数原型
324  * setDigitalInputActionDefault(self: pyaubo_sdk.IoControl) -> int
325  *
326  * @par Lua函数原型
327  * setDigitalInputActionDefault() -> nil
328  *
329  * @par JSON-RPC请求示例
330  * {"jsonrpc":"2.0","method":"rob1.IoControl.setDigitalInputActionDefault","params":[],"id":1}
331  *
332  * @par JSON-RPC响应示例
333  * {"id":1,"jsonrpc":"2.0","result":0}
334  *
335  */
336  int setDigitalInputActionDefault();
337 
338  /**
339  * 设置标准数字输入触发动作
340  *
341  * @note
342  * 当给输入设置为无触发动作(StandardInputAction::Default)时，
343  * 用户设置数字输入值为高电平，不会触发机器人发生动作。\n
344  * 当给输入设置触发动作时，用户设置数字输入值为高电平，会触发机器人执行相应的动作。\n
345  * 例如，当设置DI0的触发动作为拖动示教(StandardInputAction::Handguide)时，
346  * 用户设置DI0为高电平，机器人会进入拖动示教。
347  * 设置DI0为低电平，机器人会退出拖动示教。
348  *
349  * @param index: 表示IO口的管脚，管脚编号从0开始。
350  * 例如，0表示第一个管脚。
351  * @param action: 触发动作
352  *
353  * @return 成功返回0；失败返回错误码
354  * AUBO_REQUEST_IGNORE
355  * AUBO_BUSY
356  * AUBO_BAD_STATE
357  * -AUBO_INVL_ARGUMENT
358  * -AUBO_BAD_STATE
359  *
360  * @throws arcs::common_interface::AuboException
361  *
362  * @par Python函数原型
363  * setStandardDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int,
364  * arg1: arcs::common_interface::StandardInputAction) -> int
365  *
366  * @par Lua函数原型
367  * setStandardDigitalInputAction(index: number, action: number) -> nil
368  *
369  * @par JSON-RPC请求示例
370  * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalInputAction","params":[0,"Handguide"],"id":1}
371  *
372  * @par JSON-RPC响应示例
373  * {"id":1,"jsonrpc":"2.0","result":0}
374  *
375  */
376  int setStandardDigitalInputAction(int index, StandardInputAction action);
377 
378  /**
379  * 设置工具数字输入触发动作
380  *
381  * @note
382  * 当给输入设置为无触发动作(StandardInputAction::Default)时，
383  * 用户设置工具数字输入值为高电平，不会触发机器人发生动作。\n
384  * 当给输入设置触发动作时，用户设置工具数字输入值为高电平，会触发机器人执行相应的动作。\n
385  * 例如，当设置TOOL_IO[0]的类型为输入而且触发动作为拖动示教(StandardInputAction::Handguide)时，
386  * 用户设置TOOL_IO[0]为高电平，机器人会进入拖动示教。
387  * 设置TOOL_IO[0]为低电平，机器人会退出拖动示教。
388  *
389  * @param index: 表示IO口的管脚，管脚编号从0开始。
390  * 例如，0表示第一个管脚。
391  * @param action: 触发动作
392  *
393  * @return 成功返回0；失败返回错误码
394  * AUBO_REQUEST_IGNORE
395  * AUBO_BUSY
396  * AUBO_BAD_STATE
397  * -AUBO_INVL_ARGUMENT
398  * -AUBO_BAD_STATE
399  *
400  * @throws arcs::common_interface::AuboException
401  *
402  * @par Python函数原型
403  * setToolDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int, arg1:
404  * arcs::common_interface::StandardInputAction) -> int
405  *
406  * @par Lua函数原型
407  * setToolDigitalInputAction(index: number, action: number) -> nil
408  *
409  * @par JSON-RPC请求示例
410  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalInputAction","params":[0,"Handguide"],"id":1}
411  *
412  * @par JSON-RPC响应示例
413  * {"id":1,"jsonrpc":"2.0","result":0}
414  *
415  */
416  int setToolDigitalInputAction(int index, StandardInputAction action);
417 
418  /**
419  * 设置可配置数字输入触发动作
420  *
421  * @param index: 表示IO口的管脚，管脚编号从0开始。
422  * 例如，0表示第一个管脚。
423  * @param action: 触发动作
424  *
425  * @return 成功返回0；失败返回错误码
426  * AUBO_REQUEST_IGNORE
427  * AUBO_BUSY
428  * AUBO_BAD_STATE
429  * -AUBO_INVL_ARGUMENT
430  * -AUBO_BAD_STATE
431  *
432  * @throws arcs::common_interface::AuboException
433  *
434  * @note 需要将可配置输入的安全输入动作设置为
435  * SafetyInputAction::Unassigned时这个函数的配置才会生效
436  *
437  * @par Python函数原型
438  * setConfigurableDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int,
439  * arg1: arcs::common_interface::StandardInputAction) -> int
440  *
441  * @par Lua函数原型
442  * setConfigurableDigitalInputAction(index: number, action: number) -> nil
443  *
444  * @par JSON-RPC请求示例
445  * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalInputAction","params":[0,"Handguide"],"id":1}
446  *
447  * @par JSON-RPC响应示例
448  * {"id":1,"jsonrpc":"2.0","result":0}
449  *
450  */
451  int setConfigurableDigitalInputAction(int index,
452  StandardInputAction action);
453 
454  /**
455  * 获取标准数字输入触发动作
456  *
457  * @param index: 表示IO口的管脚，管脚编号从0开始。
458  * 例如，0表示第一个管脚。
459  * @return 标准数字输入触发动作
460  *
461  * @par Python函数原型
462  * getStandardDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int) ->
463  * arcs::common_interface::StandardInputAction
464  *
465  * @par Lua函数原型
466  * getStandardDigitalInputAction(index: number) -> number
467  *
468  * @par JSON-RPC请求示例
469  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputAction","params":[0],"id":1}
470  *
471  * @par JSON-RPC响应示例
472  * {"id":1,"jsonrpc":"2.0","result":"Default"}
473  *
474  */
475  StandardInputAction getStandardDigitalInputAction(int index);
476 
477  /**
478  * 获取工具端数字输入触发动作
479  *
480  * @param index: 表示IO口的管脚，管脚编号从0开始。
481  * 例如，0表示第一个管脚。
482  * @return 工具端数字输入触发动作
483  *
484  * @par Python函数原型
485  * getToolDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int) ->
486  * arcs::common_interface::StandardInputAction
487  *
488  * @par Lua函数原型
489  * getToolDigitalInputAction(index: number) -> number
490  *
491  * @par JSON-RPC请求示例
492  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputAction","params":[0],"id":1}
493  *
494  * @par JSON-RPC响应示例
495  * {"id":1,"jsonrpc":"2.0","result":"Default"}
496  *
497  */
498  StandardInputAction getToolDigitalInputAction(int index);
499 
500  /**
501  * 获取可配置数字输入的输入触发动作
502  *
503  * @param index: 表示IO口的管脚，管脚编号从0开始。
504  * 例如，0表示第一个管脚。
505  * @return 返回输入触发动作
506  *
507  * @par Python函数原型
508  * getConfigurableDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int)
509  * -> arcs::common_interface::StandardInputAction
510  *
511  * @par Lua函数原型
512  * getConfigurableDigitalInputAction(index: number) -> number
513  *
514  * @par JSON-RPC请求示例
515  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputAction","params":[0],"id":1}
516  *
517  * @par JSON-RPC响应示例
518  * {"id":1,"jsonrpc":"2.0","result":"Default"}
519  *
520  */
521  StandardInputAction getConfigurableDigitalInputAction(int index);
522 
523  /**
524  * 设置所有数字输出状态选择为无
525  *
526  * @note
527  * 当给输出状态设置为无(StandardOutputRunState::None)时，
528  * 用户可以设置数字输出值。\n
529  * 当给输出设置状态时，用户不可设置数字输出值，控制器会自动设置数字输出值。\n
530  * 例如，当设置DO0的输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时，
531  * 机器人进入拖动示教，DO0会自动变为高电平。
532  * 机器人退出拖动示教，DO0会自动变为低电平。
533  *
534  * @return 成功返回0；失败返回错误码
535  * AUBO_BUSY
536  * AUBO_BAD_STATE
537  * -AUBO_BAD_STATE
538  *
539  * @throws arcs::common_interface::AuboException
540  *
541  * @par Python函数原型
542  * setDigitalOutputRunstateDefault(self: pyaubo_sdk.IoControl) -> int
543  *
544  * @par Lua函数原型
545  * setDigitalOutputRunstateDefault() -> nil
546  *
547  * @par JSON-RPC请求示例
548  * {"jsonrpc":"2.0","method":"rob1.IoControl.setDigitalOutputRunstateDefault","params":[],"id":1}
549  *
550  * @par JSON-RPC响应示例
551  * {"id":1,"jsonrpc":"2.0","result":0}
552  *
553  */
554  int setDigitalOutputRunstateDefault();
555 
556  /**
557  * 设置标准数字输出状态选择
558  *
559  * @note
560  * 当给输出状态设置为无(StandardOutputRunState::None)时，
561  * 用户可以设置数字输出值。\n
562  * 当给输出设置状态时，用户不可设置数字输出值，控制器会自动设置数字输出值。\n
563  * 例如，当设置DO0的输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时，
564  * 机器人进入拖动示教，DO0会自动变为高电平。
565  * 机器人退出拖动示教，DO0会自动变为低电平。
566  *
567  * @param index: 表示IO口的管脚，管脚编号从0开始。
568  * 例如，0表示第一个管脚。
569  * @param runstate: 输出状态选择
570  *
571  * @return 成功返回0；失败返回错误码
572  * AUBO_REQUEST_IGNORE
573  * AUBO_BUSY
574  * AUBO_BAD_STATE
575  * -AUBO_INVL_ARGUMENT
576  * -AUBO_BAD_STATE
577  *
578  * @throws arcs::common_interface::AuboException
579  *
580  * @par Python函数原型
581  * setStandardDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int,
582  * arg1: arcs::common_interface::StandardOutputRunState) -> int
583  *
584  * @par Lua函数原型
585  * setStandardDigitalOutputRunstate(index: number, runstate: number) -> nil
586  *
587  * @par JSON-RPC请求示例
588  * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutputRunstate","params":[0,"PowerOn"],"id":1}
589  *
590  * @par JSON-RPC响应示例
591  * {"id":1,"jsonrpc":"2.0","result":0}
592  *
593  */
594  int setStandardDigitalOutputRunstate(int index,
595  StandardOutputRunState runstate);
596 
597  /**
598  * 设置工具端数字输出状态选择
599  *
600  * @note
601  * 当给输出状态设置为无(StandardOutputRunState::None)时，
602  * 用户可以设置数字输出值。\n
603  * 当给输出设置状态时，用户不可设置数字输出值，控制器会自动设置数字输出值。\n
604  * 例如，当设置TOOL_IO[0]类型为输出且输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时，
605  * 机器人进入拖动示教，TOOL_IO[0]会自动变为高电平。
606  * 机器人退出拖动示教，TOOL_IO[0]会自动变为低电平。
607  *
608  * @param index: 表示IO口的管脚，管脚编号从0开始。
609  * 例如，0表示第一个管脚。
610  * @param runstate: 输出状态选择
611  *
612  * @return 成功返回0；失败返回错误码
613  * AUBO_REQUEST_IGNORE
614  * AUBO_BUSY
615  * AUBO_BAD_STATE
616  * -AUBO_INVL_ARGUMENT
617  * -AUBO_BAD_STATE
618  *
619  * @throws arcs::common_interface::AuboException
620  *
621  * @par Python函数原型
622  * setToolDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int, arg1:
623  * arcs::common_interface::StandardOutputRunState) -> int
624  *
625  * @par Lua函数原型
626  * setToolDigitalOutputRunstate(index: number, runstate: number) -> nil
627  *
628  * @par JSON-RPC请求示例
629  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutputRunstate","params":[0,"None"],"id":1}
630  *
631  * @par JSON-RPC响应示例
632  * {"id":1,"jsonrpc":"2.0","result":0}
633  *
634  */
635  int setToolDigitalOutputRunstate(int index,
636  StandardOutputRunState runstate);
637 
638  /**
639  * 设置可配置数字输出状态选择
640  *
641  * @param index: 表示IO口的管脚，管脚编号从0开始。
642  * 例如，0表示第一个管脚。
643  * @param runstate: 输出状态选择
644  *
645  * @return 成功返回0；失败返回错误码
646  * AUBO_REQUEST_IGNORE
647  * AUBO_BUSY
648  * AUBO_BAD_STATE
649  * -AUBO_INVL_ARGUMENT
650  * -AUBO_BAD_STATE
651  *
652  * @throws arcs::common_interface::AuboException
653  *
654  * @par Python函数原型
655  * setConfigurableDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0:
656  * int, arg1: arcs::common_interface::StandardOutputRunState) -> int
657  *
658  * @par Lua函数原型
659  * setConfigurableDigitalOutputRunstate(index: number, runstate: number) ->
660  * nil
661  *
662  * @par JSON-RPC请求示例
663  * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutputRunstate","params":[0,"None"],"id":1}
664  *
665  * @par JSON-RPC响应示例
666  * {"id":1,"jsonrpc":"2.0","result":0}
667  *
668  */
669  int setConfigurableDigitalOutputRunstate(int index,
670  StandardOutputRunState runstate);
671 
672  /**
673  * 获取标准数字输出状态选择
674  *
675  * @param index: 表示IO口的管脚，管脚编号从0开始。
676  * 例如，0表示第一个管脚。
677  * @return 输出状态选择
678  *
679  * @throws arcs::common_interface::AuboException
680  *
681  * @par Python函数原型
682  * getStandardDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int)
683  * -> arcs::common_interface::StandardOutputRunState
684  *
685  * @par Lua函数原型
686  * getStandardDigitalOutputRunstate(index: number) -> number
687  *
688  * @par JSON-RPC请求示例
689  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputRunstate","params":[0],"id":1}
690  *
691  * @par JSON-RPC响应示例
692  * {"id":1,"jsonrpc":"2.0","result":"None"}
693  *
694  */
695  StandardOutputRunState getStandardDigitalOutputRunstate(int index);
696 
697  /**
698  * 获取工具端数字输出状态选择
699  *
700  * @param index: 表示IO口的管脚，管脚编号从0开始。
701  * 例如，0表示第一个管脚。
702  * @return 输出状态选择
703  *
704  * @throws arcs::common_interface::AuboException
705  *
706  * @par Python函数原型
707  * getToolDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
708  * arcs::common_interface::StandardOutputRunState
709  *
710  * @par Lua函数原型
711  * getToolDigitalOutputRunstate(index: number) -> number
712  *
713  * @par JSON-RPC请求示例
714  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputRunstate","params":[0],"id":1}
715  *
716  * @par JSON-RPC响应示例
717  * {"id":1,"jsonrpc":"2.0","result":"None"}
718  *
719  */
720  StandardOutputRunState getToolDigitalOutputRunstate(int index);
721 
722  /**
723  * 获取可配置数字输出状态选择
724  *
725  * @param index: 表示IO口的管脚，管脚编号从0开始。
726  * 例如，0表示第一个管脚。
727  * @return 输出状态选择
728  *
729  * @throws arcs::common_interface::AuboException
730  *
731  * @par Python函数原型
732  * getConfigurableDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0:
733  * int)
734  * -> arcs::common_interface::StandardOutputRunState
735  *
736  * @par Lua函数原型
737  * getConfigurableDigitalOutputRunstate(index: number) -> number
738  *
739  * @par JSON-RPC请求示例
740  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputRunstate","params":[0],"id":1}
741  *
742  * @par JSON-RPC响应示例
743  * {"id":1,"jsonrpc":"2.0","result":"None"}
744  *
745  */
746  StandardOutputRunState getConfigurableDigitalOutputRunstate(int index);
747 
748  /**
749  * 设置标准模拟输出状态选择
750  *
751  * @note
752  * 当给输出状态设置为无(StandardOutputRunState::None)时，
753  * 用户可以设置模拟输出值。\n
754  * 当给输出设置状态时，用户不可设置模拟输出值，控制器会自动设置模拟输出值。\n
755  * 例如，当设置AO0的输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时，
756  * 机器人进入拖动示教，AO0的值会自动变为最大值。
757  * 机器人退出拖动示教，AO0的值会自动变为0。
758  *
759  * @param index: 表示IO口的管脚，管脚编号从0开始。
760  * 例如，0表示第一个管脚。
761  * @param runstate: 输出状态选择
762  * @return 成功返回0；失败返回错误码
763  * AUBO_REQUEST_IGNORE
764  * AUBO_BUSY
765  * AUBO_BAD_STATE
766  * -AUBO_INVL_ARGUMENT
767  * -AUBO_BAD_STATE
768  *
769  * @throws arcs::common_interface::AuboException
770  *
771  * @par Python函数原型
772  * setStandardAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int,
773  * arg1: arcs::common_interface::StandardOutputRunState) -> int
774  *
775  * @par Lua函数原型
776  * setStandardAnalogOutputRunstate(index: number, runstate: number) -> nil
777  *
778  * @par JSON-RPC请求示例
779  * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogOutputRunstate","params":[0,"None"],"id":1}
780  *
781  * @par JSON-RPC响应示例
782  * {"id":1,"jsonrpc":"2.0","result":0}
783  *
784  */
785  int setStandardAnalogOutputRunstate(int index,
786  StandardOutputRunState runstate);
787 
788  /**
789  * 设置工具端模拟输出状态选择
790  *
791  * @param index: 表示IO口的管脚，管脚编号从0开始。
792  * 例如，0表示第一个管脚。
793  * @param runstate: 输出状态选择
794  * @return 成功返回0；失败返回错误码
795  * AUBO_REQUEST_IGNORE
796  * AUBO_BUSY
797  * AUBO_BAD_STATE
798  * -AUBO_INVL_ARGUMENT
799  * -AUBO_BAD_STATE
800  *
801  * @throws arcs::common_interface::AuboException
802  *
803  * @par Python函数原型
804  * setToolAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int, arg1:
805  * arcs::common_interface::StandardOutputRunState) -> int
806  *
807  * @par Lua函数原型
808  * setToolAnalogOutputRunstate(index: number, runstate: number) -> nil
809  *
810  * @par JSON-RPC请求示例
811  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogOutputRunstate","params":[0,"None"],"id":1}
812  *
813  * @par JSON-RPC响应示例
814  * {"id":1,"jsonrpc":"2.0","result":0}
815  *
816  */
817  int setToolAnalogOutputRunstate(int index, StandardOutputRunState runstate);
818 
819  /**
820  * 获取标准模拟输出状态选择
821  *
822  * @param index: 表示IO口的管脚，管脚编号从0开始。
823  * 例如，0表示第一个管脚。
824  * @return 标准模拟输出状态选择
825  *
826  * @throws arcs::common_interface::AuboException
827  *
828  * @par Python函数原型
829  * getStandardAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
830  * arcs::common_interface::StandardOutputRunState
831  *
832  * @par Lua函数原型
833  * getStandardAnalogOutputRunstate(index: number) -> number
834  *
835  * @par JSON-RPC请求示例
836  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputRunstate","params":[0],"id":1}
837  *
838  * @par JSON-RPC响应示例
839  * {"id":1,"jsonrpc":"2.0","result":"None"}
840  *
841  */
842  StandardOutputRunState getStandardAnalogOutputRunstate(int index);
843 
844  /**
845  * 获取工具端模拟输出状态选择
846  *
847  * @param index: 表示IO口的管脚，管脚编号从0开始。
848  * 例如，0表示第一个管脚。
849  * @return 工具端模拟输出状态选择
850  *
851  * @throws arcs::common_interface::AuboException
852  *
853  * @par Python函数原型
854  * getToolAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
855  * arcs::common_interface::StandardOutputRunState
856  *
857  * @par Lua函数原型
858  * getToolAnalogOutputRunstate(index: number) -> number
859  *
860  * @par JSON-RPC请求示例
861  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputRunstate","params":[0],"id":1}
862  *
863  * @par JSON-RPC响应示例
864  * {"id":1,"jsonrpc":"2.0","result":"None"}
865  *
866  */
867  StandardOutputRunState getToolAnalogOutputRunstate(int index);
868 
869  /**
870  * 设置标准模拟输入的范围
871  *
872  * @param index: 表示IO口的管脚，管脚编号从0开始。
873  * 例如，0表示第一个管脚。
874  * @param domain: 输入的范围
875  *
876  * @return 成功返回0；失败返回错误码
877  * AUBO_REQUEST_IGNORE
878  * AUBO_BUSY
879  * AUBO_BAD_STATE
880  * -AUBO_INVL_ARGUMENT
881  * -AUBO_BAD_STATE
882  *
883  * @throws arcs::common_interface::AuboException
884  *
885  * @par Python函数原型
886  * setStandardAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
887  * int) -> int
888  *
889  * @par Lua函数原型
890  * setStandardAnalogInputDomain(index: number, domain: number) -> nil
891  *
892  * @par JSON-RPC请求示例
893  * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogInputDomain","params":[0,8],"id":1}
894  *
895  * @par JSON-RPC响应示例
896  * {"id":1,"jsonrpc":"2.0","result":0}
897  *
898  */
899  int setStandardAnalogInputDomain(int index, int domain);
900 
901  /**
902  * 设置工具端模拟输入的范围
903  *
904  * @param index: 表示IO口的管脚，管脚编号从0开始。
905  * 例如，0表示第一个管脚。
906  * @param domain: 输入的范围
907  * @return 成功返回0；失败返回错误码
908  * AUBO_REQUEST_IGNORE
909  * AUBO_BUSY
910  * AUBO_BAD_STATE
911  * -AUBO_INVL_ARGUMENT
912  * -AUBO_BAD_STATE
913  *
914  * @throws arcs::common_interface::AuboException
915  *
916  * @par Python函数原型
917  * setToolAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
918  * int) -> int
919  *
920  * @par Lua函数原型
921  * setToolAnalogInputDomain(index: number, domain: number) -> nil
922  *
923  * @par JSON-RPC请求示例
924  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogInputDomain","params":[0,8],"id":1}
925  *
926  * @par JSON-RPC响应示例
927  * {"id":1,"jsonrpc":"2.0","result":0}
928  *
929  */
930  int setToolAnalogInputDomain(int index, int domain);
931 
932  /**
933  * 获取标准模式输入范围
934  *
935  * @param index: 表示IO口的管脚，管脚编号从0开始。
936  * 例如，0表示第一个管脚。
937  * @return 标准模式输入范围
938  *
939  * @throws arcs::common_interface::AuboException
940  *
941  * @par Python函数原型
942  * getStandardAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int) ->
943  * int
944  *
945  * @par Lua函数原型
946  * getStandardAnalogInputDomain(index: number) -> number
947  *
948  * @par JSON-RPC请求示例
949  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInputDomain","params":[0],"id":1}
950  *
951  * @par JSON-RPC响应示例
952  * {"id":1,"jsonrpc":"2.0","result":0}
953  *
954  */
955  int getStandardAnalogInputDomain(int index);
956 
957  /**
958  * 获取工具端模式输入范围
959  *
960  * @param index: 表示IO口的管脚，管脚编号从0开始。
961  * 例如，0表示第一个管脚。
962  * @return 工具端模式输入范围
963  *
964  * @throws arcs::common_interface::AuboException
965  *
966  * @par Python函数原型
967  * getToolAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
968  *
969  * @par Lua函数原型
970  * getToolAnalogInputDomain(index: number) -> number
971  *
972  * @par JSON-RPC请求示例
973  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInputDomain","params":[0],"id":1}
974  *
975  * @par JSON-RPC响应示例
976  * {"id":1,"jsonrpc":"2.0","result":10}
977  *
978  */
979  int getToolAnalogInputDomain(int index);
980 
981  /**
982  * 设置标准模拟输出的范围
983  *
984  * @param index: 表示IO口的管脚，管脚编号从0开始。
985  * 例如，0表示第一个管脚。
986  * @param domain: 输出的范围
987  *
988  * @return 成功返回0；失败返回错误码
989  * AUBO_REQUEST_IGNORE
990  * AUBO_BUSY
991  * AUBO_BAD_STATE
992  * -AUBO_INVL_ARGUMENT
993  * -AUBO_BAD_STATE
994  *
995  * @throws arcs::common_interface::AuboException
996  *
997  * @par Python函数原型
998  * setStandardAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int,
999  * arg1: int) -> int
1000  *
1001  * @par Lua函数原型
1002  * setStandardAnalogOutputDomain(index: number, domain: number) -> nil
1003  *
1004  * @par JSON-RPC请求示例
1005  * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogOutputDomain","params":[0,8],"id":1}
1006  *
1007  * @par JSON-RPC响应示例
1008  * {"id":1,"jsonrpc":"2.0","result":0}
1009  *
1010  */
1011  int setStandardAnalogOutputDomain(int index, int domain);
1012 
1013  /**
1014  * 设置工具端模拟输出范围
1015  *
1016  * @param index: 表示IO口的管脚，管脚编号从0开始。
1017  * 例如，0表示第一个管脚。
1018  * @param domain: 输出的范围
1019  *
1020  * @return 成功返回0；失败返回错误码
1021  * AUBO_REQUEST_IGNORE
1022  * AUBO_BUSY
1023  * AUBO_BAD_STATE
1024  * -AUBO_INVL_ARGUMENT
1025  * -AUBO_BAD_STATE
1026  *
1027  * @throws arcs::common_interface::AuboException
1028  *
1029  * @par Python函数原型
1030  * setToolAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1031  * int) -> int
1032  *
1033  * @par Lua函数原型
1034  * setToolAnalogOutputDomain(index: number, domain: number) -> nil
1035  *
1036  */
1037  int setToolAnalogOutputDomain(int index, int domain);
1038 
1039  /**
1040  * 获取标准模拟输出范围
1041  *
1042  * @param index: 表示IO口的管脚，管脚编号从0开始。
1043  * 例如，0表示第一个管脚。
1044  * @return 标准模拟输出范围
1045  *
1046  * @throws arcs::common_interface::AuboException
1047  *
1048  * @par Python函数原型
1049  * getStandardAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) ->
1050  * int
1051  *
1052  * @par Lua函数原型
1053  * getStandardAnalogOutputDomain(index: number) -> number
1054  *
1055  * @par JSON-RPC请求示例
1056  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputDomain","params":[0],"id":1}
1057  *
1058  * @par JSON-RPC响应示例
1059  * {"id":1,"jsonrpc":"2.0","result":0}
1060  *
1061  */
1062  int getStandardAnalogOutputDomain(int index);
1063 
1064  /**
1065  * 获取工具端模拟输出范围
1066  *
1067  * @param index: 表示IO口的管脚，管脚编号从0开始。
1068  * 例如，0表示第一个管脚。
1069  * @return 工具端模拟输出范围
1070  *
1071  * @throws arcs::common_interface::AuboException
1072  *
1073  * @par Python函数原型
1074  * getToolAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
1075  *
1076  * @par Lua函数原型
1077  * getToolAnalogOutputDomain(index: number) -> number
1078  *
1079  * @par JSON-RPC请求示例
1080  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputDomain","params":[0],"id":1}
1081  *
1082  * @par JSON-RPC响应示例
1083  * {"id":1,"jsonrpc":"2.0","result":0}
1084  *
1085  */
1086  int getToolAnalogOutputDomain(int index);
1087 
1088  /**
1089  * 设置工具端电源电压值(单位V)
1090  *
1091  * @param domain: 工具端电源电压值，可选三个档位，分别为0、12和24。\n
1092  * 0表示0V, 12表示12V, 24表示24V。
1093  *
1094  * @return 成功返回0; 失败返回错误码
1095  * AUBO_REQUEST_IGNORE
1096  * AUBO_BUSY
1097  * AUBO_BAD_STATE
1098  * -AUBO_INVL_ARGUMENT
1099  * -AUBO_BAD_STATE
1100  *
1101  * @throws arcs::common_interface::AuboException
1102  *
1103  * @par Python函数原型
1104  * setToolVoltageOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
1105  *
1106  * @par Lua函数原型
1107  * setToolVoltageOutputDomain(domain: number) -> nil
1108  *
1109  * @par JSON-RPC请求示例
1110  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolVoltageOutputDomain","params":[24],"id":1}
1111  *
1112  * @par JSON-RPC响应示例
1113  * {"id":1,"jsonrpc":"2.0","result":0}
1114  *
1115  */
1116  int setToolVoltageOutputDomain(int domain);
1117 
1118  /**
1119  * 获取工具端电源电压值(单位V)
1120  *
1121  * @return 工具端电源电压值(单位V)
1122  *
1123  * @throws arcs::common_interface::AuboException
1124  *
1125  * @par Python函数原型
1126  * getToolVoltageOutputDomain(self: pyaubo_sdk.IoControl) -> int
1127  *
1128  * @par Lua函数原型
1129  * getToolVoltageOutputDomain() -> number
1130  *
1131  * @par JSON-RPC请求示例
1132  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolVoltageOutputDomain","params":[],"id":1}
1133  *
1134  * @par JSON-RPC响应示例
1135  * {"id":1,"jsonrpc":"2.0","result":0}
1136  *
1137  */
1138  int getToolVoltageOutputDomain();
1139 
1140  /**
1141  * 设置标准数字输出值
1142  *
1143  * @param index: 表示IO口的管脚，
1144 
1145  * @param value: 输出值
1146  * @return 成功返回0；失败返回错误码
1147  * AUBO_REQUEST_IGNORE
1148  * AUBO_BUSY
1149  * AUBO_BAD_STATE
1150  * -AUBO_INVL_ARGUMENT
1151  * -AUBO_BAD_STATE
1152  *
1153  * @throws arcs::common_interface::AuboException
1154  *
1155  * @par Python函数原型
1156  * setStandardDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1157  * bool) -> int
1158  *
1159  * @par Lua函数原型
1160  * setStandardDigitalOutput(index: number, value: boolean) -> nil
1161  *
1162  * @par JSON-RPC请求示例
1163  * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutput","params":[0,true],"id":1}
1164  *
1165  * @par JSON-RPC响应示例
1166  * {"id":1,"jsonrpc":"2.0","result":0}
1167  *
1168  */
1169  int setStandardDigitalOutput(int index, bool value);
1170 
1171  /**
1172  * 设置数字输出脉冲
1173  *
1174  * @param index
1175  * @param value
1176  * @param duration
1177  *
1178  * @return 成功返回0；失败返回错误码
1179  * AUBO_REQUEST_IGNORE
1180  * AUBO_BUSY
1181  * AUBO_BAD_STATE
1182  * -AUBO_INVL_ARGUMENT
1183  * -AUBO_BAD_STATE
1184  *
1185  * @throws arcs::common_interface::AuboException
1186  *
1187  * @par Python函数原型
1188  * setStandardDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int,
1189  * arg1: bool, arg2: float) -> int
1190  *
1191  * @par Lua函数原型
1192  * setStandardDigitalOutputPulse(index: number, value: boolean, duration:
1193  * number) -> nil
1194  *
1195  * @par JSON-RPC请求示例
1196  * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutputPulse","params":[0,true,0.5],"id":1}
1197  *
1198  * @par JSON-RPC响应示例
1199  * {"id":1,"jsonrpc":"2.0","result":0}
1200  *
1201  */
1202  int setStandardDigitalOutputPulse(int index, bool value, double duration);
1203 
1204  /**
1205  * 设置工具端数字输出值
1206  *
1207  * @param index: 表示IO口的管脚，管脚编号从0开始。
1208  * 例如，0表示第一个管脚。
1209  * @param value: 数字输出值
1210  *
1211  * @return 成功返回0；失败返回错误码
1212  * AUBO_REQUEST_IGNORE
1213  * AUBO_BUSY
1214  * AUBO_BAD_STATE
1215  * -AUBO_INVL_ARGUMENT
1216  * -AUBO_BAD_STATE
1217  *
1218  * @throws arcs::common_interface::AuboException
1219  *
1220  * @par Python函数原型
1221  * setToolDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1: bool)
1222  * -> int
1223  *
1224  * @par Lua函数原型
1225  * setToolDigitalOutput(index: number, value: boolean) -> nil
1226  *
1227  * @par JSON-RPC请求示例
1228  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutput","params":[0,true],"id":1}
1229  *
1230  * @par JSON-RPC响应示例
1231  * {"id":1,"jsonrpc":"2.0","result":0}
1232  *
1233  */
1234  int setToolDigitalOutput(int index, bool value);
1235 
1236  /**
1237  * 设置工具端数字输出脉冲
1238  *
1239  * @param index
1240  * @param value
1241  * @param duration
1242  *
1243  * @return 成功返回0；失败返回错误码
1244  * AUBO_REQUEST_IGNORE
1245  * AUBO_BUSY
1246  * AUBO_BAD_STATE
1247  * -AUBO_INVL_ARGUMENT
1248  * -AUBO_BAD_STATE
1249  *
1250  * @throws arcs::common_interface::AuboException
1251  *
1252  * @par Python函数原型
1253  * setToolDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1254  * bool, arg2: float) -> int
1255  *
1256  * @par Lua函数原型
1257  * setToolDigitalOutputPulse(index: number, value: boolean, duration:
1258  * number) -> nil
1259  *
1260  * @par JSON-RPC请求示例
1261  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutputPulse","params":[0,true,0.5],"id":1}
1262  *
1263  * @par JSON-RPC响应示例
1264  * {"id":1,"jsonrpc":"2.0","result":0}
1265  *
1266  */
1267  int setToolDigitalOutputPulse(int index, bool value, double duration);
1268 
1269  /**
1270  * 设置可配置数字输出值
1271  *
1272  * @param index: 表示IO口的管脚，管脚编号从0开始。
1273  * 例如，0表示第一个管脚。
1274  * @param value: 数字输出值
1275  *
1276  * @return 成功返回0；失败返回错误码
1277  * AUBO_REQUEST_IGNORE
1278  * AUBO_BUSY
1279  * AUBO_BAD_STATE
1280  * -AUBO_INVL_ARGUMENT
1281  * -AUBO_BAD_STATE
1282  *
1283  * @throws arcs::common_interface::AuboException
1284  *
1285  * @par Python函数原型
1286  * setConfigurableDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1287  * bool) -> int
1288  *
1289  * @par Lua函数原型
1290  * setConfigurableDigitalOutput(index: number, value: boolean) -> nil
1291  *
1292  * @par JSON-RPC请求示例
1293  * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutput","params":[0,true],"id":1}
1294  *
1295  * @par JSON-RPC响应示例
1296  * {"id":1,"jsonrpc":"2.0","result":0}
1297  *
1298  */
1299  int setConfigurableDigitalOutput(int index, bool value);
1300 
1301  /**
1302  * 设置可配置数字输出脉冲
1303  *
1304  * @param index
1305  * @param value
1306  * @param duration
1307  *
1308  * @return 成功返回0；失败返回错误码
1309  * AUBO_REQUEST_IGNORE
1310  * AUBO_BUSY
1311  * AUBO_BAD_STATE
1312  * -AUBO_INVL_ARGUMENT
1313  * -AUBO_BAD_STATE
1314  *
1315  * @throws arcs::common_interface::AuboException
1316  *
1317  * @par Python函数原型
1318  * setConfigurableDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int,
1319  * arg1: bool, arg2: float) -> int
1320  *
1321  * @par Lua函数原型
1322  * setConfigurableDigitalOutputPulse(index: number, value: boolean,
1323  * duration: number) -> nil
1324  *
1325  * @par JSON-RPC请求示例
1326  * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutputPulse","params":[0,true,0.5],"id":1}
1327  *
1328  * @par JSON-RPC响应示例
1329  * {"id":1,"jsonrpc":"2.0","result":0}
1330  *
1331  */
1332  int setConfigurableDigitalOutputPulse(int index, bool value,
1333  double duration);
1334 
1335  /**
1336  * 设置标准模拟输出值
1337  *
1338  * @param index: 表示IO口的管脚，管脚编号从0开始。
1339  * 例如，0表示第一个管脚。
1340  * @param value: 模拟输出值
1341  *
1342  * @return 成功返回0；失败返回错误码
1343  * AUBO_REQUEST_IGNORE
1344  * AUBO_BUSY
1345  * AUBO_BAD_STATE
1346  * -AUBO_INVL_ARGUMENT
1347  * -AUBO_BAD_STATE
1348  *
1349  * @throws arcs::common_interface::AuboException
1350  *
1351  * @par Python函数原型
1352  * setStandardAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1353  * float) -> int
1354  *
1355  * @par Lua函数原型
1356  * setStandardAnalogOutput(index: number, value: number) -> nil
1357  *
1358  */
1359  int setStandardAnalogOutput(int index, double value);
1360 
1361  /**
1362  * 设置工具端模拟输出值
1363  *
1364  * @param index: 表示IO口的管脚，管脚编号从0开始。
1365  * 例如，0表示第一个管脚。
1366  * @param value: 模拟输出
1367  *
1368  * @return 成功返回0；失败返回错误码
1369  * AUBO_REQUEST_IGNORE
1370  * AUBO_BUSY
1371  * AUBO_BAD_STATE
1372  * -AUBO_INVL_ARGUMENT
1373  * -AUBO_BAD_STATE
1374  *
1375  * @throws arcs::common_interface::AuboException
1376  *
1377  * @par Python函数原型
1378  * setToolAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1: float)
1379  * -> int
1380  *
1381  * @par Lua函数原型
1382  * setToolAnalogOutput(index: number, value: number) -> nil
1383  *
1384  * @par JSON-RPC请求示例
1385  * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogOutput","params":[0,0.5],"id":1}
1386  *
1387  * @par JSON-RPC响应示例
1388  * {"id":1,"jsonrpc":"2.0","result":13}
1389  *
1390  */
1391  int setToolAnalogOutput(int index, double value);
1392 
1393  /**
1394  * 获取标准数字输入值
1395  *
1396  * @param index: 表示IO口的管脚，管脚编号从0开始。
1397  * 例如，0表示第一个管脚。
1398  *
1399  * @return 高电平返回true; 低电平返回false
1400  *
1401  * @throws arcs::common_interface::AuboException
1402  *
1403  * @par Python函数原型
1404  * getStandardDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
1405  *
1406  * @par Lua函数原型
1407  * getStandardDigitalInput(index: number) -> boolean
1408  *
1409  * @par JSON-RPC请求示例
1410  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInput","params":[0],"id":1}
1411  *
1412  * @par JSON-RPC响应示例
1413  * {"id":1,"jsonrpc":"2.0","result":false}
1414  *
1415  */
1416  bool getStandardDigitalInput(int index);
1417 
1418  /**
1419  * 获取所有的标准数字输入值
1420  *
1421  * @return 所有的标准数字输入值 \n
1422  * 例如，当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
1423  * 后16位就是所有的标准数字输入状态值，
1424  * 最后一位表示DI00的输入状态值,倒数第二位表示DI01的输入状态值，以此类推。\n
1425  * 1表示高电平状态，0表示低电平状态
1426  *
1427  * @throws arcs::common_interface::AuboException
1428  *
1429  * @par Python函数原型
1430  * getStandardDigitalInputs(self: pyaubo_sdk.IoControl) -> int
1431  *
1432  * @par Lua函数原型
1433  * getStandardDigitalInputs() -> number
1434  *
1435  * @par JSON-RPC请求示例
1436  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputs","params":[],"id":1}
1437  *
1438  * @par JSON-RPC响应示例
1439  * {"id":1,"jsonrpc":"2.0","result":0}
1440  *
1441  */
1442  uint32_t getStandardDigitalInputs();
1443 
1444  /**
1445  * 获取工具端数字输入值
1446  *
1447  * @param index: 表示IO口的管脚，管脚编号从0开始。
1448  * 例如，0表示第一个管脚。
1449  *
1450  * @return 高电平返回true; 低电平返回false
1451  *
1452  * @throws arcs::common_interface::AuboException
1453  *
1454  * @par Python函数原型
1455  * getToolDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
1456  *
1457  * @par Lua函数原型
1458  * getToolDigitalInput(index: number) -> boolean
1459  *
1460  * @par JSON-RPC请求示例
1461  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInput","params":[0],"id":1}
1462  *
1463  * @par JSON-RPC响应示例
1464  * {"id":1,"jsonrpc":"2.0","result":false}
1465  *
1466  */
1467  bool getToolDigitalInput(int index);
1468 
1469  /**
1470  * 获取所有的工具端数字输入值
1471  *
1472  * @return 返回所有的工具端数字输入值
1473  *
1474  * @throws arcs::common_interface::AuboException
1475  *
1476  * @par Python函数原型
1477  * getToolDigitalInputs(self: pyaubo_sdk.IoControl) -> int
1478  *
1479  * @par Lua函数原型
1480  * getToolDigitalInputs() -> number
1481  *
1482  * @par JSON-RPC请求示例
1483  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputs","params":[],"id":1}
1484  *
1485  * @par JSON-RPC响应示例
1486  * {"id":1,"jsonrpc":"2.0","result":0}
1487  *
1488  */
1489  uint32_t getToolDigitalInputs();
1490 
1491  /**
1492  * 获取可配置数字输入值
1493  *
1494  * @note 可用于获取安全IO的输入值
1495  *
1496  * @param index: 表示IO口的管脚，管脚编号从0开始。
1497  * 例如，0表示第一个管脚。
1498  *
1499  * @return 高电平返回true; 低电平返回false
1500  *
1501  * @throws arcs::common_interface::AuboException
1502  *
1503  * @par Python函数原型
1504  * getConfigurableDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) ->
1505  * bool
1506  *
1507  * @par Lua函数原型
1508  * getConfigurableDigitalInput(index: number) -> boolean
1509  *
1510  * @par JSON-RPC请求示例
1511  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInput","params":[0],"id":1}
1512  *
1513  * @par JSON-RPC响应示例
1514  * {"id":1,"jsonrpc":"2.0","result":false}
1515  *
1516  */
1517  bool getConfigurableDigitalInput(int index);
1518 
1519  /**
1520  * 获取所有的可配置数字输入值
1521  *
1522  * @note 可用于获取安全IO的输入值
1523  *
1524  * @return 所有的可配置数字输入值\n
1525  * 例如，当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
1526  * 后16位就是所有的输入状态值，
1527  * 最后一位表示管脚0的输入状态值,倒数第二位表示管脚1的输入状态值，以此类推。\n
1528  * 1表示高电平状态，0表示低电平状态
1529  *
1530  * @throws arcs::common_interface::AuboException
1531  *
1532  * @par Python函数原型
1533  * getConfigurableDigitalInputs(self: pyaubo_sdk.IoControl) -> int
1534  *
1535  * @par Lua函数原型
1536  * getConfigurableDigitalInputs() -> number
1537  *
1538  * @par JSON-RPC请求示例
1539  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputs","params":[],"id":1}
1540  *
1541  * @par JSON-RPC响应示例
1542  * {"id":1,"jsonrpc":"2.0","result":0}
1543  *
1544  */
1545  uint32_t getConfigurableDigitalInputs();
1546 
1547  /**
1548  * 获取标准数字输出值
1549  *
1550  * @param index: 表示IO口的管脚，管脚编号从0开始。
1551  * 例如，0表示第一个管脚。
1552  *
1553  * @return 高电平返回true; 低电平返回false
1554  *
1555  * @throws arcs::common_interface::AuboException
1556  *
1557  * @par Python函数原型
1558  * getStandardDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
1559  *
1560  * @par Lua函数原型
1561  * getStandardDigitalOutput(index: number) -> boolean
1562  *
1563  * @par JSON-RPC请求示例
1564  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutput","params":[0],"id":1}
1565  *
1566  * @par JSON-RPC响应示例
1567  * {"id":1,"jsonrpc":"2.0","result":true}
1568  *
1569  */
1570  bool getStandardDigitalOutput(int index);
1571 
1572  /**
1573  * 获取所有的标准数字输出值
1574  *
1575  * @return 所有的标准数字输出值 \n
1576  * 例如，当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
1577  * 后16位就是所有的标准数字输出状态值，
1578  * 最后一位表示DI00的输出状态值,倒数第二位表示DI01的输出状态值，以此类推。\n
1579  * 1表示高电平状态，0表示低电平状态.
1580  *
1581  * @throws arcs::common_interface::AuboException
1582  *
1583  * @par Python函数原型
1584  * getStandardDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
1585  *
1586  * @par Lua函数原型
1587  * getStandardDigitalOutputs() -> number
1588  *
1589  * @par JSON-RPC请求示例
1590  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputs","params":[],"id":1}
1591  *
1592  * @par JSON-RPC响应示例
1593  * {"id":1,"jsonrpc":"2.0","result":69}
1594  *
1595  */
1596  uint32_t getStandardDigitalOutputs();
1597 
1598  /**
1599  * 获取工具端数字输出值
1600  *
1601  * @param index: 表示IO口的管脚，管脚编号从0开始。
1602  * 例如，0表示第一个管脚。
1603  *
1604  * @return 高电平返回true; 低电平返回false
1605  *
1606  * @throws arcs::common_interface::AuboException
1607  *
1608  * @par Python函数原型
1609  * getToolDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
1610  *
1611  * @par Lua函数原型
1612  * getToolDigitalOutput(index: number) -> boolean
1613  *
1614  * @par JSON-RPC请求示例
1615  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutput","params":[0],"id":1}
1616  *
1617  * @par JSON-RPC响应示例
1618  * {"id":1,"jsonrpc":"2.0","result":false}
1619  *
1620  */
1621  bool getToolDigitalOutput(int index);
1622 
1623  /**
1624  * 获取所有的工具端数字输出值
1625  *
1626  * @return 所有的工具端数字输出值
1627  *
1628  * @throws arcs::common_interface::AuboException
1629  *
1630  * @par Python函数原型
1631  * getToolDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
1632  *
1633  * @par Lua函数原型
1634  * getToolDigitalOutputs() -> number
1635  *
1636  * @par JSON-RPC请求示例
1637  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputs","params":[],"id":1}
1638  *
1639  * @par JSON-RPC响应示例
1640  * {"id":1,"jsonrpc":"2.0","result":9}
1641  *
1642  */
1643  uint32_t getToolDigitalOutputs();
1644 
1645  /**
1646  * 获取可配值数字输出值
1647  *
1648  * @note 可用于获取安全IO的输出值
1649  *
1650  * @param index: 表示IO口的管脚，管脚编号从0开始。
1651  * 例如，0表示第一个管脚。
1652  *
1653  * @return 高电平返回true; 低电平返回false
1654  *
1655  * @throws arcs::common_interface::AuboException
1656  *
1657  * @par Python函数原型
1658  * getConfigurableDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) ->
1659  * bool
1660  *
1661  * @par Lua函数原型
1662  * getConfigurableDigitalOutput(index: number) -> boolean
1663  *
1664  * @par JSON-RPC请求示例
1665  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutput","params":[0],"id":1}
1666  *
1667  * @par JSON-RPC响应示例
1668  * {"id":1,"jsonrpc":"2.0","result":true}
1669  *
1670  */
1671  bool getConfigurableDigitalOutput(int index);
1672 
1673  /**
1674  * 获取所有的可配值数字输出值
1675  *
1676  * @note 可用于获取安全IO的输出值
1677  *
1678  * @return 所有的可配值数字输出\n
1679  * 例如，当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
1680  * 后16位就是所有的输出值，
1681  * 最后一位表示管脚0的输出状态值,倒数第二位表示管脚1的输出状态值，以此类推。\n
1682  * 1表示高电平状态，0表示低电平状态.
1683  *
1684  * @throws arcs::common_interface::AuboException
1685  *
1686  * @par Python函数原型
1687  * getConfigurableDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
1688  *
1689  * @par Lua函数原型
1690  * getConfigurableDigitalOutputs() -> number
1691  *
1692  * @par JSON-RPC请求示例
1693  * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputs","params":[],"id":1}
1694  *
1695  * @par JSON-RPC响应示例
1696  * {"id":1,"jsonrpc":"2.0","result":1}
1697  *
1698  */
1699  uint32_t getConfigurableDigitalOutputs();
1700 
1701  /**
1702  * 获取标准模拟输入值
1703  *
1704  * @param index: 表示IO口的管脚，管脚编号从0开始。
1705  * 例如，0表示第一个管脚。
1706  *
1707  * @return 标准模拟输入值
1708  *
1709  * @throws arcs::common_interface::AuboException
1710  *
1711  * @par Python函数原型
1712  * getStandardAnalogInput(self: pyaubo_sdk.IoControl, arg0: int) -> float
1713  *
1714  * @par Lua函数原型
1715  * getStandardAnalogInput(index: number) -> number
1716  *
1717  * @par JSON-RPC请求示例
1718  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInput","params":[0],"id":1}
1719  *
1720  * @par JSON-RPC响应示例
1721  * {"id":1,"jsonrpc":"2.0","result":0.0}
1722  *
1723  */
1724  double getStandardAnalogInput(int index);
1725 
1726  /**
1727  * 获取工具端模拟输入值
1728  *
1729  * @param index: 表示IO口的管脚，管脚编号从0开始。
1730  * 例如，0表示第一个管脚。
1731  *
1732  * @return 工具端模拟输入值
1733  *
1734  * @throws arcs::common_interface::AuboException
1735  *
1736  * @par Python函数原型
1737  * getToolAnalogInput(self: pyaubo_sdk.IoControl, arg0: int) -> float
1738  *
1739  * @par Lua函数原型
1740  * getToolAnalogInput(index: number) -> number
1741  *
1742  * @par JSON-RPC请求示例
1743  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInput","params":[0],"id":1}
1744  *
1745  * @par JSON-RPC响应示例
1746  * {"id":1,"jsonrpc":"2.0","result":0.0}
1747  *
1748  */
1749  double getToolAnalogInput(int index);
1750 
1751  /**
1752  * 获取标准模拟输出值
1753  *
1754  * @param index: 表示IO口的管脚，管脚编号从0开始。
1755  * 例如，0表示第一个管脚。
1756  *
1757  * @return 标准模拟输出值
1758  *
1759  * @throws arcs::common_interface::AuboException
1760  *
1761  * @par Python函数原型
1762  * getStandardAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int) -> float
1763  *
1764  * @par Lua函数原型
1765  * getStandardAnalogOutput(index: number) -> number
1766  *
1767  * @par JSON-RPC请求示例
1768  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutput","params":[0],"id":1}
1769  *
1770  * @par JSON-RPC响应示例
1771  * {"id":1,"jsonrpc":"2.0","result":0.0}
1772  *
1773  */
1774  double getStandardAnalogOutput(int index);
1775 
1776  /**
1777  * 获取工具端模拟输出值
1778  *
1779  * @param index: 表示IO口的管脚，管脚编号从0开始。
1780  * 例如，0表示第一个管脚。
1781  *
1782  * @return 工具端模拟输出值
1783  *
1784  * @throws arcs::common_interface::AuboException
1785  *
1786  * @par Python函数原型
1787  * getToolAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int) -> float
1788  *
1789  * @par Lua函数原型
1790  * getToolAnalogOutput(index: number) -> number
1791  *
1792  * @par JSON-RPC请求示例
1793  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutput","params":[0],"id":1}
1794  *
1795  * @par JSON-RPC响应示例
1796  * {"id":1,"jsonrpc":"2.0","result":0.0}
1797  *
1798  */
1799  double getToolAnalogOutput(int index);
1800 
1801  /**
1802  * 获取联动输入数量
1803  *
1804  * @return 联动输入数量
1805  *
1806  * @throws arcs::common_interface::AuboException
1807  *
1808  * @par Python函数原型
1809  * getStaticLinkInputNum(self: pyaubo_sdk.IoControl) -> int
1810  *
1811  * @par Lua函数原型
1812  * getStaticLinkInputNum() -> number
1813  *
1814  * @par JSON-RPC请求示例
1815  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkInputNum","params":[],"id":1}
1816  *
1817  * @par JSON-RPC响应示例
1818  * {"id":1,"jsonrpc":"2.0","result":8}
1819  *
1820  */
1821  int getStaticLinkInputNum();
1822 
1823  /**
1824  * 获取联动输出数量
1825  *
1826  * @return 联动输出数量
1827  *
1828  * @throws arcs::common_interface::AuboException
1829  *
1830  * @par Python函数原型
1831  * getStaticLinkOutputNum(self: pyaubo_sdk.IoControl) -> int
1832  *
1833  * @par Lua函数原型
1834  * getStaticLinkOutputNum() -> number
1835  *
1836  * @par JSON-RPC请求示例
1837  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkOutputNum","params":[],"id":1}
1838  *
1839  * @par JSON-RPC响应示例
1840  * {"id":1,"jsonrpc":"2.0","result":0}
1841  *
1842  */
1843  int getStaticLinkOutputNum();
1844 
1845  /**
1846  * 获取所有的联动输入值
1847  *
1848  * @return 所有的联动输入值\n
1849  * 例如，当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
1850  * 后16位就是所有的联动输入状态值，
1851  * 最后一位表示管脚0的输入状态值,倒数第二位表示管脚1的输入状态值，以此类推。\n
1852  * 1表示高电平状态，0表示低电平状态.
1853  *
1854  * @throws arcs::common_interface::AuboException
1855  *
1856  * @par Python函数原型
1857  * getStaticLinkInputs(self: pyaubo_sdk.IoControl) -> int
1858  *
1859  * @par Lua函数原型
1860  * getStaticLinkInputs() -> number
1861  *
1862  * @par JSON-RPC请求示例
1863  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkInputs","params":[],"id":1}
1864  *
1865  * @par JSON-RPC响应示例
1866  * {"id":1,"jsonrpc":"2.0","result":0}
1867  *
1868  */
1869  uint32_t getStaticLinkInputs();
1870 
1871  /**
1872  * 获取所有的联动输出值
1873  *
1874  * @return 返回所有的联动输出值 \n
1875  * 例如，当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
1876  * 后16位就是所有的联动输出状态值，
1877  * 最后一位表示管脚0的输出状态值,倒数第二位表示管脚1的输出状态值，以此类推。\n
1878  * 1表示高电平状态，0表示低电平状态.
1879  *
1880  * @throws arcs::common_interface::AuboException
1881  *
1882  * @par Python函数原型
1883  * getStaticLinkOutputs(self: pyaubo_sdk.IoControl) -> int
1884  *
1885  * @par Lua函数原型
1886  * getStaticLinkOutputs() -> number
1887  *
1888  * @par JSON-RPC请求示例
1889  * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkOutputs","params":[],"id":1}
1890  *
1891  * @par JSON-RPC响应示例
1892  * {"id":1,"jsonrpc":"2.0","result":0}
1893  *
1894  */
1895  uint32_t getStaticLinkOutputs();
1896 
1897  /**
1898  * 机器人是否配置了编码器
1899  *
1900  * @return 机器人配置编码器返回 true, 反之返回 false
1901  *
1902  * @throws arcs::common_interface::AuboException
1903  *
1904  * @par JSON-RPC请求示例
1905  * {"jsonrpc":"2.0","method":"rob1.IoControl.hasEncoderSensor","params":[],"id":1}
1906  *
1907  * @par JSON-RPC响应示例
1908  * {"id":1,"jsonrpc":"2.0","result":true}
1909  *
1910  */
1911  bool hasEncoderSensor();
1912 
1913  /**
1914  * 设置编码器的解码方式
1915  *
1916  * @param type
1917  * @param range_id
1918  * 0 is a 32 bit signed encoder, range [-2147483648, 2147483647]
1919  * 1 is a 8 bit unsigned encoder, range [0, 255]
1920  * 2 is a 16 bit unsigned encoder, range [0, 65535]
1921  * 3 is a 24 bit unsigned encoder, range [0, 16777215]
1922  * 4 is a 32 bit unsigned encoder, range [0, 4294967295]
1923  *
1924  * @return 成功返回0；失败返回错误码
1925  * AUBO_NO_ACCESS
1926  * AUBO_BUSY
1927  * AUBO_BAD_STATE
1928  * -AUBO_INVL_ARGUMENT
1929  * -AUBO_BAD_STATE
1930  *
1931  * @throws arcs::common_interface::AuboException
1932  *
1933  */
1934  int setEncDecoderType(int type, int range_id);
1935 
1936  /**
1937  * 设置脉冲数
1938  *
1939  * @param rick
1940  *
1941  * @return 成功返回0；失败返回错误码
1942  * AUBO_NO_ACCESS
1943  * AUBO_BUSY
1944  * AUBO_BAD_STATE
1945  * -AUBO_INVL_ARGUMENT
1946  * -AUBO_BAD_STATE
1947  *
1948  * @throws arcs::common_interface::AuboException
1949  *
1950  */
1951  int setEncTickCount(int tick);
1952 
1953  /**
1954  * 获取编码器的解码方式
1955  *
1956  * @return 成功返回0；失败返回错误码
1957  * AUBO_NO_ACCESS
1958  * AUBO_BUSY
1959  * AUBO_BAD_STATE
1960  * -AUBO_BAD_STATE
1961  *
1962  * @throws arcs::common_interface::AuboException
1963  *
1964  * @par JSON-RPC请求示例
1965  * {"jsonrpc":"2.0","method":"rob1.IoControl.getEncDecoderType","params":[],"id":1}
1966  *
1967  * @par JSON-RPC响应示例
1968  * {"id":1,"jsonrpc":"2.0","result":0}
1969  *
1970  */
1971  int getEncDecoderType();
1972 
1973  /**
1974  * 获取脉冲数
1975  *
1976  * @return 成功返回0；失败返回错误码
1977  * AUBO_NO_ACCESS
1978  * AUBO_BUSY
1979  * AUBO_BAD_STATE
1980  * -AUBO_BAD_STATE
1981  *
1982  * @throws arcs::common_interface::AuboException
1983  *
1984  * @par JSON-RPC请求示例
1985  * {"jsonrpc":"2.0","method":"rob1.IoControl.getEncTickCount","params":[],"id":1}
1986  *
1987  * @par JSON-RPC响应示例
1988  * {"id":1,"jsonrpc":"2.0","result":0}
1989  *
1990  */
1991  int getEncTickCount();
1992 
1993  /**
1994  * 防止在计数超出范围时计数错误
1995  *
1996  * @param delta_count
1997  *
1998  * @return 成功返回0；失败返回错误码
1999  * AUBO_NO_ACCESS
2000  * AUBO_BUSY
2001  * AUBO_BAD_STATE
2002  * -AUBO_BAD_STATE
2003  *
2004  * @throws arcs::common_interface::AuboException
2005  *
2006  */
2007  int unwindEncDeltaTickCount(int delta_count);
2008 
2009  /**
2010  * 获取末端按钮状态
2011  *
2012  * @return 按下返回true; 否则返回false
2013  *
2014  * @throws arcs::common_interface::AuboException
2015  *
2016  * @par Python函数原型
2017  * getToolButtonStatus() -> bool
2018  *
2019  * @par Lua函数原型
2020  * getToolButtonStatus() -> boolean
2021  *
2022  * @par JSON-RPC请求示例
2023  * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolButtonStatus","params":[],"id":1}
2024  *
2025  * @par JSON-RPC响应示例
2026  * {"id":1,"jsonrpc":"2.0","result":false}
2027  *
2028  */
2029  bool getToolButtonStatus();
2030 
2031  /**
2032  * 获取手柄按键状态
2033  *
2034  * @note 获取手柄按键状态
2035  *
2036  * @return 所有的手柄按键输入值\n
2037  * 例如，当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
2038  * 后16位就是所有的输入状态值，
2039  * 最后一位表示管脚0的输入状态值,倒数第二位表示管脚1的输入状态值，以此类推。\n
2040  * 1表示高电平状态，0表示低电平状态
2041  *
2042  * @throws arcs::common_interface::AuboException
2043  *
2044  * @par Python函数原型
2045  * getHandleIoStatus(self: pyaubo_sdk.IoControl) -> int
2046  *
2047  * @par Lua函数原型
2048  * getHandleIoStatus() -> number
2049  *
2050  * @par JSON-RPC请求示例
2051  * {"jsonrpc":"2.0","method":"rob1.IoControl.getHandleIoStatus","params":[],"id":1}
2052  *
2053  * @par JSON-RPC响应示例
2054  * {"id":1,"jsonrpc":"2.0","result":0}
2055  *
2056  */
2057  uint32_t getHandleIoStatus();
2058 
2059  /**
2060  * 获取手柄类型
2061  *
2062  * @return type
2063  *
2064  * @throws arcs::common_interface::AuboException
2065  *
2066  * @par Python函数原型
2067  * getHandleType() -> int
2068  *
2069  * @par Lua函数原型
2070  * getHandleType() -> int
2071  *
2072  * @par JSON-RPC请求示例
2073  * {"jsonrpc":"2.0","method":"rob1.IoControl.getHandleType","params":[],"id":1}
2074  *
2075  * @par JSON-RPC响应示例
2076  * {"id":1,"jsonrpc":"2.0","result":0}
2077  *
2078  */
2079  int getHandleType();
2080 
2081 
2082 protected:
2083  void *d_;
2084 };
2085 using IoControlPtr = std::shared_ptr<IoControl>;
2086 
2087 // clang-format off
2088 #define IoControl_DECLARES \
2089  _FUNC(IoControl, 0, getStandardDigitalInputNum) \
2090  _FUNC(IoControl, 0, getToolDigitalInputNum) \
2091  _FUNC(IoControl, 0, getConfigurableDigitalInputNum) \
2092  _FUNC(IoControl, 0, getStandardDigitalOutputNum) \
2093  _FUNC(IoControl, 0, getToolDigitalOutputNum) \
2094  _INST(IoControl, 2, setToolIoInput, index, input) \
2095  _FUNC(IoControl, 1, isToolIoInput, index) \
2096  _FUNC(IoControl, 0, getConfigurableDigitalOutputNum) \
2097  _FUNC(IoControl, 0, getStandardAnalogInputNum) \
2098  _FUNC(IoControl, 0, getToolAnalogInputNum) \
2099  _FUNC(IoControl, 0, getStandardAnalogOutputNum) \
2100  _FUNC(IoControl, 0, getToolAnalogOutputNum) \
2101  _INST(IoControl, 0, setDigitalInputActionDefault) \
2102  _INST(IoControl, 2, setStandardDigitalInputAction, index, action) \
2103  _INST(IoControl, 2, setToolDigitalInputAction, index, action) \
2104  _INST(IoControl, 2, setConfigurableDigitalInputAction, index, action) \
2105  _FUNC(IoControl, 1, getStandardDigitalInputAction, index) \
2106  _FUNC(IoControl, 1, getToolDigitalInputAction, index) \
2107  _FUNC(IoControl, 1, getConfigurableDigitalInputAction, index) \
2108  _INST(IoControl, 0, setDigitalOutputRunstateDefault) \
2109  _INST(IoControl, 2, setStandardDigitalOutputRunstate, index, runstate) \
2110  _INST(IoControl, 2, setToolDigitalOutputRunstate, index, runstate) \
2111  _INST(IoControl, 2, setConfigurableDigitalOutputRunstate, index, runstate) \
2112  _FUNC(IoControl, 1, getStandardDigitalOutputRunstate, index) \
2113  _FUNC(IoControl, 1, getToolDigitalOutputRunstate, index) \
2114  _FUNC(IoControl, 1, getConfigurableDigitalOutputRunstate, index) \
2115  _INST(IoControl, 2, setStandardAnalogOutputRunstate, index, runstate) \
2116  _INST(IoControl, 2, setToolAnalogOutputRunstate, index, runstate) \
2117  _FUNC(IoControl, 1, getStandardAnalogOutputRunstate, index) \
2118  _FUNC(IoControl, 1, getToolAnalogOutputRunstate, index) \
2119  _INST(IoControl, 2, setStandardAnalogInputDomain, index, domain) \
2120  _INST(IoControl, 2, setToolAnalogInputDomain, index, domain) \
2121  _FUNC(IoControl, 1, getStandardAnalogInputDomain, index) \
2122  _FUNC(IoControl, 1, getToolAnalogInputDomain, index) \
2123  _INST(IoControl, 2, setStandardAnalogOutputDomain, index, domain) \
2124  _INST(IoControl, 2, setToolAnalogOutputDomain, index, domain) \
2125  _INST(IoControl, 1, setToolVoltageOutputDomain, domain) \
2126  _FUNC(IoControl, 0, getToolVoltageOutputDomain) \
2127  _FUNC(IoControl, 1, getStandardAnalogOutputDomain, index) \
2128  _FUNC(IoControl, 1, getToolAnalogOutputDomain, index) \
2129  _INST(IoControl, 2, setStandardDigitalOutput, index, value) \
2130  _INST(IoControl, 3, setStandardDigitalOutputPulse, index, value, duration) \
2131  _INST(IoControl, 2, setToolDigitalOutput, index, value) \
2132  _INST(IoControl, 3, setToolDigitalOutputPulse, index, value, duration) \
2133  _INST(IoControl, 2, setConfigurableDigitalOutput, index, value) \
2134  _INST(IoControl, 3, setConfigurableDigitalOutputPulse, index, value, duration) \
2135  _INST(IoControl, 2, setStandardAnalogOutput, index, value) \
2136  _INST(IoControl, 2, setToolAnalogOutput, index, value) \
2137  _FUNC(IoControl, 1, getStandardDigitalInput, index) \
2138  _FUNC(IoControl, 0, getStandardDigitalInputs) \
2139  _FUNC(IoControl, 1, getToolDigitalInput, index) \
2140  _FUNC(IoControl, 0, getToolDigitalInputs) \
2141  _FUNC(IoControl, 1, getConfigurableDigitalInput, index) \
2142  _FUNC(IoControl, 0, getConfigurableDigitalInputs) \
2143  _FUNC(IoControl, 1, getStandardAnalogInput, index) \
2144  _FUNC(IoControl, 1, getToolAnalogInput, index) \
2145  _FUNC(IoControl, 1, getStandardDigitalOutput, index) \
2146  _FUNC(IoControl, 0, getStandardDigitalOutputs) \
2147  _FUNC(IoControl, 1, getToolDigitalOutput, index) \
2148  _FUNC(IoControl, 0, getToolDigitalOutputs) \
2149  _FUNC(IoControl, 1, getConfigurableDigitalOutput, index) \
2150  _FUNC(IoControl, 0, getConfigurableDigitalOutputs) \
2151  _FUNC(IoControl, 1, getStandardAnalogOutput, index) \
2152  _FUNC(IoControl, 1, getToolAnalogOutput, index) \
2153  _FUNC(IoControl, 0, getStaticLinkInputNum) \
2154  _FUNC(IoControl, 0, getStaticLinkOutputNum) \
2155  _FUNC(IoControl, 0, getStaticLinkInputs) \
2156  _FUNC(IoControl, 0, getStaticLinkOutputs) \
2157  _FUNC(IoControl, 0, hasEncoderSensor) \
2158  _FUNC(IoControl, 2, setEncDecoderType, type, range_id) \
2159  _FUNC(IoControl, 1, setEncTickCount, tick) \
2160  _FUNC(IoControl, 0, getEncDecoderType) \
2161  _FUNC(IoControl, 0, getEncTickCount) \
2162  _FUNC(IoControl, 1, unwindEncDeltaTickCount, delta_count) \
2163  _FUNC(IoControl, 0, getToolButtonStatus) \
2164  _FUNC(IoControl, 0, getHandleIoStatus) \
2165  _FUNC(IoControl, 0, getHandleType)
2166 
2167 // clang-format on
2168 } // namespace common_interface
2169 } // namespace arcs
2170 
2171 #endif // AUBO_SDK_IO_CONTROL_INTERFACE_H
type_def.h
数据类型的定义
arcs::common_interface::IoControl::d_
void * d_
Definition: io_control.h:2083
arcs::common_interface::StandardOutputRunState
StandardOutputRunState
标准输出运行状态
Definition: type_def.h:489
arcs::common_interface::IoControl
IoControl类提供了一系列的接口对机器人标配的一些数字、模拟IO进行配置，输出状态设置、读取 ...
Definition: io_control.h:28
arcs::common_interface::StandardInputAction
StandardInputAction
The StandardInputAction enum.
Definition: type_def.h:497
arcs::common_interface::IoControlPtr
std::shared_ptr< IoControl > IoControlPtr
Definition: io_control.h:2085
arcs
Definition: aubo_api.h:17
制作者   doxygen 1.8.11