4.7 C99 Signals IO 인터페이스

개요

C99 Signals 는 단일 포인트 읽기, 단일 포인트 쓰기, 일괄 읽기, 일괄 쓰기, 시간 간격 기반 IO 펄스 트리거를 제공합니다. 포트 번호는 컨트롤러 측 번호를 그대로 사용합니다.

해당 헤더 파일:

• include/c_arm_signals.h

인터페이스 시그니처

Arm_Signals_Read

int Arm_Signals_Read(ArmHandle* h, int signalType, int index, double* outValue);

항목	설명
설명	단일 IO 신호를 읽습니다.
요청 파라미터	h : ArmHandle* , C99 세션 핸들. 일반적으로 Arm_Create() 에서 얻으며, 업무 인터페이스 호출 전 연결이 성공해야 합니다. signalType : int , 신호 타입. 값은 지원 범위 표를 참고하십시오. index : int , IO 포트 번호 outValue : double* , 출력 신호값 포인터
반환값	STATUS_CODE 정수값. 0 은 성공을 의미하며, 그 외 값은 상태 코드로 처리합니다.

Arm_Signals_WriteInt

int Arm_Signals_WriteInt(ArmHandle* h, int signalType, int index, int value);

항목	설명
설명	정수형 IO 신호를 씁니다.
요청 파라미터	h : ArmHandle* , C99 세션 핸들. 일반적으로 Arm_Create() 에서 얻으며, 업무 인터페이스 호출 전 연결이 성공해야 합니다. signalType : int , 신호 타입. DO , RO , GO , TDO 에 해당하는 값만 지원합니다. index : int , IO 포트 번호 value : int , 정수형 IO 쓰기 값
반환값	STATUS_CODE 정수값. 0 은 성공을 의미하며, 그 외 값은 상태 코드로 처리합니다.

Arm_Signals_WriteFloat

int Arm_Signals_WriteFloat(ArmHandle* h, int signalType, int index, double value);

항목	설명
설명	부동소수점 IO 신호를 씁니다.
요청 파라미터	h : ArmHandle* , C99 세션 핸들. 일반적으로 Arm_Create() 에서 얻으며, 업무 인터페이스 호출 전 연결이 성공해야 합니다. signalType : int , 신호 타입. AO 에 해당하는 값만 지원합니다. index : int , IO 포트 번호 value : double , 부동소수점 IO 쓰기 값
반환값	STATUS_CODE 정수값. 0 은 성공을 의미하며, 그 외 값은 상태 코드로 처리합니다.

Arm_Signals_MultiRead

int Arm_Signals_MultiRead(ArmHandle* h, int signalType, const int* portList, size_t portCount, int* outValues, size_t maxCount, size_t* outCount);

항목	설명
설명	IO 신호를 일괄 읽습니다.
요청 파라미터	h : ArmHandle* , C99 세션 핸들. 일반적으로 Arm_Create() 에서 얻으며, 업무 인터페이스 호출 전 연결이 성공해야 합니다. signalType : int , 신호 타입. DO 에 해당하는 값만 지원합니다. portList : const int* , 포트 번호 배열 portCount : size_t , 포트 번호 개수 outValues : int* , 호출자가 할당하는 일괄 출력 배열 maxCount : size_t , 출력 배열 용량. 호출자가 최대 몇 개의 요소를 받을 수 있는지를 나타냅니다. outCount : size_t* , 출력 개수 포인터. 성공 시 실제 개수를 씁니다.
반환값	STATUS_CODE 정수값. 0 은 성공을 의미하며, 그 외 값은 상태 코드로 처리합니다.

Arm_Signals_MultiWrite

int Arm_Signals_MultiWrite(ArmHandle* h, int signalType, const int* ioList, size_t ioCount);

항목	설명
설명	IO 신호를 일괄 씁니다.
요청 파라미터	h : ArmHandle* , C99 세션 핸들. 일반적으로 Arm_Create() 에서 얻으며, 업무 인터페이스 호출 전 연결이 성공해야 합니다. signalType : int , 신호 타입. DO 에 해당하는 값만 지원합니다. ioList : const int* , 평탄화된 IO 쓰기 배열. [port, value, port, value] 형식으로 구성합니다. ioCount : size_t , 평탄화된 IO 배열 요소 수
반환값	STATUS_CODE 정수값. 0 은 성공을 의미하며, 그 외 값은 상태 코드로 처리합니다.

Arm_Signals_TriggerIOWithIntervals

int Arm_Signals_TriggerIOWithIntervals(ArmHandle* h, int inPort, const int* intervals, size_t intervalCount, const int* outPorts, size_t outPortCount, int pulseDuration);

