AUBO SDK  0.26.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
13namespace arcs {
14namespace common_interface {
15
16/**
17 * \chinese
18 * IoControl类提供了一系列的接口对机器人标配的一些数字、模拟IO进行配置,输出状态设置、读取
19 *
20 * 1. 获取各种IO的数量 \n
21 * 2. 配置IO的输入输出功能 \n
22 * 3. 可配置IO的配置 \n
23 * 4. 模拟IO的输入输出范围设置、读取
24 *
25 * 标准数字输入输出:控制柜IO面板上的标准IO \n
26 * 工具端数字输入输出:通过工具末端航插暴露的数字IO \n
27 * 可配置输入输出:可以配置为安全IO或者普通数字IO \n
28 * \endchinese
29 * \english
30 * The IoControl class provides a series of interfaces for configuring and reading the robot's standard digital and analog IO, as well as setting output states.
31 *
32 * 1. Get the number of various IOs \n
33 * 2. Configure IO input/output functions \n
34 * 3. Configuration of configurable IOs \n
35 * 4. Set and read the input/output range of analog IOs
36 *
37 * Standard digital input/output: Standard IOs on the control cabinet IO panel \n
38 * Tool digital input/output: Digital IOs exposed via the tool-end connector \n
39 * Configurable input/output: Can be configured as safety IO or general digital IO \n
40 * \endenglish
41 */
42class ARCS_ABI_EXPORT IoControl
43{
44public:
46 virtual ~IoControl();
47
48 /**
49 * \chinese
50 * 获取标准数字输入数量
51 *
52 * @return 标准数字输入数量
53 *
54 * @throws arcs::common_interface::AuboException
55 *
56 * @par Python函数原型
57 * getStandardDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
58 *
59 * @par Lua函数原型
60 * getStandardDigitalInputNum() -> number
61 *
62 * @par Lua示例
63 * num = getStandardDigitalInputNum()
64 *
65 * @par JSON-RPC请求示例
66 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputNum","params":[],"id":1}
67 *
68 * @par JSON-RPC响应示例
69 * {"id":1,"jsonrpc":"2.0","result":16}
70 *
71 * \endchinese
72 * \english
73 * Get the number of standard digital inputs.
74 *
75 * @return Number of standard digital inputs.
76 *
77 * @throws arcs::common_interface::AuboException
78 *
79 * @par Python function prototype
80 * getStandardDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
81 *
82 * @par Lua function prototype
83 * getStandardDigitalInputNum() -> number
84 *
85 * @par Lua example
86 * num = getStandardDigitalInputNum()
87 *
88 * @par JSON-RPC request example
89 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputNum","params":[],"id":1}
90 *
91 * @par JSON-RPC response example
92 * {"id":1,"jsonrpc":"2.0","result":16}
93 *
94 * \endenglish
95 */
97
98 /**
99 * \chinese
100 * 获取工具端数字IO数量(包括数字输入和数字输出)
101 *
102 * @return 工具端数字IO数量(包括数字输入和数字输出)
103 *
104 * @throws arcs::common_interface::AuboException
105 *
106 * @par Python函数原型
107 * getToolDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
108 *
109 * @par Lua函数原型
110 * getToolDigitalInputNum() -> number
111 *
112 * @par Lua示例
113 * num = getStandardDigitalInputNum()
114 *
115 * @par JSON-RPC请求示例
116 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputNum","params":[],"id":1}
117 *
118 * @par JSON-RPC响应示例
119 * {"id":1,"jsonrpc":"2.0","result":4}
120 *
121 * \endchinese
122 * \english
123 * Get the number of tool digital IOs (including digital inputs and outputs).
124 *
125 * @return Number of tool digital IOs (including digital inputs and outputs).
126 *
127 * @throws arcs::common_interface::AuboException
128 *
129 * @par Python function prototype
130 * getToolDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
131 *
132 * @par Lua function prototype
133 * getToolDigitalInputNum() -> number
134 *
135 * @par Lua example
136 * num = getStandardDigitalInputNum()
137 *
138 * @par JSON-RPC request example
139 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputNum","params":[],"id":1}
140 *
141 * @par JSON-RPC response example
142 * {"id":1,"jsonrpc":"2.0","result":4}
143 *
144 * \endenglish
145 */
147
148 /**
149 * \chinese
150 * 获取可配置数字输入数量
151 *
152 * @return 可配置数字输入数量
153 *
154 * @throws arcs::common_interface::AuboException
155 *
156 * @par Python函数原型
157 * getConfigurableDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
158 *
159 * @par Lua函数原型
160 * getConfigurableDigitalInputNum() -> number
161 *
162 * @par Lua示例
163 * num = getConfigurableDigitalInputNum()
164 *
165 * @par JSON-RPC请求示例
166 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputNum","params":[],"id":1}
167 *
168 * @par JSON-RPC响应示例
169 * {"id":1,"jsonrpc":"2.0","result":16}
170 *
171 * \endchinese
172 * \english
173 * Get the number of configurable digital inputs.
174 *
175 * @return Number of configurable digital inputs.
176 *
177 * @throws arcs::common_interface::AuboException
178 *
179 * @par Python function prototype
180 * getConfigurableDigitalInputNum(self: pyaubo_sdk.IoControl) -> int
181 *
182 * @par Lua function prototype
183 * getConfigurableDigitalInputNum() -> number
184 *
185 * @par Lua example
186 * num = getConfigurableDigitalInputNum()
187 *
188 * @par JSON-RPC request example
189 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputNum","params":[],"id":1}
190 *
191 * @par JSON-RPC response example
192 * {"id":1,"jsonrpc":"2.0","result":16}
193 *
194 * \endenglish
195 */
197
198 /**
199 * \chinese
200 * 获取标准数字输出数量
201 *
202 * @return 标准数字输出数量
203 *
204 * @throws arcs::common_interface::AuboException
205 *
206 * @par Python函数原型
207 * getStandardDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
208 *
209 * @par Lua函数原型
210 * getStandardDigitalOutputNum() -> number
211 *
212 * @par Lua示例
213 * num = getStandardDigitalOutputNum()
214 *
215 * @par JSON-RPC请求示例
216 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputNum","params":[],"id":1}
217 *
218 * @par JSON-RPC响应示例
219 * {"id":1,"jsonrpc":"2.0","result":8}
220 *
221 * \endchinese
222 * \english
223 * Get the number of standard digital outputs.
224 *
225 * @return Number of standard digital outputs.
226 *
227 * @throws arcs::common_interface::AuboException
228 *
229 * @par Python function prototype
230 * getStandardDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
231 *
232 * @par Lua function prototype
233 * getStandardDigitalOutputNum() -> number
234 *
235 * @par Lua example
236 * num = getStandardDigitalOutputNum()
237 *
238 * @par JSON-RPC request example
239 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputNum","params":[],"id":1}
240 *
241 * @par JSON-RPC response example
242 * {"id":1,"jsonrpc":"2.0","result":8}
243 *
244 * \endenglish
245 */
247
248 /**
249 * \chinese
250 * 获取工具端数字IO数量(包括数字输入和数字输出)
251 *
252 * @return 工具端数字IO数量(包括数字输入和数字输出)
253 *
254 * @throws arcs::common_interface::AuboException
255 *
256 * @par Python函数原型
257 * getToolDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
258 *
259 * @par Lua函数原型
260 * getToolDigitalOutputNum() -> number
261 *
262 * @par Lua示例
263 * num = getToolDigitalOutputNum()
264 *
265 * @par JSON-RPC请求示例
266 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputNum","params":[],"id":1}
267 *
268 * @par JSON-RPC响应示例
269 * {"id":1,"jsonrpc":"2.0","result":4}
270 *
271 * \endchinese
272 * \english
273 * Get the number of tool digital IOs (including digital inputs and outputs).
274 *
275 * @return Number of tool digital IOs (including digital inputs and outputs).
276 *
277 * @throws arcs::common_interface::AuboException
278 *
279 * @par Python function prototype
280 * getToolDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
281 *
282 * @par Lua function prototype
283 * getToolDigitalOutputNum() -> number
284 *
285 * @par Lua example
286 * num = getToolDigitalOutputNum()
287 *
288 * @par JSON-RPC request example
289 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputNum","params":[],"id":1}
290 *
291 * @par JSON-RPC response example
292 * {"id":1,"jsonrpc":"2.0","result":4}
293 *
294 * \endenglish
295 */
297
298 /**
299 * \chinese
300 * 设置指定的工具端数字IO为输入或输出
301 *
302 * 工具端数字IO比较特殊,IO可以配置为输入或者输出
303 *
304 * @param index: 表示IO口的管脚,管脚编号从0开始。
305 * 例如,0表示第一个管脚。
306 * @param input: 表示指定IO是否为输入。
307 * input 为true时,设置指定IO为输入,否则为输出
308 * @return 成功返回0;失败返回错误码
309 * AUBO_BUSY
310 * AUBO_BAD_STATE
311 * -AUBO_INVL_ARGUMENT
312 * -AUBO_BAD_STATE
313 *
314 * @throws arcs::common_interface::AuboException
315 *
316 * @par Python函数原型
317 * setToolIoInput(self: pyaubo_sdk.IoControl, arg0: int, arg1: bool) -> int
318 *
319 * @par Lua函数原型
320 * setToolIoInput(index: number, input: boolean) -> nil
321 *
322 * @par Lua示例
323 * setToolIoInput(0,true)
324 *
325 * @par JSON-RPC请求示例
326 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolIoInput","params":[0,true],"id":1}
327 *
328 * @par JSON-RPC响应示例
329 * {"id":1,"jsonrpc":"2.0","result":0}
330 *
331 * \endchinese
332 * \english
333 * Set the specified tool digital IO as input or output.
334 *
335 * Tool digital IOs are special and can be configured as input or output.
336 *
337 * @param index: Indicates the IO pin, starting from 0.
338 * For example, 0 means the first pin.
339 * @param input: Indicates whether the specified IO is input.
340 * If input is true, set the IO as input; otherwise, set as output.
341 * @return Returns 0 on success; error code on failure.
342 * AUBO_BUSY
343 * AUBO_BAD_STATE
344 * -AUBO_INVL_ARGUMENT
345 * -AUBO_BAD_STATE
346 *
347 * @throws arcs::common_interface::AuboException
348 *
349 * @par Python function prototype
350 * setToolIoInput(self: pyaubo_sdk.IoControl, arg0: int, arg1: bool) -> int
351 *
352 * @par Lua function prototype
353 * setToolIoInput(index: number, input: boolean) -> nil
354 *
355 * @par Lua example
356 * setToolIoInput(0,true)
357 *
358 * @par JSON-RPC request example
359 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolIoInput","params":[0,true],"id":1}
360 *
361 * @par JSON-RPC response example
362 * {"id":1,"jsonrpc":"2.0","result":0}
363 *
364 * \endenglish
365 */
366 int setToolIoInput(int index, bool input);
367
368 /**
369 * \chinese
370 * 判断指定的工具端数字IO类型是否为输入
371 *
372 * @param index: 表示IO口的管脚,管脚编号从0开始。
373 * 例如,0表示第一个管脚。
374 * @return 当指定的IO为输入时返回 true, 否则为 false
375 *
376 * @throws arcs::common_interface::AuboException
377 *
378 * @par Python函数原型
379 * isToolIoInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
380 *
381 * @par Lua函数原型
382 * isToolIoInput(index: number) -> boolean
383 *
384 * @par Lua示例
385 * status = isToolIoInput(0)
386 *
387 * @par JSON-RPC请求示例
388 * {"jsonrpc":"2.0","method":"rob1.IoControl.isToolIoInput","params":[0],"id":1}
389 *
390 * @par JSON-RPC响应示例
391 * {"id":1,"jsonrpc":"2.0","result":true}
392 *
393 * \endchinese
394 * \english
395 * Determine whether the specified tool digital IO is configured as input.
396 *
397 * @param index: Indicates the IO pin, starting from 0.
398 * For example, 0 means the first pin.
399 * @return Returns true if the specified IO is input, otherwise false.
400 *
401 * @throws arcs::common_interface::AuboException
402 *
403 * @par Python function prototype
404 * isToolIoInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
405 *
406 * @par Lua function prototype
407 * isToolIoInput(index: number) -> boolean
408 *
409 * @par Lua example
410 * status = isToolIoInput(0)
411 *
412 * @par JSON-RPC request example
413 * {"jsonrpc":"2.0","method":"rob1.IoControl.isToolIoInput","params":[0],"id":1}
414 *
415 * @par JSON-RPC response example
416 * {"id":1,"jsonrpc":"2.0","result":true}
417 *
418 * \endenglish
419 */
420 bool isToolIoInput(int index);
421
422 /**
423 * \chinese
424 * 获取可配置数字输出数量
425 *
426 * @return 可配置数字输出数量
427 *
428 * @throws arcs::common_interface::AuboException
429 *
430 * @par Python函数原型
431 * getConfigurableDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
432 *
433 * @par Lua函数原型
434 * getConfigurableDigitalOutputNum() -> number
435 *
436 * @par Lua示例
437 * num = getConfigurableDigitalOutputNum()
438 *
439 * @par JSON-RPC请求示例
440 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputNum","params":[],"id":1}
441 *
442 * @par JSON-RPC响应示例
443 * {"id":1,"jsonrpc":"2.0","result":16}
444 *
445 * \endchinese
446 * \english
447 * Get the number of configurable digital outputs.
448 *
449 * @return Number of configurable digital outputs.
450 *
451 * @throws arcs::common_interface::AuboException
452 *
453 * @par Python function prototype
454 * getConfigurableDigitalOutputNum(self: pyaubo_sdk.IoControl) -> int
455 *
456 * @par Lua function prototype
457 * getConfigurableDigitalOutputNum() -> number
458 *
459 * @par Lua example
460 * num = getConfigurableDigitalOutputNum()
461 *
462 * @par JSON-RPC request example
463 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputNum","params":[],"id":1}
464 *
465 * @par JSON-RPC response example
466 * {"id":1,"jsonrpc":"2.0","result":16}
467 *
468 * \endenglish
469 */
471
472 /**
473 * \chinese
474 * 获取标准模拟输入数量
475 *
476 * @return 标准模拟输入数量
477 *
478 * @throws arcs::common_interface::AuboException
479 *
480 * @par Python函数原型
481 * getStandardAnalogInputNum(self: pyaubo_sdk.IoControl) -> int
482 *
483 * @par Lua函数原型
484 * getStandardAnalogInputNum() -> number
485 *
486 * @par Lua示例
487 * num = getStandardAnalogInputNum()
488 *
489 * @par JSON-RPC请求示例
490 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInputNum","params":[],"id":1}
491 *
492 * @par JSON-RPC响应示例
493 * {"id":1,"jsonrpc":"2.0","result":2}
494 *
495 * \endchinese
496 * \english
497 * Get the number of standard analog inputs.
498 *
499 * @return Number of standard analog inputs.
500 *
501 * @throws arcs::common_interface::AuboException
502 *
503 * @par Python function prototype
504 * getStandardAnalogInputNum(self: pyaubo_sdk.IoControl) -> int
505 *
506 * @par Lua function prototype
507 * getStandardAnalogInputNum() -> number
508 *
509 * @par Lua example
510 * num = getStandardAnalogInputNum()
511 *
512 * @par JSON-RPC request example
513 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInputNum","params":[],"id":1}
514 *
515 * @par JSON-RPC response example
516 * {"id":1,"jsonrpc":"2.0","result":2}
517 *
518 * \endenglish
519 */
521
522 /**
523 * \chinese
524 * 获取工具端模拟输入数量
525 *
526 * @return 工具端模拟输入数量
527 *
528 * @throws arcs::common_interface::AuboException
529 *
530 * @par Python函数原型
531 * getToolAnalogInputNum(self: pyaubo_sdk.IoControl) -> int
532 *
533 * @par Lua函数原型
534 * getToolAnalogInputNum() -> number
535 *
536 * @par Lua示例
537 * num = getToolAnalogInputNum()
538 *
539 * @par JSON-RPC请求示例
540 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInputNum","params":[],"id":1}
541 *
542 * @par JSON-RPC响应示例
543 * {"id":1,"jsonrpc":"2.0","result":2}
544 *
545 * \endchinese
546 * \english
547 * Get the number of tool analog inputs.
548 *
549 * @return Number of tool analog inputs.
550 *
551 * @throws arcs::common_interface::AuboException
552 *
553 * @par Python function prototype
554 * getToolAnalogInputNum(self: pyaubo_sdk.IoControl) -> int
555 *
556 * @par Lua function prototype
557 * getToolAnalogInputNum() -> number
558 *
559 * @par Lua example
560 * num = getToolAnalogInputNum()
561 *
562 * @par JSON-RPC request example
563 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInputNum","params":[],"id":1}
564 *
565 * @par JSON-RPC response example
566 * {"id":1,"jsonrpc":"2.0","result":2}
567 *
568 * \endenglish
569 */
571
572 /**
573 * \chinese
574 * 获取标准模拟输出数量
575 *
576 * @return 标准模拟输出数量
577 *
578 * @throws arcs::common_interface::AuboException
579 *
580 * @par Python函数原型
581 * getStandardAnalogOutputNum(self: pyaubo_sdk.IoControl) -> int
582 *
583 * @par Lua函数原型
584 * getStandardAnalogOutputNum() -> number
585 *
586 * @par Lua示例
587 * num = getStandardAnalogOutputNum()
588 *
589 * @par JSON-RPC请求示例
590 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputNum","params":[],"id":1}
591 *
592 * @par JSON-RPC响应示例
593 * {"id":1,"jsonrpc":"2.0","result":2}
594 *
595 * \endchinese
596 * \english
597 * Get the number of standard analog outputs.
598 *
599 * @return Number of standard analog outputs.
600 *
601 * @throws arcs::common_interface::AuboException
602 *
603 * @par Python function prototype
604 * getStandardAnalogOutputNum(self: pyaubo_sdk.IoControl) -> int
605 *
606 * @par Lua function prototype
607 * getStandardAnalogOutputNum() -> number
608 *
609 * @par Lua example
610 * num = getStandardAnalogOutputNum()
611 *
612 * @par JSON-RPC request example
613 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputNum","params":[],"id":1}
614 *
615 * @par JSON-RPC response example
616 * {"id":1,"jsonrpc":"2.0","result":2}
617 *
618 * \endenglish
619 */
621
622 /**
623 * \chinese
624 * 获取工具端模拟输出数量
625 *
626 * @return 工具端模拟输出数量
627 *
628 * @throws arcs::common_interface::AuboException
629 *
630 * @par Python函数原型
631 * getToolAnalogOutputNum(self: pyaubo_sdk.IoControl) -> int
632 *
633 * @par Lua函数原型
634 * getToolAnalogOutputNum() -> number
635 *
636 * @par Lua示例
637 * num = getToolAnalogOutputNum()
638 *
639 * @par JSON-RPC请求示例
640 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputNum","params":[],"id":1}
641 *
642 * @par JSON-RPC响应示例
643 * {"id":1,"jsonrpc":"2.0","result":0}
644 *
645 * \endchinese
646 * \english
647 * Get the number of tool analog outputs.
648 *
649 * @return Number of tool analog outputs.
650 *
651 * @throws arcs::common_interface::AuboException
652 *
653 * @par Python function prototype
654 * getToolAnalogOutputNum(self: pyaubo_sdk.IoControl) -> int
655 *
656 * @par Lua function prototype
657 * getToolAnalogOutputNum() -> number
658 *
659 * @par Lua example
660 * num = getToolAnalogOutputNum()
661 *
662 * @par JSON-RPC request example
663 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputNum","params":[],"id":1}
664 *
665 * @par JSON-RPC response example
666 * {"id":1,"jsonrpc":"2.0","result":0}
667 *
668 * \endenglish
669 */
671
672 /**
673 * \chinese
674 * 设置所有数字输入动作为无触发
675 *
676 * @note
677 * 当输入动作为无触发时,用户设置数字输入值为高电平,不会触发机器人发生动作
678 *
679 * @return 成功返回0;失败返回错误码
680 * AUBO_BUSY
681 * AUBO_BAD_STATE
682 * -AUBO_BAD_STATE
683 *
684 * @throws arcs::common_interface::AuboException
685 *
686 * @par Python函数原型
687 * setDigitalInputActionDefault(self: pyaubo_sdk.IoControl) -> int
688 *
689 * @par Lua函数原型
690 * setDigitalInputActionDefault() -> nil
691 *
692 * @par Lua示例
693 * setDigitalInputActionDefault()
694 *
695 * @par JSON-RPC请求示例
696 * {"jsonrpc":"2.0","method":"rob1.IoControl.setDigitalInputActionDefault","params":[],"id":1}
697 *
698 * @par JSON-RPC响应示例
699 * {"id":1,"jsonrpc":"2.0","result":0}
700 *
701 * \endchinese
702 * \english
703 * Set all digital input actions to no trigger.
704 *
705 * @note
706 * When the input action is set to no trigger, setting the digital input value to high will not trigger any robot action.
707 *
708 * @return Returns 0 on success; error code on failure.
709 * AUBO_BUSY
710 * AUBO_BAD_STATE
711 * -AUBO_BAD_STATE
712 *
713 * @throws arcs::common_interface::AuboException
714 *
715 * @par Python function prototype
716 * setDigitalInputActionDefault(self: pyaubo_sdk.IoControl) -> int
717 *
718 * @par Lua function prototype
719 * setDigitalInputActionDefault() -> nil
720 *
721 * @par Lua example
722 * setDigitalInputActionDefault()
723 *
724 * @par JSON-RPC request example
725 * {"jsonrpc":"2.0","method":"rob1.IoControl.setDigitalInputActionDefault","params":[],"id":1}
726 *
727 * @par JSON-RPC response example
728 * {"id":1,"jsonrpc":"2.0","result":0}
729 *
730 * \endenglish
731 */
733
734 /**
735 * \chinese
736 * 设置标准数字输入触发动作
737 *
738 * @note
739 * 当给输入设置为无触发动作(StandardInputAction::Default)时,
740 * 用户设置数字输入值为高电平,不会触发机器人发生动作。\n
741 * 当给输入设置触发动作时,用户设置数字输入值为高电平,会触发机器人执行相应的动作。\n
742 * 例如,当设置DI0的触发动作为拖动示教(StandardInputAction::Handguide)时,
743 * 用户设置DI0为高电平,机器人会进入拖动示教。
744 * 设置DI0为低电平,机器人会退出拖动示教。
745 *
746 * @param index: 表示IO口的管脚,管脚编号从0开始。
747 * 例如,0表示第一个管脚。
748 * @param action: 触发动作
749 *
750 * @return 成功返回0;失败返回错误码
751 * AUBO_REQUEST_IGNORE
752 * AUBO_BUSY
753 * AUBO_BAD_STATE
754 * -AUBO_INVL_ARGUMENT
755 * -AUBO_BAD_STATE
756 *
757 * @throws arcs::common_interface::AuboException
758 *
759 * @par Python函数原型
760 * setStandardDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int,
761 * arg1: arcs::common_interface::StandardInputAction) -> int
762 *
763 * @par Lua函数原型
764 * setStandardDigitalInputAction(index: number, action: number) -> nil
765 *
766 * @par Lua示例
767 * setStandardDigitalInputAction(0,1)
768 *
769 * @par JSON-RPC请求示例
770 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalInputAction","params":[0,"Handguide"],"id":1}
771 *
772 * @par JSON-RPC响应示例
773 * {"id":1,"jsonrpc":"2.0","result":0}
774 *
775 * \endchinese
776 * \english
777 * Set the trigger action for standard digital input.
778 *
779 * @note
780 * When the input is set to no trigger action (StandardInputAction::Default),
781 * setting the digital input value to high will not trigger any robot action.\n
782 * When a trigger action is set, setting the digital input value to high will trigger the corresponding robot action.\n
783 * For example, if DI0 is set to trigger Handguide (StandardInputAction::Handguide),
784 * setting DI0 to high will enable hand-guiding mode.
785 * Setting DI0 to low will exit hand-guiding mode.
786 *
787 * @param index: Indicates the IO pin, starting from 0.
788 * For example, 0 means the first pin.
789 * @param action: Trigger action
790 *
791 * @return Returns 0 on success; error code on failure.
792 * AUBO_REQUEST_IGNORE
793 * AUBO_BUSY
794 * AUBO_BAD_STATE
795 * -AUBO_INVL_ARGUMENT
796 * -AUBO_BAD_STATE
797 *
798 * @throws arcs::common_interface::AuboException
799 *
800 * @par Python function prototype
801 * setStandardDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int,
802 * arg1: arcs::common_interface::StandardInputAction) -> int
803 *
804 * @par Lua function prototype
805 * setStandardDigitalInputAction(index: number, action: number) -> nil
806 *
807 * @par Lua example
808 * setStandardDigitalInputAction(0,1)
809 *
810 * @par JSON-RPC request example
811 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalInputAction","params":[0,"Handguide"],"id":1}
812 *
813 * @par JSON-RPC response example
814 * {"id":1,"jsonrpc":"2.0","result":0}
815 *
816 * \endenglish
817 */
819
820 /**
821 * \chinese
822 * 设置工具数字输入触发动作
823 *
824 * @note
825 * 当给输入设置为无触发动作(StandardInputAction::Default)时,
826 * 用户设置工具数字输入值为高电平,不会触发机器人发生动作。\n
827 * 当给输入设置触发动作时,用户设置工具数字输入值为高电平,会触发机器人执行相应的动作。\n
828 * 例如,当设置TOOL_IO[0]的类型为输入而且触发动作为拖动示教(StandardInputAction::Handguide)时,
829 * 用户设置TOOL_IO[0]为高电平,机器人会进入拖动示教。
830 * 设置TOOL_IO[0]为低电平,机器人会退出拖动示教。
831 *
832 * @param index: 表示IO口的管脚,管脚编号从0开始。
833 * 例如,0表示第一个管脚。
834 * @param action: 触发动作
835 *
836 * @return 成功返回0;失败返回错误码
837 * AUBO_REQUEST_IGNORE
838 * AUBO_BUSY
839 * AUBO_BAD_STATE
840 * -AUBO_INVL_ARGUMENT
841 * -AUBO_BAD_STATE
842 *
843 * @throws arcs::common_interface::AuboException
844 *
845 * @par Python函数原型
846 * setToolDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int, arg1:
847 * arcs::common_interface::StandardInputAction) -> int
848 *
849 * @par Lua函数原型
850 * setToolDigitalInputAction(index: number, action: number) -> nil
851 *
852 * @par Lua示例
853 * setToolDigitalInputAction(0,1)
854 *
855 * @par JSON-RPC请求示例
856 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalInputAction","params":[0,"Handguide"],"id":1}
857 *
858 * @par JSON-RPC响应示例
859 * {"id":1,"jsonrpc":"2.0","result":0}
860 *
861 * \endchinese
862 * \english
863 * Set the trigger action for tool digital input.
864 *
865 * @note
866 * When the input is set to no trigger action (StandardInputAction::Default),
867 * setting the tool digital input value to high will not trigger any robot action.\n
868 * When a trigger action is set, setting the tool digital input value to high will trigger the corresponding robot action.\n
869 * For example, if TOOL_IO[0] is set as input and its trigger action is Handguide (StandardInputAction::Handguide),
870 * setting TOOL_IO[0] to high will enable hand-guiding mode.
871 * Setting TOOL_IO[0] to low will exit hand-guiding mode.
872 *
873 * @param index: Indicates the IO pin, starting from 0.
874 * For example, 0 means the first pin.
875 * @param action: Trigger action
876 *
877 * @return Returns 0 on success; error code on failure.
878 * AUBO_REQUEST_IGNORE
879 * AUBO_BUSY
880 * AUBO_BAD_STATE
881 * -AUBO_INVL_ARGUMENT
882 * -AUBO_BAD_STATE
883 *
884 * @throws arcs::common_interface::AuboException
885 *
886 * @par Python function prototype
887 * setToolDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int, arg1:
888 * arcs::common_interface::StandardInputAction) -> int
889 *
890 * @par Lua function prototype
891 * setToolDigitalInputAction(index: number, action: number) -> nil
892 *
893 * @par Lua example
894 * setToolDigitalInputAction(0,1)
895 *
896 * @par JSON-RPC request example
897 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalInputAction","params":[0,"Handguide"],"id":1}
898 *
899 * @par JSON-RPC response example
900 * {"id":1,"jsonrpc":"2.0","result":0}
901 *
902 * \endenglish
903 */
905
906 /**
907 * \chinese
908 * 设置可配置数字输入触发动作
909 *
910 * @param index: 表示IO口的管脚,管脚编号从0开始。
911 * 例如,0表示第一个管脚。
912 * @param action: 触发动作
913 *
914 * @return 成功返回0;失败返回错误码
915 * AUBO_REQUEST_IGNORE
916 * AUBO_BUSY
917 * AUBO_BAD_STATE
918 * -AUBO_INVL_ARGUMENT
919 * -AUBO_BAD_STATE
920 *
921 * @throws arcs::common_interface::AuboException
922 *
923 * @note 需要将可配置输入的安全输入动作设置为
924 * SafetyInputAction::Unassigned时这个函数的配置才会生效
925 *
926 * @par Python函数原型
927 * setConfigurableDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int,
928 * arg1: arcs::common_interface::StandardInputAction) -> int
929 *
930 * @par Lua函数原型
931 * setConfigurableDigitalInputAction(index: number, action: number) -> nil
932 *
933 * @par Lua示例
934 * setConfigurableDigitalInputAction(0,1)
935 *
936 * @par JSON-RPC请求示例
937 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalInputAction","params":[0,"Handguide"],"id":1}
938 *
939 * @par JSON-RPC响应示例
940 * {"id":1,"jsonrpc":"2.0","result":0}
941 *
942 * \endchinese
943 * \english
944 * Set the trigger action for configurable digital input.
945 *
946 * @param index: Indicates the IO pin, starting from 0.
947 * For example, 0 means the first pin.
948 * @param action: Trigger action
949 *
950 * @return Returns 0 on success; error code on failure.
951 * AUBO_REQUEST_IGNORE
952 * AUBO_BUSY
953 * AUBO_BAD_STATE
954 * -AUBO_INVL_ARGUMENT
955 * -AUBO_BAD_STATE
956 *
957 * @throws arcs::common_interface::AuboException
958 *
959 * @note This function takes effect only when the safety input action of the configurable input is set to SafetyInputAction::Unassigned.
960 *
961 * @par Python function prototype
962 * setConfigurableDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int,
963 * arg1: arcs::common_interface::StandardInputAction) -> int
964 *
965 * @par Lua function prototype
966 * setConfigurableDigitalInputAction(index: number, action: number) -> nil
967 *
968 * @par Lua example
969 * setConfigurableDigitalInputAction(0,1)
970 *
971 * @par JSON-RPC request example
972 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalInputAction","params":[0,"Handguide"],"id":1}
973 *
974 * @par JSON-RPC response example
975 * {"id":1,"jsonrpc":"2.0","result":0}
976 *
977 * \endenglish
978 */
980 StandardInputAction action);
981
982 /**
983 * \chinese
984 * 获取标准数字输入触发动作
985 *
986 * @param index: 表示IO口的管脚,管脚编号从0开始。
987 * 例如,0表示第一个管脚。
988 * @return 标准数字输入触发动作
989 *
990 * @par Python函数原型
991 * getStandardDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int) ->
992 * arcs::common_interface::StandardInputAction
993 *
994 * @par Lua函数原型
995 * getStandardDigitalInputAction(index: number) -> number
996 *
997 * @par Lua示例
998 * num = getStandardDigitalInputAction(0)
999 *
1000 * @par JSON-RPC请求示例
1001 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputAction","params":[0],"id":1}
1002 *
1003 * @par JSON-RPC响应示例
1004 * {"id":1,"jsonrpc":"2.0","result":"Default"}
1005 *
1006 * \endchinese
1007 * \english
1008 * Get the trigger action for standard digital input.
1009 *
1010 * @param index: Indicates the IO pin, starting from 0.
1011 * For example, 0 means the first pin.
1012 * @return Standard digital input trigger action
1013 *
1014 * @par Python function prototype
1015 * getStandardDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int) ->
1016 * arcs::common_interface::StandardInputAction
1017 *
1018 * @par Lua function prototype
1019 * getStandardDigitalInputAction(index: number) -> number
1020 *
1021 * @par Lua example
1022 * num = getStandardDigitalInputAction(0)
1023 *
1024 * @par JSON-RPC request example
1025 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputAction","params":[0],"id":1}
1026 *
1027 * @par JSON-RPC response example
1028 * {"id":1,"jsonrpc":"2.0","result":"Default"}
1029 *
1030 * \endenglish
1031 */
1033
1034 /**
1035 * \chinese
1036 * 获取工具端数字输入触发动作
1037 *
1038 * @param index: 表示IO口的管脚,管脚编号从0开始。
1039 * 例如,0表示第一个管脚。
1040 * @return 工具端数字输入触发动作
1041 *
1042 * @par Python函数原型
1043 * getToolDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int) ->
1044 * arcs::common_interface::StandardInputAction
1045 *
1046 * @par Lua函数原型
1047 * getToolDigitalInputAction(index: number) -> number
1048 *
1049 * @par Lua示例
1050 * getToolDigitalInputAction(0)
1051 *
1052 * @par JSON-RPC请求示例
1053 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputAction","params":[0],"id":1}
1054 *
1055 * @par JSON-RPC响应示例
1056 * {"id":1,"jsonrpc":"2.0","result":"Default"}
1057 *
1058 * \endchinese
1059 * \english
1060 * Get the trigger action for tool digital input.
1061 *
1062 * @param index: Indicates the IO pin, starting from 0.
1063 * For example, 0 means the first pin.
1064 * @return Tool digital input trigger action
1065 *
1066 * @par Python function prototype
1067 * getToolDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int) ->
1068 * arcs::common_interface::StandardInputAction
1069 *
1070 * @par Lua function prototype
1071 * getToolDigitalInputAction(index: number) -> number
1072 *
1073 * @par Lua example
1074 * getToolDigitalInputAction(0)
1075 *
1076 * @par JSON-RPC request example
1077 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputAction","params":[0],"id":1}
1078 *
1079 * @par JSON-RPC response example
1080 * {"id":1,"jsonrpc":"2.0","result":"Default"}
1081 *
1082 * \endenglish
1083 */
1085
1086 /**
1087 * \chinese
1088 * 获取可配置数字输入的输入触发动作
1089 *
1090 * @param index: 表示IO口的管脚,管脚编号从0开始。
1091 * 例如,0表示第一个管脚。
1092 * @return 返回输入触发动作
1093 *
1094 * @par Python函数原型
1095 * getConfigurableDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int)
1096 * -> arcs::common_interface::StandardInputAction
1097 *
1098 * @par Lua函数原型
1099 * getConfigurableDigitalInputAction(index: number) -> number
1100 *
1101 * @par Lua示例
1102 * num = getConfigurableDigitalInputAction(0)
1103 *
1104 * @par JSON-RPC请求示例
1105 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputAction","params":[0],"id":1}
1106 *
1107 * @par JSON-RPC响应示例
1108 * {"id":1,"jsonrpc":"2.0","result":"Default"}
1109 *
1110 * \endchinese
1111 * \english
1112 * Get the trigger action for configurable digital input.
1113 *
1114 * @param index: Indicates the IO pin, starting from 0.
1115 * For example, 0 means the first pin.
1116 * @return Returns the input trigger action.
1117 *
1118 * @par Python function prototype
1119 * getConfigurableDigitalInputAction(self: pyaubo_sdk.IoControl, arg0: int)
1120 * -> arcs::common_interface::StandardInputAction
1121 *
1122 * @par Lua function prototype
1123 * getConfigurableDigitalInputAction(index: number) -> number
1124 *
1125 * @par Lua example
1126 * num = getConfigurableDigitalInputAction(0)
1127 *
1128 * @par JSON-RPC request example
1129 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputAction","params":[0],"id":1}
1130 *
1131 * @par JSON-RPC response example
1132 * {"id":1,"jsonrpc":"2.0","result":"Default"}
1133 *
1134 * \endenglish
1135 */
1137
1138 /**
1139 * \chinese
1140 * 设置所有数字输出状态选择为无
1141 *
1142 * @note
1143 * 当给输出状态设置为无(StandardOutputRunState::None)时,
1144 * 用户可以设置数字输出值。\n
1145 * 当给输出设置状态时,用户不可设置数字输出值,控制器会自动设置数字输出值。\n
1146 * 例如,当设置DO0的输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时,
1147 * 机器人进入拖动示教,DO0会自动变为高电平。
1148 * 机器人退出拖动示教,DO0会自动变为低电平。
1149 *
1150 * @return 成功返回0;失败返回错误码
1151 * AUBO_BUSY
1152 * AUBO_BAD_STATE
1153 * -AUBO_BAD_STATE
1154 *
1155 * @throws arcs::common_interface::AuboException
1156 *
1157 * @par Python函数原型
1158 * setDigitalOutputRunstateDefault(self: pyaubo_sdk.IoControl) -> int
1159 *
1160 * @par Lua函数原型
1161 * setDigitalOutputRunstateDefault() -> nil
1162 *
1163 * @par Lua示例
1164 * setDigitalOutputRunstateDefault()
1165 *
1166 * @par JSON-RPC请求示例
1167 * {"jsonrpc":"2.0","method":"rob1.IoControl.setDigitalOutputRunstateDefault","params":[],"id":1}
1168 *
1169 * @par JSON-RPC响应示例
1170 * {"id":1,"jsonrpc":"2.0","result":0}
1171 *
1172 * \endchinese
1173 * \english
1174 * Set all digital output runstates to None.
1175 *
1176 * @note
1177 * When the output runstate is set to None (StandardOutputRunState::None),
1178 * users can set the digital output value.\n
1179 * When the output runstate is set, users cannot set the digital output value, and the controller will set it automatically.\n
1180 * For example, when DO0's output runstate is set to indicate hand-guiding (StandardOutputRunState::Handguiding),
1181 * the robot enters hand-guiding mode and DO0 will automatically become high.
1182 * When the robot exits hand-guiding, DO0 will automatically become low.
1183 *
1184 * @return Returns 0 on success; error code on failure.
1185 * AUBO_BUSY
1186 * AUBO_BAD_STATE
1187 * -AUBO_BAD_STATE
1188 *
1189 * @throws arcs::common_interface::AuboException
1190 *
1191 * @par Python function prototype
1192 * setDigitalOutputRunstateDefault(self: pyaubo_sdk.IoControl) -> int
1193 *
1194 * @par Lua function prototype
1195 * setDigitalOutputRunstateDefault() -> nil
1196 *
1197 * @par Lua example
1198 * setDigitalOutputRunstateDefault()
1199 *
1200 * @par JSON-RPC request example
1201 * {"jsonrpc":"2.0","method":"rob1.IoControl.setDigitalOutputRunstateDefault","params":[],"id":1}
1202 *
1203 * @par JSON-RPC response example
1204 * {"id":1,"jsonrpc":"2.0","result":0}
1205 *
1206 * \endenglish
1207 */
1209
1210 /**
1211 * \chinese
1212 * 设置标准数字输出状态选择
1213 *
1214 * @note
1215 * 当给输出状态设置为无(StandardOutputRunState::None)时,
1216 * 用户可以设置数字输出值。\n
1217 * 当给输出设置状态时,用户不可设置数字输出值,控制器会自动设置数字输出值。\n
1218 * 例如,当设置DO0的输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时,
1219 * 机器人进入拖动示教,DO0会自动变为高电平。
1220 * 机器人退出拖动示教,DO0会自动变为低电平。
1221 *
1222 * @param index: 表示IO口的管脚,管脚编号从0开始。
1223 * 例如,0表示第一个管脚。
1224 * @param runstate: 输出状态选择
1225 *
1226 * @return 成功返回0;失败返回错误码
1227 * AUBO_REQUEST_IGNORE
1228 * AUBO_BUSY
1229 * AUBO_BAD_STATE
1230 * -AUBO_INVL_ARGUMENT
1231 * -AUBO_BAD_STATE
1232 *
1233 * @throws arcs::common_interface::AuboException
1234 *
1235 * @par Python函数原型
1236 * setStandardDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int,
1237 * arg1: arcs::common_interface::StandardOutputRunState) -> int
1238 *
1239 * @par Lua函数原型
1240 * setStandardDigitalOutputRunstate(index: number, runstate: number) -> nil
1241 *
1242 * @par Lua示例
1243 * setStandardDigitalOutputRunstate(0,1)
1244 *
1245 * @par JSON-RPC请求示例
1246 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutputRunstate","params":[0,"PowerOn"],"id":1}
1247 *
1248 * @par JSON-RPC响应示例
1249 * {"id":1,"jsonrpc":"2.0","result":0}
1250 *
1251 * \endchinese
1252 * \english
1253 * Set the runstate for standard digital output.
1254 *
1255 * @note
1256 * When the output runstate is set to None (StandardOutputRunState::None),
1257 * users can set the digital output value.\n
1258 * When the output runstate is set, users cannot set the digital output value, and the controller will set it automatically.\n
1259 * For example, when DO0's output runstate is set to indicate hand-guiding (StandardOutputRunState::Handguiding),
1260 * the robot enters hand-guiding mode and DO0 will automatically become high.
1261 * When the robot exits hand-guiding, DO0 will automatically become low.
1262 *
1263 * @param index: Indicates the IO pin, starting from 0.
1264 * For example, 0 means the first pin.
1265 * @param runstate: Output runstate selection
1266 *
1267 * @return Returns 0 on success; error code on failure.
1268 * AUBO_REQUEST_IGNORE
1269 * AUBO_BUSY
1270 * AUBO_BAD_STATE
1271 * -AUBO_INVL_ARGUMENT
1272 * -AUBO_BAD_STATE
1273 *
1274 * @throws arcs::common_interface::AuboException
1275 *
1276 * @par Python function prototype
1277 * setStandardDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int,
1278 * arg1: arcs::common_interface::StandardOutputRunState) -> int
1279 *
1280 * @par Lua function prototype
1281 * setStandardDigitalOutputRunstate(index: number, runstate: number) -> nil
1282 *
1283 * @par Lua example
1284 * setStandardDigitalOutputRunstate(0,1)
1285 *
1286 * @par JSON-RPC request example
1287 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutputRunstate","params":[0,"PowerOn"],"id":1}
1288 *
1289 * @par JSON-RPC response example
1290 * {"id":1,"jsonrpc":"2.0","result":0}
1291 *
1292 * \endenglish
1293 */
1295 StandardOutputRunState runstate);
1296
1297 /**
1298 * \chinese
1299 * 设置工具端数字输出状态选择
1300 *
1301 * @note
1302 * 当给输出状态设置为无(StandardOutputRunState::None)时,
1303 * 用户可以设置数字输出值。\n
1304 * 当给输出设置状态时,用户不可设置数字输出值,控制器会自动设置数字输出值。\n
1305 * 例如,当设置TOOL_IO[0]类型为输出且输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时,
1306 * 机器人进入拖动示教,TOOL_IO[0]会自动变为高电平。
1307 * 机器人退出拖动示教,TOOL_IO[0]会自动变为低电平。
1308 *
1309 * @param index: 表示IO口的管脚,管脚编号从0开始。
1310 * 例如,0表示第一个管脚。
1311 * @param runstate: 输出状态选择
1312 *
1313 * @return 成功返回0;失败返回错误码
1314 * AUBO_REQUEST_IGNORE
1315 * AUBO_BUSY
1316 * AUBO_BAD_STATE
1317 * -AUBO_INVL_ARGUMENT
1318 * -AUBO_BAD_STATE
1319 *
1320 * @throws arcs::common_interface::AuboException
1321 *
1322 * @par Python函数原型
1323 * setToolDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1324 * arcs::common_interface::StandardOutputRunState) -> int
1325 *
1326 * @par Lua函数原型
1327 * setToolDigitalOutputRunstate(index: number, runstate: number) -> nil
1328 *
1329 * @par Lua示例
1330 * setToolDigitalOutputRunstate(0,1)
1331 *
1332 * @par JSON-RPC请求示例
1333 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutputRunstate","params":[0,"None"],"id":1}
1334 *
1335 * @par JSON-RPC响应示例
1336 * {"id":1,"jsonrpc":"2.0","result":0}
1337 *
1338 * \endchinese
1339 * \english
1340 * Set the runstate for tool digital output.
1341 *
1342 * @note
1343 * When the output runstate is set to None (StandardOutputRunState::None),
1344 * users can set the digital output value.\n
1345 * When the output runstate is set, users cannot set the digital output value, and the controller will set it automatically.\n
1346 * For example, when TOOL_IO[0] is set as output and its runstate is set to indicate hand-guiding (StandardOutputRunState::Handguiding),
1347 * the robot enters hand-guiding mode and TOOL_IO[0] will automatically become high.
1348 * When the robot exits hand-guiding, TOOL_IO[0] will automatically become low.
1349 *
1350 * @param index: Indicates the IO pin, starting from 0.
1351 * For example, 0 means the first pin.
1352 * @param runstate: Output runstate selection
1353 *
1354 * @return Returns 0 on success; error code on failure.
1355 * AUBO_REQUEST_IGNORE
1356 * AUBO_BUSY
1357 * AUBO_BAD_STATE
1358 * -AUBO_INVL_ARGUMENT
1359 * -AUBO_BAD_STATE
1360 *
1361 * @throws arcs::common_interface::AuboException
1362 *
1363 * @par Python function prototype
1364 * setToolDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1365 * arcs::common_interface::StandardOutputRunState) -> int
1366 *
1367 * @par Lua function prototype
1368 * setToolDigitalOutputRunstate(index: number, runstate: number) -> nil
1369 *
1370 * @par Lua example
1371 * setToolDigitalOutputRunstate(0,1)
1372 *
1373 * @par JSON-RPC request example
1374 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutputRunstate","params":[0,"None"],"id":1}
1375 *
1376 * @par JSON-RPC response example
1377 * {"id":1,"jsonrpc":"2.0","result":0}
1378 *
1379 * \endenglish
1380 */
1382 StandardOutputRunState runstate);
1383
1384 /**
1385 * \chinese
1386 * 设置可配置数字输出状态选择
1387 *
1388 * @param index: 表示IO口的管脚,管脚编号从0开始。
1389 * 例如,0表示第一个管脚。
1390 * @param runstate: 输出状态选择
1391 *
1392 * @return 成功返回0;失败返回错误码
1393 * AUBO_REQUEST_IGNORE
1394 * AUBO_BUSY
1395 * AUBO_BAD_STATE
1396 * -AUBO_INVL_ARGUMENT
1397 * -AUBO_BAD_STATE
1398 *
1399 * @throws arcs::common_interface::AuboException
1400 *
1401 * @par Python函数原型
1402 * setConfigurableDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0:
1403 * int, arg1: arcs::common_interface::StandardOutputRunState) -> int
1404 *
1405 * @par Lua函数原型
1406 * setConfigurableDigitalOutputRunstate(index: number, runstate: number) ->
1407 * nil
1408 *
1409 * @par Lua示例
1410 * setConfigurableDigitalOutputRunstate(0,1)
1411 *
1412 * @par JSON-RPC请求示例
1413 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutputRunstate","params":[0,"None"],"id":1}
1414 *
1415 * @par JSON-RPC响应示例
1416 * {"id":1,"jsonrpc":"2.0","result":0}
1417 *
1418 * \endchinese
1419 * \english
1420 * Set the runstate for configurable digital output.
1421 *
1422 * @param index: Indicates the IO pin, starting from 0.
1423 * For example, 0 means the first pin.
1424 * @param runstate: Output runstate selection
1425 *
1426 * @return Returns 0 on success; error code on failure.
1427 * AUBO_REQUEST_IGNORE
1428 * AUBO_BUSY
1429 * AUBO_BAD_STATE
1430 * -AUBO_INVL_ARGUMENT
1431 * -AUBO_BAD_STATE
1432 *
1433 * @throws arcs::common_interface::AuboException
1434 *
1435 * @par Python function prototype
1436 * setConfigurableDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0:
1437 * int, arg1: arcs::common_interface::StandardOutputRunState) -> int
1438 *
1439 * @par Lua function prototype
1440 * setConfigurableDigitalOutputRunstate(index: number, runstate: number) ->
1441 * nil
1442 *
1443 * @par Lua example
1444 * setConfigurableDigitalOutputRunstate(0,1)
1445 *
1446 * @par JSON-RPC request example
1447 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutputRunstate","params":[0,"None"],"id":1}
1448 *
1449 * @par JSON-RPC response example
1450 * {"id":1,"jsonrpc":"2.0","result":0}
1451 *
1452 * \endenglish
1453 */
1455 StandardOutputRunState runstate);
1456
1457 /**
1458 * \chinese
1459 * 获取标准数字输出状态选择
1460 *
1461 * @param index: 表示IO口的管脚,管脚编号从0开始。
1462 * 例如,0表示第一个管脚。
1463 * @return 输出状态选择
1464 *
1465 * @throws arcs::common_interface::AuboException
1466 *
1467 * @par Python函数原型
1468 * getStandardDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int)
1469 * -> arcs::common_interface::StandardOutputRunState
1470 *
1471 * @par Lua函数原型
1472 * getStandardDigitalOutputRunstate(index: number) -> number
1473 *
1474 * @par Lua示例
1475 * num = getStandardDigitalOutputRunstate(0)
1476 *
1477 * @par JSON-RPC请求示例
1478 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputRunstate","params":[0],"id":1}
1479 *
1480 * @par JSON-RPC响应示例
1481 * {"id":1,"jsonrpc":"2.0","result":"None"}
1482 *
1483 * \endchinese
1484 * \english
1485 * Get the runstate for standard digital output.
1486 *
1487 * @param index: Indicates the IO pin, starting from 0.
1488 * For example, 0 means the first pin.
1489 * @return Output runstate selection
1490 *
1491 * @throws arcs::common_interface::AuboException
1492 *
1493 * @par Python function prototype
1494 * getStandardDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int)
1495 * -> arcs::common_interface::StandardOutputRunState
1496 *
1497 * @par Lua function prototype
1498 * getStandardDigitalOutputRunstate(index: number) -> number
1499 *
1500 * @par Lua example
1501 * num = getStandardDigitalOutputRunstate(0)
1502 *
1503 * @par JSON-RPC request example
1504 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputRunstate","params":[0],"id":1}
1505 *
1506 * @par JSON-RPC response example
1507 * {"id":1,"jsonrpc":"2.0","result":"None"}
1508 *
1509 * \endenglish
1510 */
1512
1513 /**
1514 * \chinese
1515 * 获取工具端数字输出状态选择
1516 *
1517 * @param index: 表示IO口的管脚,管脚编号从0开始。
1518 * 例如,0表示第一个管脚。
1519 * @return 输出状态选择
1520 *
1521 * @throws arcs::common_interface::AuboException
1522 *
1523 * @par Python函数原型
1524 * getToolDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
1525 * arcs::common_interface::StandardOutputRunState
1526 *
1527 * @par Lua函数原型
1528 * getToolDigitalOutputRunstate(index: number) -> number
1529 *
1530 * @par Lua示例
1531 * num = getToolDigitalOutputRunstate(0)
1532 *
1533 * @par JSON-RPC请求示例
1534 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputRunstate","params":[0],"id":1}
1535 *
1536 * @par JSON-RPC响应示例
1537 * {"id":1,"jsonrpc":"2.0","result":"None"}
1538 *
1539 * \endchinese
1540 * \english
1541 * Get the runstate for tool digital output.
1542 *
1543 * @param index: Indicates the IO pin, starting from 0.
1544 * For example, 0 means the first pin.
1545 * @return Output runstate selection
1546 *
1547 * @throws arcs::common_interface::AuboException
1548 *
1549 * @par Python function prototype
1550 * getToolDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
1551 * arcs::common_interface::StandardOutputRunState
1552 *
1553 * @par Lua function prototype
1554 * getToolDigitalOutputRunstate(index: number) -> number
1555 *
1556 * @par Lua example
1557 * num = getToolDigitalOutputRunstate(0)
1558 *
1559 * @par JSON-RPC request example
1560 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputRunstate","params":[0],"id":1}
1561 *
1562 * @par JSON-RPC response example
1563 * {"id":1,"jsonrpc":"2.0","result":"None"}
1564 *
1565 * \endenglish
1566 */
1568
1569 /**
1570 * \chinese
1571 * 获取可配置数字输出状态选择
1572 *
1573 * @param index: 表示IO口的管脚,管脚编号从0开始。
1574 * 例如,0表示第一个管脚。
1575 * @return 输出状态选择
1576 *
1577 * @throws arcs::common_interface::AuboException
1578 *
1579 * @par Python函数原型
1580 * getConfigurableDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0:
1581 * int)
1582 * -> arcs::common_interface::StandardOutputRunState
1583 *
1584 * @par Lua函数原型
1585 * getConfigurableDigitalOutputRunstate(index: number) -> number
1586 *
1587 * @par Lua示例
1588 * num = getConfigurableDigitalOutputRunstate(0)
1589 *
1590 * @par JSON-RPC请求示例
1591 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputRunstate","params":[0],"id":1}
1592 *
1593 * @par JSON-RPC响应示例
1594 * {"id":1,"jsonrpc":"2.0","result":"None"}
1595 *
1596 * \endchinese
1597 * \english
1598 * Get the runstate for configurable digital output.
1599 *
1600 * @param index: Indicates the IO pin, starting from 0.
1601 * For example, 0 means the first pin.
1602 * @return Output runstate selection
1603 *
1604 * @throws arcs::common_interface::AuboException
1605 *
1606 * @par Python function prototype
1607 * getConfigurableDigitalOutputRunstate(self: pyaubo_sdk.IoControl, arg0:
1608 * int)
1609 * -> arcs::common_interface::StandardOutputRunState
1610 *
1611 * @par Lua function prototype
1612 * getConfigurableDigitalOutputRunstate(index: number) -> number
1613 *
1614 * @par Lua example
1615 * num = getConfigurableDigitalOutputRunstate(0)
1616 *
1617 * @par JSON-RPC request example
1618 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputRunstate","params":[0],"id":1}
1619 *
1620 * @par JSON-RPC response example
1621 * {"id":1,"jsonrpc":"2.0","result":"None"}
1622 *
1623 * \endenglish
1624 */
1626
1627 /**
1628 * \chinese
1629 * 设置标准模拟输出状态选择
1630 *
1631 * @note
1632 * 当给输出状态设置为无(StandardOutputRunState::None)时,
1633 * 用户可以设置模拟输出值。\n
1634 * 当给输出设置状态时,用户不可设置模拟输出值,控制器会自动设置模拟输出值。\n
1635 * 例如,当设置AO0的输出状态为高电平指示正在拖动示教(StandardOutputRunState::Handguiding)时,
1636 * 机器人进入拖动示教,AO0的值会自动变为最大值。
1637 * 机器人退出拖动示教,AO0的值会自动变为0。
1638 *
1639 * @param index: 表示IO口的管脚,管脚编号从0开始。
1640 * 例如,0表示第一个管脚。
1641 * @param runstate: 输出状态选择
1642 * @return 成功返回0;失败返回错误码
1643 * AUBO_REQUEST_IGNORE
1644 * AUBO_BUSY
1645 * AUBO_BAD_STATE
1646 * -AUBO_INVL_ARGUMENT
1647 * -AUBO_BAD_STATE
1648 *
1649 * @throws arcs::common_interface::AuboException
1650 *
1651 * @par Python函数原型
1652 * setStandardAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int,
1653 * arg1: arcs::common_interface::StandardOutputRunState) -> int
1654 *
1655 * @par Lua函数原型
1656 * setStandardAnalogOutputRunstate(index: number, runstate: number) -> nil
1657 *
1658 * @par Lua示例
1659 * setStandardAnalogOutputRunstate(0,6)
1660 *
1661 * @par JSON-RPC请求示例
1662 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogOutputRunstate","params":[0,"None"],"id":1}
1663 *
1664 * @par JSON-RPC响应示例
1665 * {"id":1,"jsonrpc":"2.0","result":0}
1666 *
1667 * \endchinese
1668 * \english
1669 * Set the runstate for standard analog output.
1670 *
1671 * @note
1672 * When the output runstate is set to None (StandardOutputRunState::None),
1673 * users can set the analog output value.\n
1674 * When the output runstate is set, users cannot set the analog output value, and the controller will set it automatically.\n
1675 * For example, when AO0's output runstate is set to indicate hand-guiding (StandardOutputRunState::Handguiding),
1676 * the robot enters hand-guiding mode and AO0 will automatically become the maximum value.
1677 * When the robot exits hand-guiding, AO0 will automatically become 0.
1678 *
1679 * @param index: Indicates the IO pin, starting from 0.
1680 * For example, 0 means the first pin.
1681 * @param runstate: Output runstate selection
1682 * @return Returns 0 on success; error code on failure.
1683 * AUBO_REQUEST_IGNORE
1684 * AUBO_BUSY
1685 * AUBO_BAD_STATE
1686 * -AUBO_INVL_ARGUMENT
1687 * -AUBO_BAD_STATE
1688 *
1689 * @throws arcs::common_interface::AuboException
1690 *
1691 * @par Python function prototype
1692 * setStandardAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int,
1693 * arg1: arcs::common_interface::StandardOutputRunState) -> int
1694 *
1695 * @par Lua function prototype
1696 * setStandardAnalogOutputRunstate(index: number, runstate: number) -> nil
1697 *
1698 * @par Lua example
1699 * setStandardAnalogOutputRunstate(0,6)
1700 *
1701 * @par JSON-RPC request example
1702 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogOutputRunstate","params":[0,"None"],"id":1}
1703 *
1704 * @par JSON-RPC response example
1705 * {"id":1,"jsonrpc":"2.0","result":0}
1706 *
1707 * \endenglish
1708 */
1710 StandardOutputRunState runstate);
1711
1712 /**
1713 * \chinese
1714 * 设置工具端模拟输出状态选择
1715 *
1716 * @param index: 表示IO口的管脚,管脚编号从0开始。
1717 * 例如,0表示第一个管脚。
1718 * @param runstate: 输出状态选择
1719 * @return 成功返回0;失败返回错误码
1720 * AUBO_REQUEST_IGNORE
1721 * AUBO_BUSY
1722 * AUBO_BAD_STATE
1723 * -AUBO_INVL_ARGUMENT
1724 * -AUBO_BAD_STATE
1725 *
1726 * @throws arcs::common_interface::AuboException
1727 *
1728 * @par Python函数原型
1729 * setToolAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1730 * arcs::common_interface::StandardOutputRunState) -> int
1731 *
1732 * @par Lua函数原型
1733 * setToolAnalogOutputRunstate(index: number, runstate: number) -> nil
1734 *
1735 * @par Lua示例
1736 * setToolAnalogOutputRunstate(0,1)
1737 *
1738 * @par JSON-RPC请求示例
1739 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogOutputRunstate","params":[0,"None"],"id":1}
1740 *
1741 * @par JSON-RPC响应示例
1742 * {"id":1,"jsonrpc":"2.0","result":0}
1743 *
1744 * \endchinese
1745 * \english
1746 * Set the runstate for tool analog output.
1747 *
1748 * @param index: Indicates the IO pin, starting from 0.
1749 * For example, 0 means the first pin.
1750 * @param runstate: Output runstate selection
1751 * @return Returns 0 on success; error code on failure.
1752 * AUBO_REQUEST_IGNORE
1753 * AUBO_BUSY
1754 * AUBO_BAD_STATE
1755 * -AUBO_INVL_ARGUMENT
1756 * -AUBO_BAD_STATE
1757 *
1758 * @throws arcs::common_interface::AuboException
1759 *
1760 * @par Python function prototype
1761 * setToolAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1762 * arcs::common_interface::StandardOutputRunState) -> int
1763 *
1764 * @par Lua function prototype
1765 * setToolAnalogOutputRunstate(index: number, runstate: number) -> nil
1766 *
1767 * @par Lua example
1768 * setToolAnalogOutputRunstate(0,1)
1769 *
1770 * @par JSON-RPC request example
1771 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogOutputRunstate","params":[0,"None"],"id":1}
1772 *
1773 * @par JSON-RPC response example
1774 * {"id":1,"jsonrpc":"2.0","result":0}
1775 *
1776 * \endenglish
1777 */
1779
1780 /**
1781 * \chinese
1782 * 获取标准模拟输出状态选择
1783 *
1784 * @param index: 表示IO口的管脚,管脚编号从0开始。
1785 * 例如,0表示第一个管脚。
1786 * @return 标准模拟输出状态选择
1787 *
1788 * @throws arcs::common_interface::AuboException
1789 *
1790 * @par Python函数原型
1791 * getStandardAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
1792 * arcs::common_interface::StandardOutputRunState
1793 *
1794 * @par Lua函数原型
1795 * getStandardAnalogOutputRunstate(index: number) -> number
1796 *
1797 * @par Lua示例
1798 * num = getStandardAnalogOutputRunstate(0)
1799 *
1800 * @par JSON-RPC请求示例
1801 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputRunstate","params":[0],"id":1}
1802 *
1803 * @par JSON-RPC响应示例
1804 * {"id":1,"jsonrpc":"2.0","result":"None"}
1805 *
1806 * \endchinese
1807 * \english
1808 * Get the runstate for standard analog output.
1809 *
1810 * @param index: Indicates the IO pin, starting from 0.
1811 * For example, 0 means the first pin.
1812 * @return Standard analog output runstate selection
1813 *
1814 * @throws arcs::common_interface::AuboException
1815 *
1816 * @par Python function prototype
1817 * getStandardAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
1818 * arcs::common_interface::StandardOutputRunState
1819 *
1820 * @par Lua function prototype
1821 * getStandardAnalogOutputRunstate(index: number) -> number
1822 *
1823 * @par Lua example
1824 * num = getStandardAnalogOutputRunstate(0)
1825 *
1826 * @par JSON-RPC request example
1827 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputRunstate","params":[0],"id":1}
1828 *
1829 * @par JSON-RPC response example
1830 * {"id":1,"jsonrpc":"2.0","result":"None"}
1831 *
1832 * \endenglish
1833 */
1835
1836 /**
1837 * \chinese
1838 * 获取工具端模拟输出状态选择
1839 *
1840 * @param index: 表示IO口的管脚,管脚编号从0开始。
1841 * 例如,0表示第一个管脚。
1842 * @return 工具端模拟输出状态选择
1843 *
1844 * @throws arcs::common_interface::AuboException
1845 *
1846 * @par Python函数原型
1847 * getToolAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
1848 * arcs::common_interface::StandardOutputRunState
1849 *
1850 * @par Lua函数原型
1851 * getToolAnalogOutputRunstate(index: number) -> number
1852 *
1853 * @par Lua示例
1854 * num = getToolAnalogOutputRunstate(0)
1855 *
1856 * @par JSON-RPC请求示例
1857 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputRunstate","params":[0],"id":1}
1858 *
1859 * @par JSON-RPC响应示例
1860 * {"id":1,"jsonrpc":"2.0","result":"None"}
1861 *
1862 * \endchinese
1863 * \english
1864 * Get the runstate for tool analog output.
1865 *
1866 * @param index: Indicates the IO pin, starting from 0.
1867 * For example, 0 means the first pin.
1868 * @return Tool analog output runstate selection
1869 *
1870 * @throws arcs::common_interface::AuboException
1871 *
1872 * @par Python function prototype
1873 * getToolAnalogOutputRunstate(self: pyaubo_sdk.IoControl, arg0: int) ->
1874 * arcs::common_interface::StandardOutputRunState
1875 *
1876 * @par Lua function prototype
1877 * getToolAnalogOutputRunstate(index: number) -> number
1878 *
1879 * @par Lua example
1880 * num = getToolAnalogOutputRunstate(0)
1881 *
1882 * @par JSON-RPC request example
1883 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputRunstate","params":[0],"id":1}
1884 *
1885 * @par JSON-RPC response example
1886 * {"id":1,"jsonrpc":"2.0","result":"None"}
1887 *
1888 * \endenglish
1889 */
1891
1892 /**
1893 * \chinese
1894 * 设置标准模拟输入的范围
1895 *
1896 * @param index: 表示IO口的管脚,管脚编号从0开始。
1897 * 例如,0表示第一个管脚。
1898 * @param domain: 输入的范围
1899 *
1900 * @return 成功返回0;失败返回错误码
1901 * AUBO_REQUEST_IGNORE
1902 * AUBO_BUSY
1903 * AUBO_BAD_STATE
1904 * -AUBO_INVL_ARGUMENT
1905 * -AUBO_BAD_STATE
1906 *
1907 * @throws arcs::common_interface::AuboException
1908 *
1909 * @par Python函数原型
1910 * setStandardAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1911 * int) -> int
1912 *
1913 * @par Lua函数原型
1914 * setStandardAnalogInputDomain(index: number, domain: number) -> nil
1915 *
1916 * @par Lua示例
1917 * setStandardAnalogInputDomain(0,1)
1918 *
1919 * @par JSON-RPC请求示例
1920 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogInputDomain","params":[0,8],"id":1}
1921 *
1922 * @par JSON-RPC响应示例
1923 * {"id":1,"jsonrpc":"2.0","result":0}
1924 *
1925 * \endchinese
1926 * \english
1927 * Set the range of standard analog input.
1928 *
1929 * @param index: Indicates the IO pin, starting from 0.
1930 * For example, 0 means the first pin.
1931 * @param domain: Input range
1932 *
1933 * @return Returns 0 on success; error code on failure.
1934 * AUBO_REQUEST_IGNORE
1935 * AUBO_BUSY
1936 * AUBO_BAD_STATE
1937 * -AUBO_INVL_ARGUMENT
1938 * -AUBO_BAD_STATE
1939 *
1940 * @throws arcs::common_interface::AuboException
1941 *
1942 * @par Python function prototype
1943 * setStandardAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1944 * int) -> int
1945 *
1946 * @par Lua function prototype
1947 * setStandardAnalogInputDomain(index: number, domain: number) -> nil
1948 *
1949 * @par Lua example
1950 * setStandardAnalogInputDomain(0,1)
1951 *
1952 * @par JSON-RPC request example
1953 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogInputDomain","params":[0,8],"id":1}
1954 *
1955 * @par JSON-RPC response example
1956 * {"id":1,"jsonrpc":"2.0","result":0}
1957 *
1958 * \endenglish
1959 */
1960 int setStandardAnalogInputDomain(int index, int domain);
1961
1962 /**
1963 * \chinese
1964 * 设置工具端模拟输入的范围
1965 *
1966 * @param index: 表示IO口的管脚,管脚编号从0开始。
1967 * 例如,0表示第一个管脚。
1968 * @param domain: 输入的范围
1969 * @return 成功返回0;失败返回错误码
1970 * AUBO_REQUEST_IGNORE
1971 * AUBO_BUSY
1972 * AUBO_BAD_STATE
1973 * -AUBO_INVL_ARGUMENT
1974 * -AUBO_BAD_STATE
1975 *
1976 * @throws arcs::common_interface::AuboException
1977 *
1978 * @par Python函数原型
1979 * setToolAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
1980 * int) -> int
1981 *
1982 * @par Lua函数原型
1983 * setToolAnalogInputDomain(index: number, domain: number) -> nil
1984 *
1985 * @par Lua示例
1986 * setToolAnalogInputDomain(0,1)
1987 *
1988 * @par JSON-RPC请求示例
1989 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogInputDomain","params":[0,8],"id":1}
1990 *
1991 * @par JSON-RPC响应示例
1992 * {"id":1,"jsonrpc":"2.0","result":0}
1993 *
1994 * \endchinese
1995 * \english
1996 * Set the range of tool analog input.
1997 *
1998 * @param index: Indicates the IO pin, starting from 0.
1999 * For example, 0 means the first pin.
2000 * @param domain: Input range
2001 * @return Returns 0 on success; error code on failure.
2002 * AUBO_REQUEST_IGNORE
2003 * AUBO_BUSY
2004 * AUBO_BAD_STATE
2005 * -AUBO_INVL_ARGUMENT
2006 * -AUBO_BAD_STATE
2007 *
2008 * @throws arcs::common_interface::AuboException
2009 *
2010 * @par Python function prototype
2011 * setToolAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2012 * int) -> int
2013 *
2014 * @par Lua function prototype
2015 * setToolAnalogInputDomain(index: number, domain: number) -> nil
2016 *
2017 * @par Lua example
2018 * setToolAnalogInputDomain(0,1)
2019 *
2020 * @par JSON-RPC request example
2021 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogInputDomain","params":[0,8],"id":1}
2022 *
2023 * @par JSON-RPC response example
2024 * {"id":1,"jsonrpc":"2.0","result":0}
2025 *
2026 * \endenglish
2027 */
2028 int setToolAnalogInputDomain(int index, int domain);
2029
2030 /**
2031 * \chinese
2032 * 获取标准模式输入范围
2033 *
2034 * @param index: 表示IO口的管脚,管脚编号从0开始。
2035 * 例如,0表示第一个管脚。
2036 * @return 标准模式输入范围
2037 *
2038 * @throws arcs::common_interface::AuboException
2039 *
2040 * @par Python函数原型
2041 * getStandardAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2042 *
2043 * @par Lua函数原型
2044 * getStandardAnalogInputDomain(index: number) -> number
2045 *
2046 * @par Lua示例
2047 * num = getStandardAnalogInputDomain(0)
2048 *
2049 * @par JSON-RPC请求示例
2050 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInputDomain","params":[0],"id":1}
2051 *
2052 * @par JSON-RPC响应示例
2053 * {"id":1,"jsonrpc":"2.0","result":0}
2054 *
2055 * \endchinese
2056 * \english
2057 * Get the domain of standard analog input.
2058 *
2059 * @param index: Indicates the IO pin, starting from 0.
2060 * For example, 0 means the first pin.
2061 * @return Standard analog input domain
2062 *
2063 * @throws arcs::common_interface::AuboException
2064 *
2065 * @par Python function prototype
2066 * getStandardAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2067 *
2068 * @par Lua function prototype
2069 * getStandardAnalogInputDomain(index: number) -> number
2070 *
2071 * @par Lua example
2072 * num = getStandardAnalogInputDomain(0)
2073 *
2074 * @par JSON-RPC request example
2075 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInputDomain","params":[0],"id":1}
2076 *
2077 * @par JSON-RPC response example
2078 * {"id":1,"jsonrpc":"2.0","result":0}
2079 *
2080 * \endenglish
2081 */
2083
2084 /**
2085 * \chinese
2086 * 获取工具端模式输入范围
2087 *
2088 * @param index: 表示IO口的管脚,管脚编号从0开始。
2089 * 例如,0表示第一个管脚。
2090 * @return 工具端模式输入范围
2091 *
2092 * @throws arcs::common_interface::AuboException
2093 *
2094 * @par Python函数原型
2095 * getToolAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2096 *
2097 * @par Lua函数原型
2098 * getToolAnalogInputDomain(index: number) -> number
2099 *
2100 * @par Lua示例
2101 * num = getToolAnalogInputDomain(0)
2102 *
2103 * @par JSON-RPC请求示例
2104 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInputDomain","params":[0],"id":1}
2105 *
2106 * @par JSON-RPC响应示例
2107 * {"id":1,"jsonrpc":"2.0","result":10}
2108 *
2109 * \endchinese
2110 * \english
2111 * Get the domain of tool analog input.
2112 *
2113 * @param index: Indicates the IO pin, starting from 0.
2114 * For example, 0 means the first pin.
2115 * @return Tool analog input domain
2116 *
2117 * @throws arcs::common_interface::AuboException
2118 *
2119 * @par Python function prototype
2120 * getToolAnalogInputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2121 *
2122 * @par Lua function prototype
2123 * getToolAnalogInputDomain(index: number) -> number
2124 *
2125 * @par Lua example
2126 * num = getToolAnalogInputDomain(0)
2127 *
2128 * @par JSON-RPC request example
2129 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInputDomain","params":[0],"id":1}
2130 *
2131 * @par JSON-RPC response example
2132 * {"id":1,"jsonrpc":"2.0","result":10}
2133 *
2134 * \endenglish
2135 */
2137
2138 /**
2139 * \chinese
2140 * 设置标准模拟输出的范围
2141 *
2142 * @param index: 表示IO口的管脚,管脚编号从0开始。
2143 * 例如,0表示第一个管脚。
2144 * @param domain: 输出的范围
2145 *
2146 * @return 成功返回0;失败返回错误码
2147 * AUBO_REQUEST_IGNORE
2148 * AUBO_BUSY
2149 * AUBO_BAD_STATE
2150 * -AUBO_INVL_ARGUMENT
2151 * -AUBO_BAD_STATE
2152 *
2153 * @throws arcs::common_interface::AuboException
2154 *
2155 * @par Python函数原型
2156 * setStandardAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int,
2157 * arg1: int) -> int
2158 *
2159 * @par Lua函数原型
2160 * setStandardAnalogOutputDomain(index: number, domain: number) -> nil
2161 *
2162 * @par Lua示例
2163 * setStandardAnalogOutputDomain(0,1)
2164 *
2165 * @par JSON-RPC请求示例
2166 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogOutputDomain","params":[0,8],"id":1}
2167 *
2168 * @par JSON-RPC响应示例
2169 * {"id":1,"jsonrpc":"2.0","result":0}
2170 *
2171 * \endchinese
2172 * \english
2173 * Set the range of standard analog output.
2174 *
2175 * @param index: Indicates the IO pin, starting from 0.
2176 * For example, 0 means the first pin.
2177 * @param domain: Output range
2178 *
2179 * @return Returns 0 on success; error code on failure.
2180 * AUBO_REQUEST_IGNORE
2181 * AUBO_BUSY
2182 * AUBO_BAD_STATE
2183 * -AUBO_INVL_ARGUMENT
2184 * -AUBO_BAD_STATE
2185 *
2186 * @throws arcs::common_interface::AuboException
2187 *
2188 * @par Python function prototype
2189 * setStandardAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int,
2190 * arg1: int) -> int
2191 *
2192 * @par Lua function prototype
2193 * setStandardAnalogOutputDomain(index: number, domain: number) -> nil
2194 *
2195 * @par Lua example
2196 * setStandardAnalogOutputDomain(0,1)
2197 *
2198 * @par JSON-RPC request example
2199 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardAnalogOutputDomain","params":[0,8],"id":1}
2200 *
2201 * @par JSON-RPC response example
2202 * {"id":1,"jsonrpc":"2.0","result":0}
2203 *
2204 * \endenglish
2205 */
2206 int setStandardAnalogOutputDomain(int index, int domain);
2207
2208 /**
2209 * \chinese
2210 * 设置工具端模拟输出范围
2211 *
2212 * @param index: 表示IO口的管脚,管脚编号从0开始。
2213 * 例如,0表示第一个管脚。
2214 * @param domain: 输出的范围
2215 *
2216 * @return 成功返回0;失败返回错误码
2217 * AUBO_REQUEST_IGNORE
2218 * AUBO_BUSY
2219 * AUBO_BAD_STATE
2220 * -AUBO_INVL_ARGUMENT
2221 * -AUBO_BAD_STATE
2222 *
2223 * @throws arcs::common_interface::AuboException
2224 *
2225 * @par Python函数原型
2226 * setToolAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2227 * int) -> int
2228 *
2229 * @par Lua函数原型
2230 * setToolAnalogOutputDomain(index: number, domain: number) -> nil
2231 *
2232 * @par Lua示例
2233 * setToolAnalogOutputDomain(0,1)
2234 *
2235 * \endchinese
2236 * \english
2237 * Set the range of tool analog output.
2238 *
2239 * @param index: Indicates the IO pin, starting from 0.
2240 * For example, 0 means the first pin.
2241 * @param domain: Output range
2242 *
2243 * @return Returns 0 on success; error code on failure.
2244 * AUBO_REQUEST_IGNORE
2245 * AUBO_BUSY
2246 * AUBO_BAD_STATE
2247 * -AUBO_INVL_ARGUMENT
2248 * -AUBO_BAD_STATE
2249 *
2250 * @throws arcs::common_interface::AuboException
2251 *
2252 * @par Python function prototype
2253 * setToolAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2254 * int) -> int
2255 *
2256 * @par Lua function prototype
2257 * setToolAnalogOutputDomain(index: number, domain: number) -> nil
2258 *
2259 * @par Lua example
2260 * setToolAnalogOutputDomain(0,1)
2261 *
2262 * \endenglish
2263 */
2264 int setToolAnalogOutputDomain(int index, int domain);
2265
2266 /**
2267 * \chinese
2268 * 获取标准模拟输出范围
2269 *
2270 * @param index: 表示IO口的管脚,管脚编号从0开始。
2271 * 例如,0表示第一个管脚。
2272 * @return 标准模拟输出范围
2273 *
2274 * @throws arcs::common_interface::AuboException
2275 *
2276 * @par Python函数原型
2277 * getStandardAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2278 *
2279 * @par Lua函数原型
2280 * getStandardAnalogOutputDomain(index: number) -> number
2281 *
2282 * @par Lua示例
2283 * num = getStandardAnalogOutputDomain(0)
2284 *
2285 * @par JSON-RPC请求示例
2286 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputDomain","params":[0],"id":1}
2287 *
2288 * @par JSON-RPC响应示例
2289 * {"id":1,"jsonrpc":"2.0","result":0}
2290 *
2291 * \endchinese
2292 * \english
2293 * Get the domain of standard analog output.
2294 *
2295 * @param index: Indicates the IO pin, starting from 0.
2296 * For example, 0 means the first pin.
2297 * @return Standard analog output domain
2298 *
2299 * @throws arcs::common_interface::AuboException
2300 *
2301 * @par Python function prototype
2302 * getStandardAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2303 *
2304 * @par Lua function prototype
2305 * getStandardAnalogOutputDomain(index: number) -> number
2306 *
2307 * @par Lua example
2308 * num = getStandardAnalogOutputDomain(0)
2309 *
2310 * @par JSON-RPC request example
2311 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutputDomain","params":[0],"id":1}
2312 *
2313 * @par JSON-RPC response example
2314 * {"id":1,"jsonrpc":"2.0","result":0}
2315 *
2316 * \endenglish
2317 */
2319
2320 /**
2321 * \chinese
2322 * 获取工具端模拟输出范围
2323 *
2324 * @param index: 表示IO口的管脚,管脚编号从0开始。
2325 * 例如,0表示第一个管脚。
2326 * @return 工具端模拟输出范围
2327 *
2328 * @throws arcs::common_interface::AuboException
2329 *
2330 * @par Python函数原型
2331 * getToolAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2332 *
2333 * @par Lua函数原型
2334 * getToolAnalogOutputDomain(index: number) -> number
2335 *
2336 * @par Lua示例
2337 * num = getToolAnalogOutputDomain(0)
2338 *
2339 * @par JSON-RPC请求示例
2340 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputDomain","params":[0],"id":1}
2341 *
2342 * @par JSON-RPC响应示例
2343 * {"id":1,"jsonrpc":"2.0","result":0}
2344 *
2345 * \endchinese
2346 * \english
2347 * Get the domain of tool analog output.
2348 *
2349 * @param index: Indicates the IO pin, starting from 0.
2350 * For example, 0 means the first pin.
2351 * @return Tool analog output domain
2352 *
2353 * @throws arcs::common_interface::AuboException
2354 *
2355 * @par Python function prototype
2356 * getToolAnalogOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2357 *
2358 * @par Lua function prototype
2359 * getToolAnalogOutputDomain(index: number) -> number
2360 *
2361 * @par Lua example
2362 * num = getToolAnalogOutputDomain(0)
2363 *
2364 * @par JSON-RPC request example
2365 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutputDomain","params":[0],"id":1}
2366 *
2367 * @par JSON-RPC response example
2368 * {"id":1,"jsonrpc":"2.0","result":0}
2369 *
2370 * \endenglish
2371 */
2373
2374 /**
2375 * \chinese
2376 * 设置工具端电源电压值(单位V)
2377 *
2378 * @param domain: 工具端电源电压值,可选三个档位,分别为0、12和24。\n
2379 * 0表示0V, 12表示12V, 24表示24V。
2380 *
2381 * @return 成功返回0; 失败返回错误码
2382 * AUBO_REQUEST_IGNORE
2383 * AUBO_BUSY
2384 * AUBO_BAD_STATE
2385 * -AUBO_INVL_ARGUMENT
2386 * -AUBO_BAD_STATE
2387 *
2388 * @throws arcs::common_interface::AuboException
2389 *
2390 * @par Python函数原型
2391 * setToolVoltageOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2392 *
2393 * @par Lua函数原型
2394 * setToolVoltageOutputDomain(domain: number) -> nil
2395 *
2396 * @par Lua示例
2397 * setToolVoltageOutputDomain(24)
2398 *
2399 * @par JSON-RPC请求示例
2400 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolVoltageOutputDomain","params":[24],"id":1}
2401 *
2402 * @par JSON-RPC响应示例
2403 * {"id":1,"jsonrpc":"2.0","result":0}
2404 *
2405 * \endchinese
2406 * \english
2407 * Set the tool voltage output value (unit: V)
2408 *
2409 * @param domain: Tool voltage output value, can be 0, 12, or 24.\n
2410 * 0 means 0V, 12 means 12V, 24 means 24V.
2411 *
2412 * @return Returns 0 on success; error code on failure.
2413 * AUBO_REQUEST_IGNORE
2414 * AUBO_BUSY
2415 * AUBO_BAD_STATE
2416 * -AUBO_INVL_ARGUMENT
2417 * -AUBO_BAD_STATE
2418 *
2419 * @throws arcs::common_interface::AuboException
2420 *
2421 * @par Python function prototype
2422 * setToolVoltageOutputDomain(self: pyaubo_sdk.IoControl, arg0: int) -> int
2423 *
2424 * @par Lua function prototype
2425 * setToolVoltageOutputDomain(domain: number) -> nil
2426 *
2427 * @par Lua example
2428 * setToolVoltageOutputDomain(24)
2429 *
2430 * @par JSON-RPC request example
2431 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolVoltageOutputDomain","params":[24],"id":1}
2432 *
2433 * @par JSON-RPC response example
2434 * {"id":1,"jsonrpc":"2.0","result":0}
2435 *
2436 * \endenglish
2437 */
2439
2440 /**
2441 * \chinese
2442 * 获取工具端电源电压值(单位V)
2443 *
2444 * @return 工具端电源电压值(单位V)
2445 *
2446 * @throws arcs::common_interface::AuboException
2447 *
2448 * @par Python函数原型
2449 * getToolVoltageOutputDomain(self: pyaubo_sdk.IoControl) -> int
2450 *
2451 * @par Lua函数原型
2452 * getToolVoltageOutputDomain() -> number
2453 *
2454 * @par Lua示例
2455 * num = getToolVoltageOutputDomain()
2456 *
2457 * @par JSON-RPC请求示例
2458 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolVoltageOutputDomain","params":[],"id":1}
2459 *
2460 * @par JSON-RPC响应示例
2461 * {"id":1,"jsonrpc":"2.0","result":0}
2462 *
2463 * \endchinese
2464 * \english
2465 * Get the tool voltage output value (unit: V)
2466 *
2467 * @return Tool voltage output value (unit: V)
2468 *
2469 * @throws arcs::common_interface::AuboException
2470 *
2471 * @par Python function prototype
2472 * getToolVoltageOutputDomain(self: pyaubo_sdk.IoControl) -> int
2473 *
2474 * @par Lua function prototype
2475 * getToolVoltageOutputDomain() -> number
2476 *
2477 * @par Lua example
2478 * num = getToolVoltageOutputDomain()
2479 *
2480 * @par JSON-RPC request example
2481 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolVoltageOutputDomain","params":[],"id":1}
2482 *
2483 * @par JSON-RPC response example
2484 * {"id":1,"jsonrpc":"2.0","result":0}
2485 *
2486 * \endenglish
2487 */
2489
2490 /**
2491 * \chinese
2492 * 设置标准数字输出值
2493 *
2494 * @param index: 表示IO口的管脚,
2495 * @param value: 输出值
2496 * @return 成功返回0;失败返回错误码
2497 * AUBO_REQUEST_IGNORE
2498 * AUBO_BUSY
2499 * AUBO_BAD_STATE
2500 * -AUBO_INVL_ARGUMENT
2501 * -AUBO_BAD_STATE
2502 *
2503 * @throws arcs::common_interface::AuboException
2504 *
2505 * @par Python函数原型
2506 * setStandardDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2507 * bool) -> int
2508 *
2509 * @par Lua函数原型
2510 * setStandardDigitalOutput(index: number, value: boolean) -> nil
2511 *
2512 * @par Lua示例
2513 * setStandardDigitalOutput(0,true)
2514 *
2515 * @par JSON-RPC请求示例
2516 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutput","params":[0,true],"id":1}
2517 *
2518 * @par JSON-RPC响应示例
2519 * {"id":1,"jsonrpc":"2.0","result":0}
2520 *
2521 * \endchinese
2522 * \english
2523 * Set the value of a standard digital output.
2524 *
2525 * @param index: Indicates the IO pin.
2526 * @param value: Output value.
2527 * @return Returns 0 on success; error code on failure.
2528 * AUBO_REQUEST_IGNORE
2529 * AUBO_BUSY
2530 * AUBO_BAD_STATE
2531 * -AUBO_INVL_ARGUMENT
2532 * -AUBO_BAD_STATE
2533 *
2534 * @throws arcs::common_interface::AuboException
2535 *
2536 * @par Python function prototype
2537 * setStandardDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2538 * bool) -> int
2539 *
2540 * @par Lua function prototype
2541 * setStandardDigitalOutput(index: number, value: boolean) -> nil
2542 *
2543 * @par Lua example
2544 * setStandardDigitalOutput(0,true)
2545 *
2546 * @par JSON-RPC request example
2547 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutput","params":[0,true],"id":1}
2548 *
2549 * @par JSON-RPC response example
2550 * {"id":1,"jsonrpc":"2.0","result":0}
2551 *
2552 * \endenglish
2553 */
2554 int setStandardDigitalOutput(int index, bool value);
2555
2556 /**
2557 * \chinese
2558 * 设置数字输出脉冲
2559 *
2560 * @param index
2561 * @param value
2562 * @param duration
2563 *
2564 * @return 成功返回0;失败返回错误码
2565 * AUBO_REQUEST_IGNORE
2566 * AUBO_BUSY
2567 * AUBO_BAD_STATE
2568 * -AUBO_INVL_ARGUMENT
2569 * -AUBO_BAD_STATE
2570 *
2571 * @throws arcs::common_interface::AuboException
2572 *
2573 * @par Python函数原型
2574 * setStandardDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int,
2575 * arg1: bool, arg2: float) -> int
2576 *
2577 * @par Lua函数原型
2578 * setStandardDigitalOutputPulse(index: number, value: boolean, duration:
2579 * number) -> nil
2580 *
2581 * @par Lua示例
2582 * setStandardDigitalOutputPulse(0,true,2.5)
2583 *
2584 * @par JSON-RPC请求示例
2585 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutputPulse","params":[0,true,0.5],"id":1}
2586 *
2587 * @par JSON-RPC响应示例
2588 * {"id":1,"jsonrpc":"2.0","result":0}
2589 *
2590 * \endchinese
2591 * \english
2592 * Set digital output pulse.
2593 *
2594 * @param index
2595 * @param value
2596 * @param duration
2597 *
2598 * @return Returns 0 on success; error code on failure.
2599 * AUBO_REQUEST_IGNORE
2600 * AUBO_BUSY
2601 * AUBO_BAD_STATE
2602 * -AUBO_INVL_ARGUMENT
2603 * -AUBO_BAD_STATE
2604 *
2605 * @throws arcs::common_interface::AuboException
2606 *
2607 * @par Python function prototype
2608 * setStandardDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int,
2609 * arg1: bool, arg2: float) -> int
2610 *
2611 * @par Lua function prototype
2612 * setStandardDigitalOutputPulse(index: number, value: boolean, duration:
2613 * number) -> nil
2614 *
2615 * @par Lua example
2616 * setStandardDigitalOutputPulse(0,true,2.5)
2617 *
2618 * @par JSON-RPC request example
2619 * {"jsonrpc":"2.0","method":"rob1.IoControl.setStandardDigitalOutputPulse","params":[0,true,0.5],"id":1}
2620 *
2621 * @par JSON-RPC response example
2622 * {"id":1,"jsonrpc":"2.0","result":0}
2623 *
2624 * \endenglish
2625 */
2626 int setStandardDigitalOutputPulse(int index, bool value, double duration);
2627
2628 /**
2629 * \chinese
2630 * 设置工具端数字输出值
2631 *
2632 * @param index: 表示IO口的管脚,管脚编号从0开始。
2633 * 例如,0表示第一个管脚。
2634 * @param value: 数字输出值
2635 *
2636 * @return 成功返回0;失败返回错误码
2637 * AUBO_REQUEST_IGNORE
2638 * AUBO_BUSY
2639 * AUBO_BAD_STATE
2640 * -AUBO_INVL_ARGUMENT
2641 * -AUBO_BAD_STATE
2642 *
2643 * @throws arcs::common_interface::AuboException
2644 *
2645 * @par Python函数原型
2646 * setToolDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1: bool)
2647 * -> int
2648 *
2649 * @par Lua函数原型
2650 * setToolDigitalOutput(index: number, value: boolean) -> nil
2651 *
2652 * @par Lua示例
2653 * setToolDigitalOutput(0,true)
2654 *
2655 * @par JSON-RPC请求示例
2656 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutput","params":[0,true],"id":1}
2657 *
2658 * @par JSON-RPC响应示例
2659 * {"id":1,"jsonrpc":"2.0","result":0}
2660 *
2661 * \endchinese
2662 * \english
2663 * Set the value of tool digital output.
2664 *
2665 * @param index: Indicates the IO pin, starting from 0.
2666 * For example, 0 means the first pin.
2667 * @param value: Output value.
2668 *
2669 * @return Returns 0 on success; error code on failure.
2670 * AUBO_REQUEST_IGNORE
2671 * AUBO_BUSY
2672 * AUBO_BAD_STATE
2673 * -AUBO_INVL_ARGUMENT
2674 * -AUBO_BAD_STATE
2675 *
2676 * @throws arcs::common_interface::AuboException
2677 *
2678 * @par Python function prototype
2679 * setToolDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1: bool)
2680 * -> int
2681 *
2682 * @par Lua function prototype
2683 * setToolDigitalOutput(index: number, value: boolean) -> nil
2684 *
2685 * @par Lua example
2686 * setToolDigitalOutput(0,true)
2687 *
2688 * @par JSON-RPC request example
2689 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutput","params":[0,true],"id":1}
2690 *
2691 * @par JSON-RPC response example
2692 * {"id":1,"jsonrpc":"2.0","result":0}
2693 *
2694 * \endenglish
2695 */
2696 int setToolDigitalOutput(int index, bool value);
2697
2698 /**
2699 * \chinese
2700 * 设置工具端数字输出脉冲
2701 *
2702 * @param index
2703 * @param value
2704 * @param duration
2705 *
2706 * @return 成功返回0;失败返回错误码
2707 * AUBO_REQUEST_IGNORE
2708 * AUBO_BUSY
2709 * AUBO_BAD_STATE
2710 * -AUBO_INVL_ARGUMENT
2711 * -AUBO_BAD_STATE
2712 *
2713 * @throws arcs::common_interface::AuboException
2714 *
2715 * @par Python函数原型
2716 * setToolDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2717 * bool, arg2: float) -> int
2718 *
2719 * @par Lua函数原型
2720 * setToolDigitalOutputPulse(index: number, value: boolean, duration:
2721 * number) -> nil
2722 *
2723 * @par Lua示例
2724 * setToolDigitalOutputPulse(0,true,2)
2725 *
2726 * @par JSON-RPC请求示例
2727 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutputPulse","params":[0,true,0.5],"id":1}
2728 *
2729 * @par JSON-RPC响应示例
2730 * {"id":1,"jsonrpc":"2.0","result":0}
2731 *
2732 * \endchinese
2733 * \english
2734 * Set tool digital output pulse.
2735 *
2736 * @param index
2737 * @param value
2738 * @param duration
2739 *
2740 * @return Returns 0 on success; error code on failure.
2741 * AUBO_REQUEST_IGNORE
2742 * AUBO_BUSY
2743 * AUBO_BAD_STATE
2744 * -AUBO_INVL_ARGUMENT
2745 * -AUBO_BAD_STATE
2746 *
2747 * @throws arcs::common_interface::AuboException
2748 *
2749 * @par Python function prototype
2750 * setToolDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2751 * bool, arg2: float) -> int
2752 *
2753 * @par Lua function prototype
2754 * setToolDigitalOutputPulse(index: number, value: boolean, duration:
2755 * number) -> nil
2756 *
2757 * @par Lua example
2758 * setToolDigitalOutputPulse(0,true,2)
2759 *
2760 * @par JSON-RPC request example
2761 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolDigitalOutputPulse","params":[0,true,0.5],"id":1}
2762 *
2763 * @par JSON-RPC response example
2764 * {"id":1,"jsonrpc":"2.0","result":0}
2765 *
2766 * \endenglish
2767 */
2768 int setToolDigitalOutputPulse(int index, bool value, double duration);
2769
2770 /**
2771 * \chinese
2772 * 设置可配置数字输出值
2773 *
2774 * @param index: 表示IO口的管脚,管脚编号从0开始。
2775 * 例如,0表示第一个管脚。
2776 * @param value: 数字输出值
2777 *
2778 * @return 成功返回0;失败返回错误码
2779 * AUBO_REQUEST_IGNORE
2780 * AUBO_BUSY
2781 * AUBO_BAD_STATE
2782 * -AUBO_INVL_ARGUMENT
2783 * -AUBO_BAD_STATE
2784 *
2785 * @throws arcs::common_interface::AuboException
2786 *
2787 * @par Python函数原型
2788 * setConfigurableDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2789 * bool) -> int
2790 *
2791 * @par Lua函数原型
2792 * setConfigurableDigitalOutput(index: number, value: boolean) -> nil
2793 *
2794 * @par Lua示例
2795 * setConfigurableDigitalOutput(0,true)
2796 *
2797 * @par JSON-RPC请求示例
2798 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutput","params":[0,true],"id":1}
2799 *
2800 * @par JSON-RPC响应示例
2801 * {"id":1,"jsonrpc":"2.0","result":0}
2802 *
2803 * \endchinese
2804 * \english
2805 * Set the value of configurable digital output.
2806 *
2807 * @param index: Indicates the IO pin, starting from 0.
2808 * For example, 0 means the first pin.
2809 * @param value: Output value.
2810 *
2811 * @return Returns 0 on success; error code on failure.
2812 * AUBO_REQUEST_IGNORE
2813 * AUBO_BUSY
2814 * AUBO_BAD_STATE
2815 * -AUBO_INVL_ARGUMENT
2816 * -AUBO_BAD_STATE
2817 *
2818 * @throws arcs::common_interface::AuboException
2819 *
2820 * @par Python function prototype
2821 * setConfigurableDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2822 * bool) -> int
2823 *
2824 * @par Lua function prototype
2825 * setConfigurableDigitalOutput(index: number, value: boolean) -> nil
2826 *
2827 * @par Lua example
2828 * setConfigurableDigitalOutput(0,true)
2829 *
2830 * @par JSON-RPC request example
2831 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutput","params":[0,true],"id":1}
2832 *
2833 * @par JSON-RPC response example
2834 * {"id":1,"jsonrpc":"2.0","result":0}
2835 *
2836 * \endenglish
2837 */
2838 int setConfigurableDigitalOutput(int index, bool value);
2839
2840 /**
2841 * \chinese
2842 * 设置可配置数字输出脉冲
2843 *
2844 * @param index
2845 * @param value
2846 * @param duration
2847 *
2848 * @return 成功返回0;失败返回错误码
2849 * AUBO_REQUEST_IGNORE
2850 * AUBO_BUSY
2851 * AUBO_BAD_STATE
2852 * -AUBO_INVL_ARGUMENT
2853 * -AUBO_BAD_STATE
2854 *
2855 * @throws arcs::common_interface::AuboException
2856 *
2857 * @par Python函数原型
2858 * setConfigurableDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int,
2859 * arg1: bool, arg2: float) -> int
2860 *
2861 * @par Lua函数原型
2862 * setConfigurableDigitalOutputPulse(index: number, value: boolean,
2863 * duration: number) -> nil
2864 *
2865 * @par Lua示例
2866 * setConfigurableDigitalOutputPulse(0,true,2.3)
2867 *
2868 * @par JSON-RPC请求示例
2869 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutputPulse","params":[0,true,0.5],"id":1}
2870 *
2871 * @par JSON-RPC响应示例
2872 * {"id":1,"jsonrpc":"2.0","result":0}
2873 *
2874 * \endchinese
2875 * \english
2876 * Set configurable digital output pulse.
2877 *
2878 * @param index
2879 * @param value
2880 * @param duration
2881 *
2882 * @return Returns 0 on success; error code on failure.
2883 * AUBO_REQUEST_IGNORE
2884 * AUBO_BUSY
2885 * AUBO_BAD_STATE
2886 * -AUBO_INVL_ARGUMENT
2887 * -AUBO_BAD_STATE
2888 *
2889 * @throws arcs::common_interface::AuboException
2890 *
2891 * @par Python function prototype
2892 * setConfigurableDigitalOutputPulse(self: pyaubo_sdk.IoControl, arg0: int,
2893 * arg1: bool, arg2: float) -> int
2894 *
2895 * @par Lua function prototype
2896 * setConfigurableDigitalOutputPulse(index: number, value: boolean,
2897 * duration: number) -> nil
2898 *
2899 * @par Lua example
2900 * setConfigurableDigitalOutputPulse(0,true,2.3)
2901 *
2902 * @par JSON-RPC request example
2903 * {"jsonrpc":"2.0","method":"rob1.IoControl.setConfigurableDigitalOutputPulse","params":[0,true,0.5],"id":1}
2904 *
2905 * @par JSON-RPC response example
2906 * {"id":1,"jsonrpc":"2.0","result":0}
2907 *
2908 * \endenglish
2909 */
2910 int setConfigurableDigitalOutputPulse(int index, bool value,
2911 double duration);
2912
2913 /**
2914 * \chinese
2915 * 设置标准模拟输出值
2916 *
2917 * @param index: 表示IO口的管脚,管脚编号从0开始。
2918 * 例如,0表示第一个管脚。
2919 * @param value: 模拟输出值
2920 *
2921 * @return 成功返回0;失败返回错误码
2922 * AUBO_REQUEST_IGNORE
2923 * AUBO_BUSY
2924 * AUBO_BAD_STATE
2925 * -AUBO_INVL_ARGUMENT
2926 * -AUBO_BAD_STATE
2927 *
2928 * @throws arcs::common_interface::AuboException
2929 *
2930 * @par Python函数原型
2931 * setStandardAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2932 * float) -> int
2933 *
2934 * @par Lua函数原型
2935 * setStandardAnalogOutput(index: number, value: number) -> nil
2936 *
2937 * @par Lua示例
2938 * setStandardAnalogOutput(0,5.4)
2939 *
2940 * \endchinese
2941 * \english
2942 * Set the value of standard analog output.
2943 *
2944 * @param index: Indicates the IO pin, starting from 0.
2945 * For example, 0 means the first pin.
2946 * @param value: Output value.
2947 *
2948 * @return Returns 0 on success; error code on failure.
2949 * AUBO_REQUEST_IGNORE
2950 * AUBO_BUSY
2951 * AUBO_BAD_STATE
2952 * -AUBO_INVL_ARGUMENT
2953 * -AUBO_BAD_STATE
2954 *
2955 * @throws arcs::common_interface::AuboException
2956 *
2957 * @par Python function prototype
2958 * setStandardAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1:
2959 * float) -> int
2960 *
2961 * @par Lua function prototype
2962 * setStandardAnalogOutput(index: number, value: number) -> nil
2963 *
2964 * @par Lua example
2965 * setStandardAnalogOutput(0,5.4)
2966 *
2967 * \endenglish
2968 */
2969 int setStandardAnalogOutput(int index, double value);
2970
2971 /**
2972 * \chinese
2973 * 设置工具端模拟输出值
2974 *
2975 * @param index: 表示IO口的管脚,管脚编号从0开始。
2976 * 例如,0表示第一个管脚。
2977 * @param value: 模拟输出
2978 *
2979 * @return 成功返回0;失败返回错误码
2980 * AUBO_REQUEST_IGNORE
2981 * AUBO_BUSY
2982 * AUBO_BAD_STATE
2983 * -AUBO_INVL_ARGUMENT
2984 * -AUBO_BAD_STATE
2985 *
2986 * @throws arcs::common_interface::AuboException
2987 *
2988 * @par Python函数原型
2989 * setToolAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1: float)
2990 * -> int
2991 *
2992 * @par Lua函数原型
2993 * setToolAnalogOutput(index: number, value: number) -> nil
2994 *
2995 * @par Lua示例
2996 * setToolAnalogOutput(0,1.2)
2997 *
2998 * @par JSON-RPC请求示例
2999 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogOutput","params":[0,0.5],"id":1}
3000 *
3001 * @par JSON-RPC响应示例
3002 * {"id":1,"jsonrpc":"2.0","result":13}
3003 *
3004 * \endchinese
3005 * \english
3006 * Set the value of tool analog output.
3007 *
3008 * @param index: Indicates the IO pin, starting from 0.
3009 * For example, 0 means the first pin.
3010 * @param value: Output value.
3011 *
3012 * @return Returns 0 on success; error code on failure.
3013 * AUBO_REQUEST_IGNORE
3014 * AUBO_BUSY
3015 * AUBO_BAD_STATE
3016 * -AUBO_INVL_ARGUMENT
3017 * -AUBO_BAD_STATE
3018 *
3019 * @throws arcs::common_interface::AuboException
3020 *
3021 * @par Python function prototype
3022 * setToolAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int, arg1: float)
3023 * -> int
3024 *
3025 * @par Lua function prototype
3026 * setToolAnalogOutput(index: number, value: number) -> nil
3027 *
3028 * @par Lua example
3029 * setToolAnalogOutput(0,1.2)
3030 *
3031 * @par JSON-RPC request example
3032 * {"jsonrpc":"2.0","method":"rob1.IoControl.setToolAnalogOutput","params":[0,0.5],"id":1}
3033 *
3034 * @par JSON-RPC response example
3035 * {"id":1,"jsonrpc":"2.0","result":13}
3036 *
3037 * \endenglish
3038 */
3039 int setToolAnalogOutput(int index, double value);
3040
3041 /**
3042 * \chinese
3043 * 获取标准数字输入值
3044 *
3045 * @param index: 表示IO口的管脚,管脚编号从0开始。
3046 * 例如,0表示第一个管脚。
3047 *
3048 * @return 高电平返回true; 低电平返回false
3049 *
3050 * @throws arcs::common_interface::AuboException
3051 *
3052 * @par Python函数原型
3053 * getStandardDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3054 *
3055 * @par Lua函数原型
3056 * getStandardDigitalInput(index: number) -> boolean
3057 *
3058 * @par Lua示例
3059 * status = getStandardDigitalInput(0)
3060 *
3061 * @par JSON-RPC请求示例
3062 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInput","params":[0],"id":1}
3063 *
3064 * @par JSON-RPC响应示例
3065 * {"id":1,"jsonrpc":"2.0","result":false}
3066 *
3067 * \endchinese
3068 * \english
3069 * Get the value of a standard digital input.
3070 *
3071 * @param index: Indicates the IO pin, starting from 0.
3072 * For example, 0 means the first pin.
3073 *
3074 * @return Returns true for high level; false for low level.
3075 *
3076 * @throws arcs::common_interface::AuboException
3077 *
3078 * @par Python function prototype
3079 * getStandardDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3080 *
3081 * @par Lua function prototype
3082 * getStandardDigitalInput(index: number) -> boolean
3083 *
3084 * @par Lua example
3085 * status = getStandardDigitalInput(0)
3086 *
3087 * @par JSON-RPC request example
3088 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInput","params":[0],"id":1}
3089 *
3090 * @par JSON-RPC response example
3091 * {"id":1,"jsonrpc":"2.0","result":false}
3092 *
3093 * \endenglish
3094 */
3096
3097 /**
3098 * \chinese
3099 * 获取所有的标准数字输入值
3100 *
3101 * @return 所有的标准数字输入值 \n
3102 * 例如,当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
3103 * 后16位就是所有的标准数字输入状态值,
3104 * 最后一位表示DI00的输入状态值,倒数第二位表示DI01的输入状态值,以此类推。\n
3105 * 1表示高电平状态,0表示低电平状态
3106 *
3107 * @throws arcs::common_interface::AuboException
3108 *
3109 * @par Python函数原型
3110 * getStandardDigitalInputs(self: pyaubo_sdk.IoControl) -> int
3111 *
3112 * @par Lua函数原型
3113 * getStandardDigitalInputs() -> number
3114 *
3115 * @par Lua示例
3116 * num = getStandardDigitalInputs()
3117 *
3118 * @par JSON-RPC请求示例
3119 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputs","params":[],"id":1}
3120 *
3121 * @par JSON-RPC响应示例
3122 * {"id":1,"jsonrpc":"2.0","result":0}
3123 *
3124 * \endchinese
3125 * \english
3126 * Get all standard digital input values.
3127 *
3128 * @return All standard digital input values.\n
3129 * For example, if the return value is 2863267846, its binary representation is 10101010101010100000000000000110.
3130 * The lower 16 bits represent the status of all standard digital inputs,
3131 * the least significant bit indicates the input status of DI00, the second least significant bit indicates DI01, and so on.\n
3132 * 1 means high level, 0 means low level.
3133 *
3134 * @throws arcs::common_interface::AuboException
3135 *
3136 * @par Python function prototype
3137 * getStandardDigitalInputs(self: pyaubo_sdk.IoControl) -> int
3138 *
3139 * @par Lua function prototype
3140 * getStandardDigitalInputs() -> number
3141 *
3142 * @par Lua example
3143 * num = getStandardDigitalInputs()
3144 *
3145 * @par JSON-RPC request example
3146 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalInputs","params":[],"id":1}
3147 *
3148 * @par JSON-RPC response example
3149 * {"id":1,"jsonrpc":"2.0","result":0}
3150 *
3151 * \endenglish
3152 */
3154
3155 /**
3156 * \chinese
3157 * 获取工具端数字输入值
3158 *
3159 * @param index: 表示IO口的管脚,管脚编号从0开始。
3160 * 例如,0表示第一个管脚。
3161 *
3162 * @return 高电平返回true; 低电平返回false
3163 *
3164 * @throws arcs::common_interface::AuboException
3165 *
3166 * @par Python函数原型
3167 * getToolDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3168 *
3169 * @par Lua函数原型
3170 * getToolDigitalInput(index: number) -> boolean
3171 *
3172 * @par Lua示例
3173 * status = getToolDigitalInput(0)
3174 *
3175 * @par JSON-RPC请求示例
3176 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInput","params":[0],"id":1}
3177 *
3178 * @par JSON-RPC响应示例
3179 * {"id":1,"jsonrpc":"2.0","result":false}
3180 *
3181 * \endchinese
3182 * \english
3183 * Get the value of tool digital input.
3184 *
3185 * @param index: Indicates the IO pin, starting from 0.
3186 * For example, 0 means the first pin.
3187 *
3188 * @return Returns true for high level; false for low level.
3189 *
3190 * @throws arcs::common_interface::AuboException
3191 *
3192 * @par Python function prototype
3193 * getToolDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3194 *
3195 * @par Lua function prototype
3196 * getToolDigitalInput(index: number) -> boolean
3197 *
3198 * @par Lua example
3199 * status = getToolDigitalInput(0)
3200 *
3201 * @par JSON-RPC request example
3202 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInput","params":[0],"id":1}
3203 *
3204 * @par JSON-RPC response example
3205 * {"id":1,"jsonrpc":"2.0","result":false}
3206 *
3207 * \endenglish
3208 */
3209 bool getToolDigitalInput(int index);
3210
3211 /**
3212 * \chinese
3213 * 获取所有的工具端数字输入值
3214 *
3215 * @return 返回所有的工具端数字输入值
3216 *
3217 * @throws arcs::common_interface::AuboException
3218 *
3219 * @par Python函数原型
3220 * getToolDigitalInputs(self: pyaubo_sdk.IoControl) -> int
3221 *
3222 * @par Lua函数原型
3223 * getToolDigitalInputs() -> number
3224 *
3225 * @par Lua示例
3226 * num = getToolDigitalInputs()
3227 *
3228 * @par JSON-RPC请求示例
3229 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputs","params":[],"id":1}
3230 *
3231 * @par JSON-RPC响应示例
3232 * {"id":1,"jsonrpc":"2.0","result":0}
3233 *
3234 * \endchinese
3235 * \english
3236 * Get all tool digital input values.
3237 *
3238 * @return Returns all tool digital input values.
3239 *
3240 * @throws arcs::common_interface::AuboException
3241 *
3242 * @par Python function prototype
3243 * getToolDigitalInputs(self: pyaubo_sdk.IoControl) -> int
3244 *
3245 * @par Lua function prototype
3246 * getToolDigitalInputs() -> number
3247 *
3248 * @par Lua example
3249 * num = getToolDigitalInputs()
3250 *
3251 * @par JSON-RPC request example
3252 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalInputs","params":[],"id":1}
3253 *
3254 * @par JSON-RPC response example
3255 * {"id":1,"jsonrpc":"2.0","result":0}
3256 *
3257 * \endenglish
3258 */
3260
3261 /**
3262 * \chinese
3263 * 获取可配置数字输入值
3264 *
3265 * @note 可用于获取安全IO的输入值
3266 *
3267 * @param index: 表示IO口的管脚,管脚编号从0开始。
3268 * 例如,0表示第一个管脚。
3269 *
3270 * @return 高电平返回true; 低电平返回false
3271 *
3272 * @throws arcs::common_interface::AuboException
3273 *
3274 * @par Python函数原型
3275 * getConfigurableDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3276 *
3277 * @par Lua函数原型
3278 * getConfigurableDigitalInput(index: number) -> boolean
3279 *
3280 * @par Lua示例
3281 * status = getConfigurableDigitalInput(0)
3282 *
3283 * @par JSON-RPC请求示例
3284 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInput","params":[0],"id":1}
3285 *
3286 * @par JSON-RPC响应示例
3287 * {"id":1,"jsonrpc":"2.0","result":false}
3288 *
3289 * \endchinese
3290 * \english
3291 * Get the value of configurable digital input.
3292 *
3293 * @note Can be used to get the value of safety IO.
3294 *
3295 * @param index: Indicates the IO pin, starting from 0.
3296 * For example, 0 means the first pin.
3297 *
3298 * @return Returns true for high level; false for low level.
3299 *
3300 * @throws arcs::common_interface::AuboException
3301 *
3302 * @par Python function prototype
3303 * getConfigurableDigitalInput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3304 *
3305 * @par Lua function prototype
3306 * getConfigurableDigitalInput(index: number) -> boolean
3307 *
3308 * @par Lua example
3309 * status = getConfigurableDigitalInput(0)
3310 *
3311 * @par JSON-RPC request example
3312 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInput","params":[0],"id":1}
3313 *
3314 * @par JSON-RPC response example
3315 * {"id":1,"jsonrpc":"2.0","result":false}
3316 *
3317 * \endenglish
3318 */
3320
3321 /**
3322 * \chinese
3323 * 获取所有的可配置数字输入值
3324 *
3325 * @note 可用于获取安全IO的输入值
3326 *
3327 * @return 所有的可配置数字输入值\n
3328 * 例如,当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
3329 * 后16位就是所有的输入状态值,
3330 * 最后一位表示管脚0的输入状态值,倒数第二位表示管脚1的输入状态值,以此类推。\n
3331 * 1表示高电平状态,0表示低电平状态
3332 *
3333 * @throws arcs::common_interface::AuboException
3334 *
3335 * @par Python函数原型
3336 * getConfigurableDigitalInputs(self: pyaubo_sdk.IoControl) -> int
3337 *
3338 * @par Lua函数原型
3339 * getConfigurableDigitalInputs() -> number
3340 *
3341 * @par Lua示例
3342 * num = getConfigurableDigitalInputs()
3343 *
3344 * @par JSON-RPC请求示例
3345 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputs","params":[],"id":1}
3346 *
3347 * @par JSON-RPC响应示例
3348 * {"id":1,"jsonrpc":"2.0","result":0}
3349 *
3350 * \endchinese
3351 * \english
3352 * Get all configurable digital input values.
3353 *
3354 * @note Can be used to get the value of safety IO.
3355 *
3356 * @return All configurable digital input values.\n
3357 * For example, if the return value is 2863267846, its binary representation is 10101010101010100000000000000110.
3358 * The lower 16 bits represent the status of all input pins,
3359 * the least significant bit indicates the input status of pin 0, the second least significant bit indicates pin 1, and so on.\n
3360 * 1 means high level, 0 means low level.
3361 *
3362 * @throws arcs::common_interface::AuboException
3363 *
3364 * @par Python function prototype
3365 * getConfigurableDigitalInputs(self: pyaubo_sdk.IoControl) -> int
3366 *
3367 * @par Lua function prototype
3368 * getConfigurableDigitalInputs() -> number
3369 *
3370 * @par Lua example
3371 * num = getConfigurableDigitalInputs()
3372 *
3373 * @par JSON-RPC request example
3374 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalInputs","params":[],"id":1}
3375 *
3376 * @par JSON-RPC response example
3377 * {"id":1,"jsonrpc":"2.0","result":0}
3378 *
3379 * \endenglish
3380 */
3382
3383 /**
3384 * \chinese
3385 * 获取标准数字输出值
3386 *
3387 * @param index: 表示IO口的管脚,管脚编号从0开始。
3388 * 例如,0表示第一个管脚。
3389 *
3390 * @return 高电平返回true; 低电平返回false
3391 *
3392 * @throws arcs::common_interface::AuboException
3393 *
3394 * @par Python函数原型
3395 * getStandardDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3396 *
3397 * @par Lua函数原型
3398 * getStandardDigitalOutput(index: number) -> boolean
3399 *
3400 * @par Lua示例
3401 * status = getStandardDigitalOutput(0)
3402 *
3403 * @par JSON-RPC请求示例
3404 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutput","params":[0],"id":1}
3405 *
3406 * @par JSON-RPC响应示例
3407 * {"id":1,"jsonrpc":"2.0","result":true}
3408 *
3409 * \endchinese
3410 * \english
3411 * Get the value of a standard digital output.
3412 *
3413 * @param index: Indicates the IO pin, starting from 0.
3414 * For example, 0 means the first pin.
3415 *
3416 * @return Returns true for high level; false for low level.
3417 *
3418 * @throws arcs::common_interface::AuboException
3419 *
3420 * @par Python function prototype
3421 * getStandardDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3422 *
3423 * @par Lua function prototype
3424 * getStandardDigitalOutput(index: number) -> boolean
3425 *
3426 * @par Lua example
3427 * status = getStandardDigitalOutput(0)
3428 *
3429 * @par JSON-RPC request example
3430 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutput","params":[0],"id":1}
3431 *
3432 * @par JSON-RPC response example
3433 * {"id":1,"jsonrpc":"2.0","result":true}
3434 *
3435 * \endenglish
3436 */
3438
3439 /**
3440 * \chinese
3441 * 获取所有的标准数字输出值
3442 *
3443 * @return 所有的标准数字输出值 \n
3444 * 例如,当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
3445 * 后16位就是所有的标准数字输出状态值,
3446 * 最后一位表示DI00的输出状态值,倒数第二位表示DI01的输出状态值,以此类推。\n
3447 * 1表示高电平状态,0表示低电平状态.
3448 *
3449 * @throws arcs::common_interface::AuboException
3450 *
3451 * @par Python函数原型
3452 * getStandardDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
3453 *
3454 * @par Lua函数原型
3455 * getStandardDigitalOutputs() -> number
3456 *
3457 * @par Lua示例
3458 * num = getStandardDigitalOutputs()
3459 *
3460 * @par JSON-RPC请求示例
3461 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputs","params":[],"id":1}
3462 *
3463 * @par JSON-RPC响应示例
3464 * {"id":1,"jsonrpc":"2.0","result":69}
3465 *
3466 * \endchinese
3467 * \english
3468 * Get all standard digital output values.
3469 *
3470 * @return All standard digital output values.\n
3471 * For example, if the return value is 2863267846, its binary representation is 10101010101010100000000000000110.
3472 * The lower 16 bits represent the status of all standard digital outputs,
3473 * the least significant bit indicates the output status of DO00, the second least significant bit indicates DO01, and so on.\n
3474 * 1 means high level, 0 means low level.
3475 *
3476 * @throws arcs::common_interface::AuboException
3477 *
3478 * @par Python function prototype
3479 * getStandardDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
3480 *
3481 * @par Lua function prototype
3482 * getStandardDigitalOutputs() -> number
3483 *
3484 * @par Lua example
3485 * num = getStandardDigitalOutputs()
3486 *
3487 * @par JSON-RPC request example
3488 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardDigitalOutputs","params":[],"id":1}
3489 *
3490 * @par JSON-RPC response example
3491 * {"id":1,"jsonrpc":"2.0","result":69}
3492 *
3493 * \endenglish
3494 */
3496
3497 /**
3498 * \chinese
3499 * 获取工具端数字输出值
3500 *
3501 * @param index: 表示IO口的管脚,管脚编号从0开始。
3502 * 例如,0表示第一个管脚。
3503 *
3504 * @return 高电平返回true; 低电平返回false
3505 *
3506 * @throws arcs::common_interface::AuboException
3507 *
3508 * @par Python函数原型
3509 * getToolDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3510 *
3511 * @par Lua函数原型
3512 * getToolDigitalOutput(index: number) -> boolean
3513 *
3514 * @par Lua示例
3515 * status = getToolDigitalOutput(0)
3516 *
3517 * @par JSON-RPC请求示例
3518 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutput","params":[0],"id":1}
3519 *
3520 * @par JSON-RPC响应示例
3521 * {"id":1,"jsonrpc":"2.0","result":false}
3522 *
3523 * \endchinese
3524 * \english
3525 * Get the value of tool digital output.
3526 *
3527 * @param index: Indicates the IO pin, starting from 0.
3528 * For example, 0 means the first pin.
3529 *
3530 * @return Returns true for high level; false for low level.
3531 *
3532 * @throws arcs::common_interface::AuboException
3533 *
3534 * @par Python function prototype
3535 * getToolDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) -> bool
3536 *
3537 * @par Lua function prototype
3538 * getToolDigitalOutput(index: number) -> boolean
3539 *
3540 * @par Lua example
3541 * status = getToolDigitalOutput(0)
3542 *
3543 * @par JSON-RPC request example
3544 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutput","params":[0],"id":1}
3545 *
3546 * @par JSON-RPC response example
3547 * {"id":1,"jsonrpc":"2.0","result":false}
3548 *
3549 * \endenglish
3550 */
3551 bool getToolDigitalOutput(int index);
3552
3553 /**
3554 * \chinese
3555 * 获取所有的工具端数字输出值
3556 *
3557 * @return 所有的工具端数字输出值
3558 *
3559 * @throws arcs::common_interface::AuboException
3560 *
3561 * @par Python函数原型
3562 * getToolDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
3563 *
3564 * @par Lua函数原型
3565 * getToolDigitalOutputs() -> number
3566 *
3567 * @par Lua示例
3568 * num = getToolDigitalOutputs()
3569 *
3570 * @par JSON-RPC请求示例
3571 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputs","params":[],"id":1}
3572 *
3573 * @par JSON-RPC响应示例
3574 * {"id":1,"jsonrpc":"2.0","result":9}
3575 *
3576 * \endchinese
3577 * \english
3578 * Get all tool digital output values.
3579 *
3580 * @return All tool digital output values.
3581 *
3582 * @throws arcs::common_interface::AuboException
3583 *
3584 * @par Python function prototype
3585 * getToolDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
3586 *
3587 * @par Lua function prototype
3588 * getToolDigitalOutputs() -> number
3589 *
3590 * @par Lua example
3591 * num = getToolDigitalOutputs()
3592 *
3593 * @par JSON-RPC request example
3594 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolDigitalOutputs","params":[],"id":1}
3595 *
3596 * @par JSON-RPC response example
3597 * {"id":1,"jsonrpc":"2.0","result":9}
3598 *
3599 * \endenglish
3600 */
3602
3603 /**
3604 * \chinese
3605 * 获取可配值数字输出值
3606 *
3607 * @note 可用于获取安全IO的输出值
3608 *
3609 * @param index: 表示IO口的管脚,管脚编号从0开始。
3610 * 例如,0表示第一个管脚。
3611 *
3612 * @return 高电平返回true; 低电平返回false
3613 *
3614 * @throws arcs::common_interface::AuboException
3615 *
3616 * @par Python函数原型
3617 * getConfigurableDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) ->
3618 * bool
3619 *
3620 * @par Lua函数原型
3621 * getConfigurableDigitalOutput(index: number) -> boolean
3622 *
3623 * @par Lua示例
3624 * status = getConfigurableDigitalOutput(0)
3625 *
3626 * @par JSON-RPC请求示例
3627 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutput","params":[0],"id":1}
3628 *
3629 * @par JSON-RPC响应示例
3630 * {"id":1,"jsonrpc":"2.0","result":true}
3631 *
3632 * \endchinese
3633 * \english
3634 * Get the value of configurable digital output.
3635 *
3636 * @note Can be used to get the value of safety IO.
3637 *
3638 * @param index: Indicates the IO pin, starting from 0.
3639 * For example, 0 means the first pin.
3640 *
3641 * @return Returns true for high level; false for low level.
3642 *
3643 * @throws arcs::common_interface::AuboException
3644 *
3645 * @par Python function prototype
3646 * getConfigurableDigitalOutput(self: pyaubo_sdk.IoControl, arg0: int) ->
3647 * bool
3648 *
3649 * @par Lua function prototype
3650 * getConfigurableDigitalOutput(index: number) -> boolean
3651 *
3652 * @par Lua example
3653 * status = getConfigurableDigitalOutput(0)
3654 *
3655 * @par JSON-RPC request example
3656 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutput","params":[0],"id":1}
3657 *
3658 * @par JSON-RPC response example
3659 * {"id":1,"jsonrpc":"2.0","result":true}
3660 *
3661 * \endenglish
3662 */
3664
3665 /**
3666 * \chinese
3667 * 获取所有的可配值数字输出值
3668 *
3669 * @note 可用于获取安全IO的输出值
3670 *
3671 * @return 所有的可配值数字输出\n
3672 * 例如,当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
3673 * 后16位就是所有的输出值,
3674 * 最后一位表示管脚0的输出状态值,倒数第二位表示管脚1的输出状态值,以此类推。\n
3675 * 1表示高电平状态,0表示低电平状态.
3676 *
3677 * @throws arcs::common_interface::AuboException
3678 *
3679 * @par Python函数原型
3680 * getConfigurableDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
3681 *
3682 * @par Lua函数原型
3683 * getConfigurableDigitalOutputs() -> number
3684 *
3685 * @par Lua示例
3686 * num = getConfigurableDigitalOutputs()
3687 *
3688 * @par JSON-RPC请求示例
3689 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputs","params":[],"id":1}
3690 *
3691 * @par JSON-RPC响应示例
3692 * {"id":1,"jsonrpc":"2.0","result":1}
3693 *
3694 * \endchinese
3695 * \english
3696 * Get all configurable digital output values.
3697 *
3698 * @note Can be used to get the value of safety IO.
3699 *
3700 * @return All configurable digital output values.\n
3701 * For example, if the return value is 2863267846, its binary representation is 10101010101010100000000000000110.
3702 * The lower 16 bits represent the status of all output pins,
3703 * the least significant bit indicates the output status of pin 0, the second least significant bit indicates pin 1, and so on.\n
3704 * 1 means high level, 0 means low level.
3705 *
3706 * @throws arcs::common_interface::AuboException
3707 *
3708 * @par Python function prototype
3709 * getConfigurableDigitalOutputs(self: pyaubo_sdk.IoControl) -> int
3710 *
3711 * @par Lua function prototype
3712 * getConfigurableDigitalOutputs() -> number
3713 *
3714 * @par Lua example
3715 * num = getConfigurableDigitalOutputs()
3716 *
3717 * @par JSON-RPC request example
3718 * {"jsonrpc":"2.0","method":"rob1.IoControl.getConfigurableDigitalOutputs","params":[],"id":1}
3719 *
3720 * @par JSON-RPC response example
3721 * {"id":1,"jsonrpc":"2.0","result":1}
3722 *
3723 * \endenglish
3724 */
3726
3727 /**
3728 * \chinese
3729 * 获取标准模拟输入值
3730 *
3731 * @param index: 表示IO口的管脚,管脚编号从0开始。
3732 * 例如,0表示第一个管脚。
3733 *
3734 * @return 标准模拟输入值
3735 *
3736 * @throws arcs::common_interface::AuboException
3737 *
3738 * @par Python函数原型
3739 * getStandardAnalogInput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3740 *
3741 * @par Lua函数原型
3742 * getStandardAnalogInput(index: number) -> number
3743 *
3744 * @par Lua示例
3745 * getStandardAnalogInput(0)
3746 *
3747 * @par JSON-RPC请求示例
3748 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInput","params":[0],"id":1}
3749 *
3750 * @par JSON-RPC响应示例
3751 * {"id":1,"jsonrpc":"2.0","result":0.0}
3752 *
3753 * \endchinese
3754 * \english
3755 * Get the value of standard analog input.
3756 *
3757 * @param index: Indicates the IO pin, starting from 0.
3758 * For example, 0 means the first pin.
3759 *
3760 * @return Standard analog input value.
3761 *
3762 * @throws arcs::common_interface::AuboException
3763 *
3764 * @par Python function prototype
3765 * getStandardAnalogInput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3766 *
3767 * @par Lua function prototype
3768 * getStandardAnalogInput(index: number) -> number
3769 *
3770 * @par Lua example
3771 * getStandardAnalogInput(0)
3772 *
3773 * @par JSON-RPC request example
3774 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogInput","params":[0],"id":1}
3775 *
3776 * @par JSON-RPC response example
3777 * {"id":1,"jsonrpc":"2.0","result":0.0}
3778 *
3779 * \endenglish
3780 */
3781 double getStandardAnalogInput(int index);
3782
3783 /**
3784 * \chinese
3785 * 获取工具端模拟输入值
3786 *
3787 * @param index: 表示IO口的管脚,管脚编号从0开始。
3788 * 例如,0表示第一个管脚。
3789 *
3790 * @return 工具端模拟输入值
3791 *
3792 * @throws arcs::common_interface::AuboException
3793 *
3794 * @par Python函数原型
3795 * getToolAnalogInput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3796 *
3797 * @par Lua函数原型
3798 * getToolAnalogInput(index: number) -> number
3799 *
3800 * @par Lua示例
3801 * num = getToolAnalogInput(0)
3802 *
3803 * @par JSON-RPC请求示例
3804 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInput","params":[0],"id":1}
3805 *
3806 * @par JSON-RPC响应示例
3807 * {"id":1,"jsonrpc":"2.0","result":0.0}
3808 *
3809 * \endchinese
3810 * \english
3811 * Get the value of tool analog input.
3812 *
3813 * @param index: Indicates the IO pin, starting from 0.
3814 * For example, 0 means the first pin.
3815 *
3816 * @return Tool analog input value.
3817 *
3818 * @throws arcs::common_interface::AuboException
3819 *
3820 * @par Python function prototype
3821 * getToolAnalogInput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3822 *
3823 * @par Lua function prototype
3824 * getToolAnalogInput(index: number) -> number
3825 *
3826 * @par Lua example
3827 * num = getToolAnalogInput(0)
3828 *
3829 * @par JSON-RPC request example
3830 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogInput","params":[0],"id":1}
3831 *
3832 * @par JSON-RPC response example
3833 * {"id":1,"jsonrpc":"2.0","result":0.0}
3834 *
3835 * \endenglish
3836 */
3837 double getToolAnalogInput(int index);
3838
3839 /**
3840 * \chinese
3841 * 获取标准模拟输出值
3842 *
3843 * @param index: 表示IO口的管脚,管脚编号从0开始。
3844 * 例如,0表示第一个管脚。
3845 *
3846 * @return 标准模拟输出值
3847 *
3848 * @throws arcs::common_interface::AuboException
3849 *
3850 * @par Python函数原型
3851 * getStandardAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3852 *
3853 * @par Lua函数原型
3854 * getStandardAnalogOutput(index: number) -> number
3855 *
3856 * @par Lua示例
3857 * num = getStandardAnalogOutput(0)
3858 *
3859 * @par JSON-RPC请求示例
3860 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutput","params":[0],"id":1}
3861 *
3862 * @par JSON-RPC响应示例
3863 * {"id":1,"jsonrpc":"2.0","result":0.0}
3864 *
3865 * \endchinese
3866 * \english
3867 * Get the value of standard analog output.
3868 *
3869 * @param index: Indicates the IO pin, starting from 0.
3870 * For example, 0 means the first pin.
3871 *
3872 * @return Standard analog output value.
3873 *
3874 * @throws arcs::common_interface::AuboException
3875 *
3876 * @par Python function prototype
3877 * getStandardAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3878 *
3879 * @par Lua function prototype
3880 * getStandardAnalogOutput(index: number) -> number
3881 *
3882 * @par Lua example
3883 * num = getStandardAnalogOutput(0)
3884 *
3885 * @par JSON-RPC request example
3886 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStandardAnalogOutput","params":[0],"id":1}
3887 *
3888 * @par JSON-RPC response example
3889 * {"id":1,"jsonrpc":"2.0","result":0.0}
3890 *
3891 * \endenglish
3892 */
3893 double getStandardAnalogOutput(int index);
3894
3895 /**
3896 * \chinese
3897 * 获取工具端模拟输出值
3898 *
3899 * @param index: 表示IO口的管脚,管脚编号从0开始。
3900 * 例如,0表示第一个管脚。
3901 *
3902 * @return 工具端模拟输出值
3903 *
3904 * @throws arcs::common_interface::AuboException
3905 *
3906 * @par Python函数原型
3907 * getToolAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3908 *
3909 * @par Lua函数原型
3910 * getToolAnalogOutput(index: number) -> number
3911 *
3912 * @par Lua示例
3913 * num = getToolAnalogOutput(0)
3914 *
3915 * @par JSON-RPC请求示例
3916 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutput","params":[0],"id":1}
3917 *
3918 * @par JSON-RPC响应示例
3919 * {"id":1,"jsonrpc":"2.0","result":0.0}
3920 *
3921 * \endchinese
3922 * \english
3923 * Get the value of tool analog output.
3924 *
3925 * @param index: Indicates the IO pin, starting from 0.
3926 * For example, 0 means the first pin.
3927 *
3928 * @return Tool analog output value.
3929 *
3930 * @throws arcs::common_interface::AuboException
3931 *
3932 * @par Python function prototype
3933 * getToolAnalogOutput(self: pyaubo_sdk.IoControl, arg0: int) -> float
3934 *
3935 * @par Lua function prototype
3936 * getToolAnalogOutput(index: number) -> number
3937 *
3938 * @par Lua example
3939 * num = getToolAnalogOutput(0)
3940 *
3941 * @par JSON-RPC request example
3942 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolAnalogOutput","params":[0],"id":1}
3943 *
3944 * @par JSON-RPC response example
3945 * {"id":1,"jsonrpc":"2.0","result":0.0}
3946 *
3947 * \endenglish
3948 */
3949 double getToolAnalogOutput(int index);
3950
3951 /**
3952 * \chinese
3953 * 获取联动输入数量
3954 *
3955 * @return 联动输入数量
3956 *
3957 * @throws arcs::common_interface::AuboException
3958 *
3959 * @par Python函数原型
3960 * getStaticLinkInputNum(self: pyaubo_sdk.IoControl) -> int
3961 *
3962 * @par Lua函数原型
3963 * getStaticLinkInputNum() -> number
3964 *
3965 * @par Lua示例
3966 * num = getStaticLinkInputNum()
3967 *
3968 * @par JSON-RPC请求示例
3969 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkInputNum","params":[],"id":1}
3970 *
3971 * @par JSON-RPC响应示例
3972 * {"id":1,"jsonrpc":"2.0","result":8}
3973 *
3974 * \endchinese
3975 * \english
3976 * Get the number of static link inputs.
3977 *
3978 * @return Number of static link inputs.
3979 *
3980 * @throws arcs::common_interface::AuboException
3981 *
3982 * @par Python function prototype
3983 * getStaticLinkInputNum(self: pyaubo_sdk.IoControl) -> int
3984 *
3985 * @par Lua function prototype
3986 * getStaticLinkInputNum() -> number
3987 *
3988 * @par Lua example
3989 * num = getStaticLinkInputNum()
3990 *
3991 * @par JSON-RPC request example
3992 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkInputNum","params":[],"id":1}
3993 *
3994 * @par JSON-RPC response example
3995 * {"id":1,"jsonrpc":"2.0","result":8}
3996 *
3997 * \endenglish
3998 */
4000
4001 /**
4002 * \chinese
4003 * 获取联动输出数量
4004 *
4005 * @return 联动输出数量
4006 *
4007 * @throws arcs::common_interface::AuboException
4008 *
4009 * @par Python函数原型
4010 * getStaticLinkOutputNum(self: pyaubo_sdk.IoControl) -> int
4011 *
4012 * @par Lua函数原型
4013 * getStaticLinkOutputNum() -> number
4014 *
4015 * @par Lua示例
4016 * num = getStaticLinkOutputNum()
4017 *
4018 * @par JSON-RPC请求示例
4019 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkOutputNum","params":[],"id":1}
4020 *
4021 * @par JSON-RPC响应示例
4022 * {"id":1,"jsonrpc":"2.0","result":0}
4023 *
4024 * \endchinese
4025 * \english
4026 * Get the number of static link outputs.
4027 *
4028 * @return Number of static link outputs.
4029 *
4030 * @throws arcs::common_interface::AuboException
4031 *
4032 * @par Python function prototype
4033 * getStaticLinkOutputNum(self: pyaubo_sdk.IoControl) -> int
4034 *
4035 * @par Lua function prototype
4036 * getStaticLinkOutputNum() -> number
4037 *
4038 * @par Lua example
4039 * num = getStaticLinkOutputNum()
4040 *
4041 * @par JSON-RPC request example
4042 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkOutputNum","params":[],"id":1}
4043 *
4044 * @par JSON-RPC response example
4045 * {"id":1,"jsonrpc":"2.0","result":0}
4046 *
4047 * \endenglish
4048 */
4050
4051 /**
4052 * \chinese
4053 * 获取所有的联动输入值
4054 *
4055 * @return 所有的联动输入值\n
4056 * 例如,当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
4057 * 后16位就是所有的联动输入状态值,
4058 * 最后一位表示管脚0的输入状态值,倒数第二位表示管脚1的输入状态值,以此类推。\n
4059 * 1表示高电平状态,0表示低电平状态.
4060 *
4061 * @throws arcs::common_interface::AuboException
4062 *
4063 * @par Python函数原型
4064 * getStaticLinkInputs(self: pyaubo_sdk.IoControl) -> int
4065 *
4066 * @par Lua函数原型
4067 * getStaticLinkInputs() -> number
4068 *
4069 * @par Lua示例
4070 * num = getStaticLinkInputs()
4071 *
4072 * @par JSON-RPC请求示例
4073 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkInputs","params":[],"id":1}
4074 *
4075 * @par JSON-RPC响应示例
4076 * {"id":1,"jsonrpc":"2.0","result":0}
4077 *
4078 * \endchinese
4079 * \english
4080 * Get all static link input values.
4081 *
4082 * @return All static link input values.\n
4083 * For example, if the return value is 2863267846, its binary representation is 10101010101010100000000000000110.
4084 * The lower 16 bits represent the status of all static link inputs,
4085 * the least significant bit indicates the input status of pin 0, the second least significant bit indicates pin 1, and so on.\n
4086 * 1 means high level, 0 means low level.
4087 *
4088 * @throws arcs::common_interface::AuboException
4089 *
4090 * @par Python function prototype
4091 * getStaticLinkInputs(self: pyaubo_sdk.IoControl) -> int
4092 *
4093 * @par Lua function prototype
4094 * getStaticLinkInputs() -> number
4095 *
4096 * @par Lua example
4097 * num = getStaticLinkInputs()
4098 *
4099 * @par JSON-RPC request example
4100 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkInputs","params":[],"id":1}
4101 *
4102 * @par JSON-RPC response example
4103 * {"id":1,"jsonrpc":"2.0","result":0}
4104 *
4105 * \endenglish
4106 */
4108
4109 /**
4110 * \chinese
4111 * 获取所有的联动输出值
4112 *
4113 * @return 返回所有的联动输出值 \n
4114 * 例如,当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
4115 * 后16位就是所有的联动输出状态值,
4116 * 最后一位表示管脚0的输出状态值,倒数第二位表示管脚1的输出状态值,以此类推。\n
4117 * 1表示高电平状态,0表示低电平状态.
4118 *
4119 * @throws arcs::common_interface::AuboException
4120 *
4121 * @par Python函数原型
4122 * getStaticLinkOutputs(self: pyaubo_sdk.IoControl) -> int
4123 *
4124 * @par Lua函数原型
4125 * getStaticLinkOutputs() -> number
4126 *
4127 * @par Lua示例
4128 * num = getStaticLinkOutputs()
4129 *
4130 * @par JSON-RPC请求示例
4131 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkOutputs","params":[],"id":1}
4132 *
4133 * @par JSON-RPC响应示例
4134 * {"id":1,"jsonrpc":"2.0","result":0}
4135 *
4136 * \endchinese
4137 * \english
4138 * Get all static link output values.
4139 *
4140 * @return Returns all static link output values.\n
4141 * For example, if the return value is 2863267846, its binary representation is 10101010101010100000000000000110.
4142 * The lower 16 bits represent the status of all static link outputs,
4143 * the least significant bit indicates the output status of pin 0, the second least significant bit indicates pin 1, and so on.\n
4144 * 1 means high level, 0 means low level.
4145 *
4146 * @throws arcs::common_interface::AuboException
4147 *
4148 * @par Python function prototype
4149 * getStaticLinkOutputs(self: pyaubo_sdk.IoControl) -> int
4150 *
4151 * @par Lua function prototype
4152 * getStaticLinkOutputs() -> number
4153 *
4154 * @par Lua example
4155 * num = getStaticLinkOutputs()
4156 *
4157 * @par JSON-RPC request example
4158 * {"jsonrpc":"2.0","method":"rob1.IoControl.getStaticLinkOutputs","params":[],"id":1}
4159 *
4160 * @par JSON-RPC response example
4161 * {"id":1,"jsonrpc":"2.0","result":0}
4162 *
4163 * \endenglish
4164 */
4166
4167 /**
4168 * \chinese
4169 * 机器人是否配置了编码器
4170 * 集成编码器的编号为 0
4171 *
4172 * @return 机器人配置编码器返回 true, 反之返回 false
4173 *
4174 * @throws arcs::common_interface::AuboException
4175 *
4176 * @par JSON-RPC请求示例
4177 * {"jsonrpc":"2.0","method":"rob1.IoControl.hasEncoderSensor","params":[],"id":1}
4178 *
4179 * @par JSON-RPC响应示例
4180 * {"id":1,"jsonrpc":"2.0","result":true}
4181 *
4182 * \endchinese
4183 * \english
4184 * Whether the robot is equipped with an encoder.
4185 * The integrated encoder number is 0.
4186 *
4187 * @return Returns true if the robot is equipped with an encoder, otherwise false.
4188 *
4189 * @throws arcs::common_interface::AuboException
4190 *
4191 * @par JSON-RPC request example
4192 * {"jsonrpc":"2.0","method":"rob1.IoControl.hasEncoderSensor","params":[],"id":1}
4193 *
4194 * @par JSON-RPC response example
4195 * {"id":1,"jsonrpc":"2.0","result":true}
4196 *
4197 * \endenglish
4198 */
4200 /**
4201 * \chinese
4202 * 设置集成编码器的解码方式
4203 *
4204 * @param type
4205 * 0-禁用编码器
4206 * 1-AB正交
4207 * 2-AB正交+Z
4208 * 3-AB差分正交
4209 * 4-AB差分正交+Z差分
4210 *
4211 * @param range_id
4212 * 0 表示32位有符号编码器,范围为 [-2147483648, 2147483647]
4213 * 1 表示8位无符号编码器,范围为 [0, 255]
4214 * 2 表示16位无符号编码器,范围为 [0, 65535]
4215 * 3 表示24位无符号编码器,范围为 [0, 16777215]
4216 * 4 表示32位无符号编码器,范围为 [0, 4294967295]
4217 *
4218 * @return 成功返回0;失败返回错误码
4219 * AUBO_NO_ACCESS
4220 * AUBO_BUSY
4221 * AUBO_BAD_STATE
4222 * -AUBO_INVL_ARGUMENT
4223 * -AUBO_BAD_STATE
4224 *
4225 * @throws arcs::common_interface::AuboException
4226 * \endchinese
4227 * \english
4228 * Set the decoding method of the integrated encoder.
4229 *
4230 * @param type
4231 * 0 - Disable encoder
4232 * 1 - AB quadrature
4233 * 2 - AB quadrature + Z
4234 * 3 - AB differential quadrature
4235 * 4 - AB differential quadrature + Z differential
4236 *
4237 * @param range_id
4238 * 0 is a 32-bit signed encoder, range [-2147483648, 2147483647]
4239 * 1 is an 8-bit unsigned encoder, range [0, 255]
4240 * 2 is a 16-bit unsigned encoder, range [0, 65535]
4241 * 3 is a 24-bit unsigned encoder, range [0, 16777215]
4242 * 4 is a 32-bit unsigned encoder, range [0, 4294967295]
4243 *
4244 * @return Returns 0 on success; error code on failure.
4245 * AUBO_NO_ACCESS
4246 * AUBO_BUSY
4247 * AUBO_BAD_STATE
4248 * -AUBO_INVL_ARGUMENT
4249 * -AUBO_BAD_STATE
4250 *
4251 * @throws arcs::common_interface::AuboException
4252 * \endenglish
4253 */
4254 int setEncDecoderType(int type, int range_id);
4255
4256 /**
4257 * \chinese
4258 * 设置集成编码器脉冲数
4259 *
4260 * @param tick 脉冲数
4261 *
4262 * @return 成功返回0;失败返回错误码
4263 * AUBO_NO_ACCESS
4264 * AUBO_BUSY
4265 * AUBO_BAD_STATE
4266 * -AUBO_INVL_ARGUMENT
4267 * -AUBO_BAD_STATE
4268 *
4269 * @throws arcs::common_interface::AuboException
4270 * \endchinese
4271 * \english
4272 * Set the tick count of the integrated encoder.
4273 *
4274 * @param tick Tick count
4275 *
4276 * @return Returns 0 on success; error code on failure.
4277 * AUBO_NO_ACCESS
4278 * AUBO_BUSY
4279 * AUBO_BAD_STATE
4280 * -AUBO_INVL_ARGUMENT
4281 * -AUBO_BAD_STATE
4282 *
4283 * @throws arcs::common_interface::AuboException
4284 * \endenglish
4285 */
4286 int setEncTickCount(int tick);
4287
4288 /**
4289 * \chinese
4290 * 获取编码器的解码方式
4291 *
4292 * @return 成功返回0;失败返回错误码
4293 * AUBO_NO_ACCESS
4294 * AUBO_BUSY
4295 * AUBO_BAD_STATE
4296 * -AUBO_BAD_STATE
4297 *
4298 * @throws arcs::common_interface::AuboException
4299 *
4300 * @par JSON-RPC请求示例
4301 * {"jsonrpc":"2.0","method":"rob1.IoControl.getEncDecoderType","params":[],"id":1}
4302 *
4303 * @par JSON-RPC响应示例
4304 * {"id":1,"jsonrpc":"2.0","result":0}
4305 *
4306 * \endchinese
4307 * \english
4308 * Get the decoder type of the encoder.
4309 *
4310 * @return Returns 0 on success; error code on failure.
4311 * AUBO_NO_ACCESS
4312 * AUBO_BUSY
4313 * AUBO_BAD_STATE
4314 * -AUBO_BAD_STATE
4315 *
4316 * @throws arcs::common_interface::AuboException
4317 *
4318 * @par JSON-RPC request example
4319 * {"jsonrpc":"2.0","method":"rob1.IoControl.getEncDecoderType","params":[],"id":1}
4320 *
4321 * @par JSON-RPC response example
4322 * {"id":1,"jsonrpc":"2.0","result":0}
4323 *
4324 * \endenglish
4325 */
4327
4328 /**
4329 * \chinese
4330 * 获取脉冲数
4331 *
4332 * @return 成功返回0;失败返回错误码
4333 * AUBO_NO_ACCESS
4334 * AUBO_BUSY
4335 * AUBO_BAD_STATE
4336 * -AUBO_BAD_STATE
4337 *
4338 * @throws arcs::common_interface::AuboException
4339 *
4340 * @par JSON-RPC请求示例
4341 * {"jsonrpc":"2.0","method":"rob1.IoControl.getEncTickCount","params":[],"id":1}
4342 *
4343 * @par JSON-RPC响应示例
4344 * {"id":1,"jsonrpc":"2.0","result":0}
4345 *
4346 * \endchinese
4347 * \english
4348 * Get the tick count
4349 *
4350 * @return Returns 0 on success; error code on failure.
4351 * AUBO_NO_ACCESS
4352 * AUBO_BUSY
4353 * AUBO_BAD_STATE
4354 * -AUBO_BAD_STATE
4355 *
4356 * @throws arcs::common_interface::AuboException
4357 *
4358 * @par JSON-RPC request example
4359 * {"jsonrpc":"2.0","method":"rob1.IoControl.getEncTickCount","params":[],"id":1}
4360 *
4361 * @par JSON-RPC response example
4362 * {"id":1,"jsonrpc":"2.0","result":0}
4363 *
4364 * \endenglish
4365 */
4367
4368 /**
4369 * \chinese
4370 * 防止在计数超出范围时计数错误
4371 *
4372 * @param delta_count
4373 *
4374 * @return 成功返回0;失败返回错误码
4375 * AUBO_NO_ACCESS
4376 * AUBO_BUSY
4377 * AUBO_BAD_STATE
4378 * -AUBO_BAD_STATE
4379 *
4380 * @throws arcs::common_interface::AuboException
4381 * \endchinese
4382 * \english
4383 * Prevent counting errors when the count exceeds the range
4384 *
4385 * @param delta_count
4386 *
4387 * @return Returns 0 on success; error code on failure.
4388 * AUBO_NO_ACCESS
4389 * AUBO_BUSY
4390 * AUBO_BAD_STATE
4391 * -AUBO_BAD_STATE
4392 *
4393 * @throws arcs::common_interface::AuboException
4394 * \endenglish
4395 */
4396 int unwindEncDeltaTickCount(int delta_count);
4397
4398 /**
4399 * \chinese
4400 * 获取末端按钮状态
4401 *
4402 * @return 按下返回true; 否则返回false
4403 *
4404 * @throws arcs::common_interface::AuboException
4405 *
4406 * @par Python函数原型
4407 * getToolButtonStatus() -> bool
4408 *
4409 * @par Lua函数原型
4410 * getToolButtonStatus() -> boolean
4411 *
4412 * @par Lua示例
4413 * status = getToolButtonStatus()
4414 *
4415 * @par JSON-RPC请求示例
4416 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolButtonStatus","params":[],"id":1}
4417 *
4418 * @par JSON-RPC响应示例
4419 * {"id":1,"jsonrpc":"2.0","result":false}
4420 *
4421 * \endchinese
4422 * \english
4423 * Get the status of the tool button.
4424 *
4425 * @return Returns true if pressed; otherwise false.
4426 *
4427 * @throws arcs::common_interface::AuboException
4428 *
4429 * @par Python function prototype
4430 * getToolButtonStatus() -> bool
4431 *
4432 * @par Lua function prototype
4433 * getToolButtonStatus() -> boolean
4434 *
4435 * @par Lua example
4436 * status = getToolButtonStatus()
4437 *
4438 * @par JSON-RPC request example
4439 * {"jsonrpc":"2.0","method":"rob1.IoControl.getToolButtonStatus","params":[],"id":1}
4440 *
4441 * @par JSON-RPC response example
4442 * {"id":1,"jsonrpc":"2.0","result":false}
4443 *
4444 * \endenglish
4445 */
4447
4448 /**
4449 * \chinese
4450 * 获取手柄按键状态
4451 *
4452 * @note 获取手柄按键状态
4453 *
4454 * @return 所有的手柄按键输入值\n
4455 * 例如,当返回值是2863267846时,换成2进制后是10101010101010100000000000000110。
4456 * 后16位就是所有的输入状态值,
4457 * 最后一位表示管脚0的输入状态值,倒数第二位表示管脚1的输入状态值,以此类推。\n
4458 * 1表示高电平状态,0表示低电平状态
4459 *
4460 * @throws arcs::common_interface::AuboException
4461 *
4462 * @par Python函数原型
4463 * getHandleIoStatus(self: pyaubo_sdk.IoControl) -> int
4464 *
4465 * @par Lua函数原型
4466 * getHandleIoStatus() -> number
4467 *
4468 * @par Lua示例
4469 * num = getHandleIoStatus()
4470 *
4471 * @par JSON-RPC请求示例
4472 * {"jsonrpc":"2.0","method":"rob1.IoControl.getHandleIoStatus","params":[],"id":1}
4473 *
4474 * @par JSON-RPC响应示例
4475 * {"id":1,"jsonrpc":"2.0","result":0}
4476 *
4477 * \endchinese
4478 * \english
4479 * Get the status of handle buttons.
4480 *
4481 * @note Get the status of handle buttons.
4482 *
4483 * @return All handle button input values.\n
4484 * For example, if the return value is 2863267846, its binary representation is 10101010101010100000000000000110.
4485 * The lower 16 bits represent the status of all input pins,
4486 * the least significant bit indicates the input status of pin 0, the second least significant bit indicates pin 1, and so on.\n
4487 * 1 means high level, 0 means low level.
4488 *
4489 * @throws arcs::common_interface::AuboException
4490 *
4491 * @par Python function prototype
4492 * getHandleIoStatus(self: pyaubo_sdk.IoControl) -> int
4493 *
4494 * @par Lua function prototype
4495 * getHandleIoStatus() -> number
4496 *
4497 * @par Lua example
4498 * num = getHandleIoStatus()
4499 *
4500 * @par JSON-RPC request example
4501 * {"jsonrpc":"2.0","method":"rob1.IoControl.getHandleIoStatus","params":[],"id":1}
4502 *
4503 * @par JSON-RPC response example
4504 * {"id":1,"jsonrpc":"2.0","result":0}
4505 *
4506 * \endenglish
4507 */
4509
4510 /**
4511 * \chinese
4512 * 获取手柄类型
4513 *
4514 * @return type
4515 *
4516 * @throws arcs::common_interface::AuboException
4517 *
4518 * @par Python函数原型
4519 * getHandleType() -> int
4520 *
4521 * @par Lua函数原型
4522 * getHandleType() -> int
4523 *
4524 * @par Lua示例
4525 * int_num = getHandleType()
4526 *
4527 * @par JSON-RPC请求示例
4528 * {"jsonrpc":"2.0","method":"rob1.IoControl.getHandleType","params":[],"id":1}
4529 *
4530 * @par JSON-RPC响应示例
4531 * {"id":1,"jsonrpc":"2.0","result":0}
4532 *
4533 * \endchinese
4534 * \english
4535 * Get the handle type.
4536 *
4537 * @return type
4538 *
4539 * @throws arcs::common_interface::AuboException
4540 *
4541 * @par Python function prototype
4542 * getHandleType() -> int
4543 *
4544 * @par Lua function prototype
4545 * getHandleType() -> int
4546 *
4547 * @par Lua example
4548 * int_num = getHandleType()
4549 *
4550 * @par JSON-RPC request example
4551 * {"jsonrpc":"2.0","method":"rob1.IoControl.getHandleType","params":[],"id":1}
4552 *
4553 * @par JSON-RPC response example
4554 * {"id":1,"jsonrpc":"2.0","result":0}
4555 *
4556 * \endenglish
4557 */
4559
4560protected:
4561 void *d_;
4562};
4563using IoControlPtr = std::shared_ptr<IoControl>;
4564} // namespace common_interface
4565} // namespace arcs
4566
4567#endif // AUBO_SDK_IO_CONTROL_INTERFACE_H
IoControl类提供了一系列的接口对机器人标配的一些数字、模拟IO进行配置,输出状态设置、读取
Definition io_control.h:43
int setToolAnalogOutputDomain(int index, int domain)
设置工具端模拟输出范围
StandardInputAction getStandardDigitalInputAction(int index)
获取标准数字输入触发动作
int setToolAnalogInputDomain(int index, int domain)
设置工具端模拟输入的范围
bool getToolDigitalOutput(int index)
获取工具端数字输出值
int getConfigurableDigitalOutputNum()
获取可配置数字输出数量
int setConfigurableDigitalOutput(int index, bool value)
设置可配置数字输出值
StandardOutputRunState getToolAnalogOutputRunstate(int index)
获取工具端模拟输出状态选择
uint32_t getStaticLinkOutputs()
获取所有的联动输出值
uint32_t getStandardDigitalOutputs()
获取所有的标准数字输出值
StandardInputAction getConfigurableDigitalInputAction(int index)
获取可配置数字输入的输入触发动作
int setStandardDigitalInputAction(int index, StandardInputAction action)
设置标准数字输入触发动作
int setConfigurableDigitalInputAction(int index, StandardInputAction action)
设置可配置数字输入触发动作
int getConfigurableDigitalInputNum()
获取可配置数字输入数量
int getStandardAnalogOutputNum()
获取标准模拟输出数量
int getToolDigitalOutputNum()
获取工具端数字IO数量(包括数字输入和数字输出)
double getStandardAnalogOutput(int index)
获取标准模拟输出值
uint32_t getHandleIoStatus()
获取手柄按键状态
int setDigitalOutputRunstateDefault()
设置所有数字输出状态选择为无
StandardOutputRunState getStandardDigitalOutputRunstate(int index)
获取标准数字输出状态选择
int getStaticLinkOutputNum()
获取联动输出数量
int getEncTickCount()
获取脉冲数
int getStandardDigitalOutputNum()
获取标准数字输出数量
int getHandleType()
获取手柄类型
int setToolAnalogOutputRunstate(int index, StandardOutputRunState runstate)
设置工具端模拟输出状态选择
int getToolAnalogInputNum()
获取工具端模拟输入数量
int setStandardDigitalOutput(int index, bool value)
设置标准数字输出值
bool getStandardDigitalOutput(int index)
获取标准数字输出值
bool getToolDigitalInput(int index)
获取工具端数字输入值
StandardInputAction getToolDigitalInputAction(int index)
获取工具端数字输入触发动作
double getToolAnalogOutput(int index)
获取工具端模拟输出值
int getToolVoltageOutputDomain()
获取工具端电源电压值(单位V)
int getStandardDigitalInputNum()
获取标准数字输入数量
int getToolDigitalInputNum()
获取工具端数字IO数量(包括数字输入和数字输出)
bool getStandardDigitalInput(int index)
获取标准数字输入值
int setToolVoltageOutputDomain(int domain)
设置工具端电源电压值(单位V)
int setToolDigitalOutputPulse(int index, bool value, double duration)
设置工具端数字输出脉冲
uint32_t getToolDigitalOutputs()
获取所有的工具端数字输出值
int setToolDigitalInputAction(int index, StandardInputAction action)
设置工具数字输入触发动作
int setConfigurableDigitalOutputPulse(int index, bool value, double duration)
设置可配置数字输出脉冲
int setStandardAnalogOutputDomain(int index, int domain)
设置标准模拟输出的范围
double getToolAnalogInput(int index)
获取工具端模拟输入值
int setEncDecoderType(int type, int range_id)
设置集成编码器的解码方式
StandardOutputRunState getConfigurableDigitalOutputRunstate(int index)
获取可配置数字输出状态选择
int getStandardAnalogInputDomain(int index)
获取标准模式输入范围
int setToolIoInput(int index, bool input)
设置指定的工具端数字IO为输入或输出
int getToolAnalogOutputNum()
获取工具端模拟输出数量
StandardOutputRunState getStandardAnalogOutputRunstate(int index)
获取标准模拟输出状态选择
uint32_t getConfigurableDigitalInputs()
获取所有的可配置数字输入值
bool getToolButtonStatus()
获取末端按钮状态
int getStandardAnalogOutputDomain(int index)
获取标准模拟输出范围
int setStandardAnalogInputDomain(int index, int domain)
设置标准模拟输入的范围
int setDigitalInputActionDefault()
设置所有数字输入动作为无触发
uint32_t getToolDigitalInputs()
获取所有的工具端数字输入值
int getStandardAnalogInputNum()
获取标准模拟输入数量
int setToolAnalogOutput(int index, double value)
设置工具端模拟输出值
int setConfigurableDigitalOutputRunstate(int index, StandardOutputRunState runstate)
设置可配置数字输出状态选择
int setEncTickCount(int tick)
设置集成编码器脉冲数
bool hasEncoderSensor()
机器人是否配置了编码器 集成编码器的编号为 0
int getToolAnalogOutputDomain(int index)
获取工具端模拟输出范围
int getToolAnalogInputDomain(int index)
获取工具端模式输入范围
bool isToolIoInput(int index)
判断指定的工具端数字IO类型是否为输入
int setStandardDigitalOutputRunstate(int index, StandardOutputRunState runstate)
设置标准数字输出状态选择
int setToolDigitalOutputRunstate(int index, StandardOutputRunState runstate)
设置工具端数字输出状态选择
int setToolDigitalOutput(int index, bool value)
设置工具端数字输出值
int setStandardAnalogOutputRunstate(int index, StandardOutputRunState runstate)
设置标准模拟输出状态选择
StandardOutputRunState getToolDigitalOutputRunstate(int index)
获取工具端数字输出状态选择
uint32_t getConfigurableDigitalOutputs()
获取所有的可配值数字输出值
int unwindEncDeltaTickCount(int delta_count)
防止在计数超出范围时计数错误
uint32_t getStandardDigitalInputs()
获取所有的标准数字输入值
double getStandardAnalogInput(int index)
获取标准模拟输入值
int getEncDecoderType()
获取编码器的解码方式
int setStandardAnalogOutput(int index, double value)
设置标准模拟输出值
uint32_t getStaticLinkInputs()
获取所有的联动输入值
bool getConfigurableDigitalInput(int index)
获取可配置数字输入值
int getStaticLinkInputNum()
获取联动输入数量
bool getConfigurableDigitalOutput(int index)
获取可配值数字输出值
int setStandardDigitalOutputPulse(int index, bool value, double duration)
设置数字输出脉冲
StandardInputAction
The StandardInputAction enum
Definition type_def.h:597
std::shared_ptr< IoControl > IoControlPtr
StandardOutputRunState
标准输出运行状态
Definition type_def.h:589
数据类型的定义