항목	설명
설명	시간 간격에 따라 IO 출력 펄스를 트리거합니다.
요청 파라미터	h : ArmHandle* , C99 세션 핸들. 일반적으로 Arm_Create() 에서 얻으며, 업무 인터페이스 호출 전 연결이 성공해야 합니다. inPort : int , 입력 포트 번호 intervals : const int* , 트리거 간격 배열 intervalCount : size_t , 트리거 간격 개수 outPorts : const int* , 출력 포트 번호 배열 outPortCount : size_t , 출력 포트 개수 pulseDuration : int , 출력 펄스 지속 시간
반환값	STATUS_CODE 정수값. 0 은 성공을 의미하며, 그 외 값은 상태 코드로 처리합니다.

파라미터 및 규칙

지원 범위

인터페이스	지원 범위
Arm_Signals_Read	DI 、 DO 、 UI 、 UO 、 RI 、 RO 、 GI 、 GO 、 TAI 、 TDI 、 TDO 、 AI 、 AO
Arm_Signals_WriteInt	DO 、 RO 、 GO 、 TDO
Arm_Signals_WriteFloat	AO
Arm_Signals_MultiRead	DO
Arm_Signals_MultiWrite	DO

신호 타입 값

C 상수	값	설명
ARM_SIGNAL_DI	1	디지털 입력
ARM_SIGNAL_DO	2	디지털 출력
ARM_SIGNAL_UI	3	전용 입력
ARM_SIGNAL_UO	4	전용 출력
ARM_SIGNAL_RI	5	원격 입력
ARM_SIGNAL_RO	6	원격 출력
ARM_SIGNAL_GI	7	그룹 입력
ARM_SIGNAL_GO	8	그룹 출력
ARM_SIGNAL_TAI	9	손목 아날로그 입력
ARM_SIGNAL_TDI	10	손목 디지털 입력
ARM_SIGNAL_TDO	11	손목 디지털 출력
ARM_SIGNAL_AI	12	아날로그 입력
ARM_SIGNAL_AO	13	아날로그 출력

항목	규칙
signalType	ARM_SIGNAL_DI , ARM_SIGNAL_DO , ARM_SIGNAL_AI , ARM_SIGNAL_AO 등 신호 타입 값을 사용합니다.
index	컨트롤러 측 포트 번호이며, 컨트롤러의 실제 번호 그대로 전달합니다.
WriteInt	정수형 출력에 사용합니다. 지원하지 않는 신호 타입은 UNSUPPORTED_SIGNAL_TYPE 을 반환합니다.
WriteFloat	아날로그 출력에 사용합니다. 지원하지 않는 신호 타입은 UNSUPPORTED_SIGNAL_TYPE 을 반환합니다.
MultiRead	outValues + maxCount + outCount 로 일괄 값을 반환합니다. 현재는 DO 만 지원합니다.
MultiWrite	ioList 는 평탄화 배열이며 [port, value, port, value] 형식으로 전달합니다.
TriggerIOWithIntervals	입력 포트와 시간 간격에 따라 출력 포트 펄스를 트리거합니다. pulseDuration 단위는 밀리초입니다.

실패 기준:

시나리오	반환
신호 타입이 지원 범위에 없음	UNSUPPORTED_SIGNAL_TYPE
portList 가 비어 있거나 portCount 가 0	INVALID_PARAMETER
Arm_Signals_MultiRead() 출력 용량 부족	BUFFER_TOO_SMALL
ioList 가 비어 있거나, 요소 수가 홀수이거나, ioCount 가 0	INVALID_PARAMETER
intervals / outPorts 가 비어 있거나 개수가 0	INVALID_PARAMETER

Arm_Signals_TriggerIOWithIntervals() 는 intervals 에 지정된 시간 간격에 따라 outPorts 출력 펄스를 트리거합니다. pulseDuration 은 각 출력 펄스의 지속 시간을 의미합니다.

최소 호출 예제

#include <stdio.h>  // DI 값을 출력하기 위한 printf
#include "c_arm_api.h"  // C99 SDK 최상위 헤더
int main(void)  // 예제 프로그램 진입점
{  // 예제 main 함수 시작
    ArmHandle* h = Arm_Create();  // C99 세션 핸들 생성
    double value = 0.0;  // 단일 포인트 읽기 출력 변수 준비
    if (h == NULL) {  // 핸들 생성 실패 여부 확인
        return 1;  // 생성 실패 시 종료
    }  // 핸들 확인 종료
    if (Arm_Connect(h, "10.27.1.2", "10.27.1.102") != 0) {  // 컨트롤러 연결
        Arm_Destroy(h);  // 연결 실패 시 핸들 해제
        return 1;  // 오류 반환
    }  // 연결 확인 종료
    int ret = Arm_Signals_Read(h, ARM_SIGNAL_DI, 0, &value);  // DI0 읽기
    printf("di0=%f\n", value);  // DI0 값 출력
    Arm_Disconnect(h);  // 연결 해제
    Arm_Destroy(h);  // 핸들 해제
    return ret == 0 ? 0 : 1;  // 읽기 결과에 따라 반환
}  // 예제 main 함수 종료

시나리오 예제

단일 포인트 및 일괄 읽기

double diValue = 0.0;  // 단일 포인트 DI 출력 변수 준비
int ports[2] = {0, 1};  // DO 읽기 포트 목록 준비
int values[2] = {0};  // 일괄 읽기 출력 배열 준비
size_t outCount = 0U;  // 실제 출력 개수를 받을 변수 준비
int readRet = Arm_Signals_Read(h, ARM_SIGNAL_DI, 0, &diValue);  // 단일 포인트 DI 읽기
int multiRet = Arm_Signals_MultiRead(h, ARM_SIGNAL_DO, ports, 2, values, 2, &outCount);  // DO 일괄 읽기
(void)readRet;  // 예제에서 단일 포인트 읽기 상태 코드 보관
(void)multiRet;  // 예제에서 일괄 읽기 상태 코드 보관

쓰기 및 트리거

int ioList[4] = {1, 1, 2, 0};  // 일괄 쓰기 평탄화 배열 준비: DO1=1, DO2=0
int intervals[2] = {100, 200};  // 트리거 간격 준비, 단위는 컨트롤러 인터페이스 정의를 따름
int outPorts[2] = {1, 2};  // 출력 포트 목록 준비
/* int writeIntRet = Arm_Signals_WriteInt(h, ARM_SIGNAL_DO, 1, 1); */  // DO 쓰기는 출력 상태를 변경하므로 확인 후 실행
/* int writeFloatRet = Arm_Signals_WriteFloat(h, ARM_SIGNAL_AO, 1, 1.5); */  // AO 쓰기는 아날로그 출력을 변경하므로 확인 후 실행
/* int multiWriteRet = Arm_Signals_MultiWrite(h, ARM_SIGNAL_DO, ioList, 4); */  // DO 일괄 쓰기, 확인 후 실행
/* int triggerRet = Arm_Signals_TriggerIOWithIntervals(h, 0, intervals, 2, outPorts, 2, 50); */  // IO 펄스 트리거, 확인 후 실행

예제 코드

c99/signals_basic/src/main.cpp

#include <stdio.h>

extern "C" {
#include "c_arm_api.h"
}

int main(void)
{
    // [ZH] 本示例直接在源码中写死连接地址，不解析命令行参数。
    // [EN] This example hard-codes the connection addresses in the source code and does not parse command-line arguments.
    // [ZH] 创建并连接 SDK 句柄。
    // [EN] Create the SDK handle and connect to the robot.
    ArmHandle* handle = Arm_Create();
    if (handle == NULL) {
        printf("[c99_signals] 创建句柄失败 / Failed to create the handle\n");
        return 1;
    }
    int ret = Arm_Connect(handle, "10.27.1.2", "10.27.1.102");
    if (ret != 0) {
        printf("[c99_signals] 连接失败 / Connect failed, 状态码 / Status code: %d\n", ret);
        Arm_Destroy(handle);
        return 1;
    }
    printf("[c99_signals] 机器人连接成功 / Robot connected successfully\n");

    // [ZH] 读取单路信号与批量信号。
    // [EN] Read a single signal and a batch of signals.
    double diValue = 0.0;
    int ports[2] = {0, 1};
    int values[2] = {0, 0};
    size_t outCount = 0U;
    ret = Arm_Signals_Read(handle, ARM_SIGNAL_DI, 0, &diValue);
    printf("[c99_signals] Read 状态码 / Read status code: %d, DI[0]=%.6f\n", ret, diValue);
    ret = Arm_Signals_MultiRead(handle, ARM_SIGNAL_DI, ports, 2U, values, 2U, &outCount);
    printf("[c99_signals] MultiRead 状态码 / MultiRead status code: %d, 数量 / Count: %zu, 值 / Values: [%d, %d]\n",
        ret,
        outCount,
        values[0],
        values[1]);

    // [ZH] 顺序执行全部写接口。
    // [EN] Execute all write APIs in sequence.
    ret = Arm_Signals_WriteInt(handle, ARM_SIGNAL_DO, 1, 1);
    printf("[c99_signals] WriteInt 状态码 / WriteInt status code: %d\n", ret);
    ret = Arm_Signals_WriteFloat(handle, ARM_SIGNAL_AO, 1, 1.5);
    printf("[c99_signals] WriteFloat 状态码 / WriteFloat status code: %d\n", ret);
    int ioList[4] = {4, 1, 6, 0};
    ret = Arm_Signals_MultiWrite(handle, ARM_SIGNAL_DO, ioList, 4U);
    printf("[c99_signals] MultiWrite 状态码 / MultiWrite status code: %d\n", ret);
    int intervals[2] = {100, 200};
    int outPorts[2] = {4, 5};
    ret = Arm_Signals_TriggerIOWithIntervals(handle, 1, intervals, 2U, outPorts, 2U, 60);
    printf("[c99_signals] TriggerIOWithIntervals 状态码 / TriggerIOWithIntervals status code: %d\n", ret);

    // [ZH] 断开连接并销毁句柄。
    // [EN] Disconnect and destroy the handle.
    Arm_Disconnect(handle);
    Arm_Destroy(handle);
    printf("[c99_signals] 示例结束 / Example finished\n");
    return 0;
}