[내장형]박춘우_2011년 10월 17일 월요일 DailyReport

Linux Serial Port Programming

Serial 은 1 bit 씩 데이터 송수신하는 통식 방식이다. 전송 속도가 느리지만 케이블이 단순하여 구현하기 쉽고 가격이 저렴하다. 이러한 Serial 통신을 리눅스에서 접근하여 통신을 해보자. 사용환경은 VMplayer 을 이용하여 리눅스를 사용하고 있으며, 윈도우의 가상 포트를 생성하여 연결하도록 한다. 가상 포트를 생성하는 방법은 추후에 다루기로 하고 우선 리눅스에서 Serial 을 접근하는 방법에 대해 알아보자.

리눅스는 장치들을 파일로 취급하며, 보통 파일 함수 (ex> open 함수) 들을 통해 읽거나 쓴다. 이러한 장치들은 /dev 디렉토리에 저장되어 있으며 Serial 의 장치 역시 /dev 저장되어 있다. Serial 포트 번호와 장치명을 살펴보면 다음과 같다.

COM1 -> /dev/ttyS0
COM2 -> /dev/ttyS1
COM3 -> /dev/ttyS2
          ...

포트번호와 장치명의 뒤의 번호가 서로 어긋나는 것을 주의하자.

터미널 인터페이스를 제어하기 위한 termios 구조체를 이용한다. termios 는 POSIX 가 지정한 표준 인터페이스이다. 구조체와 함수들은 termios.h 에 정의되어 있다. 터미널을 제어하기 위한 입력, 출력, 제어, 로컬, 특수 제어 문자 모드가 있다. 자세한 내용은 예제를 통해 살펴보도록 하고 그전에 Serial 통신을 하기 위해 기본적인 설정을 해보자.

<Serial 통신을 위한 설정>

Serial 통신을 하기 위해 기본적인 설정을 해보자. 실습을 하기 위한 방법으로 VMplayer 을 이용하여 리눅스에서 윈도우 가상 포트를 생성하여 연결한다. 따라서 윈도우 가상 포트를 생성해야한다.
Eltima Software Virtual Serial Port Driver 프로그램을 이용하여 가상 포트를 생성한다. 프로그램을 실행한 후에 다음과 같이 가상 포트를 만든다.

임의로 COM10 과 COM11 을 가상 포트 만들기로한다. 설정한 후 COM10 과 COM11을 선택한 후에 Add pair 버튼을 누르자.

다음은 Multi Flexing 방법을 사용하기 위해 가상 포트를 하나 더 만들어두자.

COM12 와 COM13 으로 가상 포트를 역시 위의 방법으로 추가하자.

추가가 끝이나면 VMPlayer 의 설정을 해줘야 하므로 리눅스가 켜져 있다면 리눅스를 종료 또는 VMPlayer 의 Suspend 기능을 이용하여 VMPlayer 를 종료를 한 후 다시 실행하자. 이렇게 하는 이유는 가상 포트를 생성하였지만 인식을 하지 못하기 때문에 다시 실행하여 인식을 시켜주기 위함이다.

리눅스의 VMPlayer 의 셋팅을 선택한 후에 다음과 같이 설정하자.

Serial Port 를 COM10 으로 설정하고 연결이 되도록 설정한다.

다음은 Multi Flexing 에서 사용하기 위해 하나 더 연결하자.

Serial Port2 에 COM12 로 설정하고 연결 하자.

리눅스와 윈도우의 가상포트를 이용한Serial 통신을 하기 위한 기본 설정은 끝이 났다. 윈도우의 하이퍼터미널만 설정하면 된다. 하이퍼터미널은 예제를 살펴보면서 알아보도록 하자.

Serial 의 장치와 터미널 인터페이스를 제어하여 Serial 통신을 할 수 있다. 이 때 Serial 통신의 프로그래밍 기법으로 크게 Canonical, Non-Canonical, Asynchronous, Multu Flexing 4 가지 방식이 있다. 차례대로 알아보자.

1. Canonical

---

터미널의 기본 처리 방법으로 Canonical 모드 또는 Standard 모드라고도 한다. 모든 입력이 줄 단위로 처리한다. 한 줄의 의미는 다음과 같다.

NL (New Line, ASCII는 LF)
EOF (End of File)
EOL (End of Line) 에 의해 종료되는 문자열

사용자가 Enter 를 눌러야 입력을 받아들인다. 여기서 주의 해야할 점은 Enter 문자는 리눅스에서 ASCII 에서 CR (Carrige Return) 이 아니라 LF (Line Feed) 임을 알아야 한다. 다시 말해 리눅스는 라인피드를 주의 끝으로 간주한다. 반면 MS-DOS 는  캐리지 리턴과 라인피드를 하나의 쌍으로 사용한다. 만일 입력 장치 또는 출력 장치가 캐리지 리턴도 전송하거나 요구하는 경우에는 리눅스 터미널에서 적절히 처리해 준다.

Canonical 방식을 이용한 Serial 통신을 구현해보자.

< 소스 코드 >

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>

#define SPEED B19200
#define SPORT "/dev/ttyS0"

int main()
{
	// 수신용 버퍼
	char cBuff[255];
	// 장치 디스크립션
	int iDev = 0;
	int iRet = 0;
	
	struct termios stOldState;
	struct termios stNewState;

	iDev = open(SPORT, O_RDWR | O_NOCTTY);

	if( 0 > iDev )
	{
		perror(SPORT);
		exit(-10);
	}
	
	tcgetattr(iDev, &stOldState);
	bzero(&stNewState, sizeof(stNewState));

	stNewState.c_cflag = SPEED | CRTSCTS | CS8 | CLOCAL | CREAD;

	stNewState.c_iflag = IGNPAR | ICRNL;
	stNewState.c_oflag = 0;
	// Canonical
	stNewState.c_lflag = ICANON;

	bzero(stNewState.c_cc, NCCS);
	// Canonical
	stNewState.c_cc[VMIN] = 1;
	
	tcflush(iDev, TCIFLUSH);
	tcsetattr(iDev, TCSANOW, &stNewState);

	while(1)
	{
		iRet = read(iDev, cBuff, 255);
		cBuff[iRet-1] = 0;
		printf("[%s]:[%d]\n", cBuff, iRet);
	}	

	tcsetattr(iDev, TCSANOW, &stOldState);
	
	close(iDev);
	
	return 0;
}

위의 소스코들 분석을 해보자. 전체적인 흐름을 살펴보면서 분석하도록 하자.

1) 변수 선언

#define SPEED B19200

B19200 으로 define 되어 있다. 이는 터미널 속도를 정의하였다. B 는 통신 속도 단위인 Baud 를 의미한다. 19200 은 전송 속도를 의미한다. 표준으로 다음과 같이 설정값을 가질 수 있다.

B0 -> 터미널 연결을 끊는다.
B1200
B2400
B9600
B19200
B38400

표준이 아닌 리눅스에서 더 빠른 속도를 지원한다. ex) B57600, B115200, B230400

#define SPORT "/dev/ttyS0"

"/dev/ttyS0" 는 장치의 경로를 의미하며 문자열로 define 하였다. 앞서 ttyS0 은 COM1 을 의미하는 것을 살펴보았다.

struct termios stOldState;
struct termios stNewState;

termios 구조체를 선언하였다. 구조체의 내부는 다음과 같이 구성되어 있다.

struct termios
{
	tcflag_t c_iflag;	
	tcflag_t c_oflag;	
	tcflag_t c_cflag;	
	tcflag_t c_lflag;	
	cc_t c_line;	
	cc_t c_cc[NCCS];
};

termios 구초체는 bits/termios.h 에 정의 되어 있다. termios 구조체 멤버는 차례대로 입력 모드, 출력 모드, 제어 모드, 로컬 모드, 특수 제어 모드로 구성되어 있다. c_line 멤버는 POSIX 호환 시스템에서 사용되지 않음을 유의하자. 구조체 멤버의 자료형 타입과 특수 제어 모드의 c_cc 배열의 NCCS 의 크기는 다음과 같이 정의되어 있다.

typedef unsigned char cc_t;
typedef unsigned int tcflag_t;
#define NCCS 32

2) 장치 열기

iDev = open(SPORT, O_RDWR | O_NOCTTY);

if( 0 > iDev )
{	
	perror(SPORT);	
	exit(-10);
}

장치를 열기위해 open 함수를 사용한다. 인자를 살펴보면 SPORT 는 장치의 경로를 문자열로 define 해 놓은 것이다. 다음 인자는 옵션을 설정한다. O_RDWR 은 읽기쓰기 옵션을 의미한다. O_NOCTTY 는 장치가 현재 terminal을 제어하지 못하도록 하는 옵션이다. 장치가 잘 열렸는지 에러를 체크한 후에 에러가 발생하면 perror 함수를 통해 에러를 출력한다.

3) 현재 터미널 설정 값 저장

tcgetattr(iDev, &stOldState);

tcgetattr() 함수는 현재 터미널에 설정된 값을 얻기위해 사용한다. 현재의 터미널의 설정 값을 유지하기 위해 stOldState 구조체에 저장해 둔다.

4) Serial 통신 설정을 위한 termios 구조체에 값을 할당 후 터미널 인터페이스 적용

bzero(&stNewState, sizeof(stNewState));

bzero() 함수를 이용하여 stNewState 구조체를 0 으로 초기화한다. bzero() 함수는 해당 메모리에 0 으로 초기화 해주는 함수로 memset() 함수의 wrapper 함수이다. wrapper 함수는 사용자에게 사용하기 편리하도록 특정 기능을 간단하게 사용할 수 있도록 만들어 놓은 함수를 의미한다. bzero() 함수를 예를 들면 위의 코드는 memset(&stNewState, 0, sizeof(stNewState)); 과 동일하다. 다시말해 bzero() 함수 내부에는 결국 memset() 함수를 호출한다. 하지만 memset 은 인자가 3 개를 넣어야하는 번거로움을 덜어주는 것이 bzero() 함수이다. 다만 0 으로 초기화 하는 특정기능만 사용할 수 있다.

stNewState.c_cflag = SPEED | CRTSCTS | CS8 | CLOCAL | CREAD;

구조체 멤버에 값을 넣어준다. c_cflag 멤버는 제어모드로 터미널의 하드웨어적 특성을 제어한다.

SPEED
앞서 define 되어있는 전송 속도 (B19200) 를 의미한다.

CRTSCTS
RTS/CTS 흐름제어를 활성화 한다는 의미이다. RTS/CTS 는 Request to Send and Clear to Send (송신 요구/수신 가능) 의 의미이며 데이터를 손실이 발생하지 않도록 제어하는 통신 매커니즘이다 자세한 내용은 복잡하므로 생략한다.

CS8
송/수신 데이터를 8 bit 를 사용한다는 의미이다.

CLOCAL
모든 모뎀 상태 회선을 무시한다는 의미로 모뎀 접속이 아님을 명시한다.

CREAD
문자 수신을 활성화하는 것이다.

stNewState.c_iflag = IGNPAR | ICRNL;

c_iflag 멤버는 입력모드로 입력이 프로그램에 전달되기 전에 처리되는 방식을 결정한다.

IGNPAR
패리티 (parity) 오류가 있는 문자들을 무시한다.

ICRNL
CR 문자를 NL 문자로 변환한다.

stNewState.c_oflag = 0;

c_oflag 멤버는 출력 모드로 프로그램이 보낸 문자들이 직렬포트나 화면으로 전달되기 전에 처리되는 방식을 결정한다. 자주 쓰이지는 않는다. 0 으로 설정한다.

stNewState.c_lflag = ICANON;

c_lflag 멤버는 로컬 모드로 터미널의 다양한 특성을 제어한다. ICANON 는 Canonical 모드를 설정하도록 한다.

bzero(stNewState.c_cc, NCCS);
stNewState.c_cc[VMIN] = 1;

c_cc 멤버는 특수 제어 문자로 Ctrl + C 와 같이 특별한 행동을 하는 키 입력을 의미한다. c_cc 멤버는 배열로 구성되어 있으며 특수 행동에 연관된 문자들이 들어 있다. 배열의 인덱스마다 각각 문자들이 있으며 문자들은 매크로로 정의되어 있다.

/* c_cc characters */
#define VINTR		0
#define VQUIT		1
#define VERASE		2
#define VKILL		3
#define VEOF		4
#define VTIME		5
#define VMIN		6
#define VSWTC		7
#define VSTART		8
#define VSTOP		9
#define VSUSP		10
#define VEOL		11
#define VREPRINT	12
#define VDISCARD	13
#define VWERASE		14
#define VLNEXT		15
#define VEOL2		16

VMIN 은 읽을 때 최소 문자 개수를 설정한다. 1 설정하였으므로 문자 하나만 읽는다.

tcflush(iDev, TCIFLUSH);

Serial 포트의 수신 큐를 초기화 한다. TCIFLUSH 는 읽지 않아도 수신 버퍼를 초기화한다.

tcsetattr(iDev, TCSANOW, &stNewState);

Serial 통신을 하기 위한 설정을 끝낸 stNewState 구조체를 터미널 인터페이스에 적용시킨다. TCSANOW 는 값들을 즉시 변경시키도록 한다.

5) 수신된 데이터 읽기

iRet = read(iDev, cBuff, 255);
cBuff[iRet-1] = 0;
printf("[%s]:[%d]\n", cBuff, iRet);

Serial 통신으로 수신된 데이터를 읽어 콘솔창으로 출력한다. 결국 이 예제는 통신으로 데이터를 출력하는 기능을 가지는 것이다.

6) 초기의 터미널 설정으로 변경

tcsetattr(iDev, TCSANOW, &stOldState);

이전에 터미널 설정 값을 저장한 이유는 원래의 설정으로 되돌리기 위함이다. [3) 현재 터미널 설정 값 저장] 에서 저장한 stOldState 구조체를 이용해 원래의 설정으로 되돌린다.

7) 장치 닫기

close(iDev);

시작을 했으면 끝이 있는 법이므로 장치를 열었으니 모든 작업이 끝이나면 반드시 장치를 닫아준다.

실행 결과를 살펴보기 앞서 하이퍼터미널을 열어서 설정해보자.

<하이퍼터미널 설정>

하이퍼터미널을 실행하여 새 연결을 해보자.

가상 포트로 만들었던 COM11 을 선택하자.

COM11 의 연결 설정에서 속도를 코드상에서 설정했던 것과 같은 19200 로 설정하자.
설정 후 속성에서 [설정]-[ASCII] 설정에서 입력된 문자를 터미널에 출력을 체크해 놓으면 알아보기 쉽다.

실행결과를 살펴보자.

<실행 결과>

왼쪽 하얀부분은 하이퍼터미널에서 입력한 문자들이다. 오른쪽은 하이퍼터미널에서 전송받아 출력된 리눅스의 콘솔창이다. 123456789 를 입력하고 엔터를 누르면 리눅스 콘솔창에 123456789 가 그대로 출력된다. 결국 엔터를 눌러야만 출력한다.
참고 : 편의상 소스코드에서 [ 5) 수신된 데이터 읽기 ] 부분에 while 문을 사용하여 무한루프로 출력한 결과이다.

2. Non-Canonical

---

한 번에 정해진 크기를 처리를 한다. Canonical 는 한 라인을 처리하는 것에 비해 자유도가 크다. 타이머를 사용하여 대기 시간을 설정할 수 있다.

Non-Canonical 방식을 이용한 Serial 통신을 구현해보자.

<소스 코드>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>

#define SPEED B19200
#define SPORT "/dev/ttyS0"

int main()
{
	// 수신용 버퍼
	char cBuff[255];
	// 장치 디스크립션
	int iDev = 0;
	int iRet = 0;
	
	struct termios stOldState;
	struct termios stNewState;

	iDev = open(SPORT, O_RDWR | O_NOCTTY);

	if( 0 > iDev )
	{
		perror(SPORT);
		exit(-10);
	}
	
	tcgetattr(iDev, &stOldState);
	bzero(&stNewState, sizeof(stNewState));

	stNewState.c_cflag = SPEED | CRTSCTS | CS8 | CLOCAL | CREAD;

	stNewState.c_iflag = IGNPAR | ICRNL;
	stNewState.c_oflag = 0;

	// Non-Canonical
	stNewState.c_lflag = 0;
	
	bzero(stNewState.c_cc, NCCS);
	
	// Non-Canonical
	stNewState.c_cc[VTIME] = 0;
	stNewState.c_cc[VMIN] = 0;
	tcflush(iDev, TCIFLUSH);
	tcsetattr(iDev, TCSANOW, &stNewState);

	while(1)
	{
		iRet = read(iDev, cBuff, 255);
		cBuff[iRet-1] = 0;
		printf("[%s]:[%d]\n", cBuff, iRet);
	}	

	tcsetattr(iDev, TCSANOW, &stOldState);
	
	close(iDev);
	
	return 0;
}

소스 코드를 분석해보자. 대부분 앞서 분석하였던 Canonical 방식과 동일하므로 차이가 있는 부분만 분석하고 전체적인 흐름을 살펴보자. 세부 내용이 없는 부분은 Canonical 부분을 참조하도록 하자.

1) 변수 설정
2) 장치 열기
3) 현재 터미널 설정 값 저장
4) Serial 통신 설정을 위한 termios 구조체에 값을 할당 후 터미널 인터페이스 적용

stNewState.c_cflag = SPEED | CRTSCTS | CS8 | CLOCAL | CREAD;
stNewState.c_iflag = IGNPAR | ICRNL;
stNewState.c_oflag = 0;

// Non-Canonical
stNewState.c_lflag = 0;

bzero(stNewState.c_cc, NCCS);	

// Non-Canonical
stNewState.c_cc[VTIME] = 0;
stNewState.c_cc[VMIN] = 5;

tcflush(iDev, TCIFLUSH);
tcsetattr(iDev, TCSANOW, &stNewState);

하얀 부분으로 칠해진 부분이 수정 및 추가된 부분이다. 나머지는 동일하다. Non-Canonical 이므로 c_lflag 멤버에 ICANON 을 할당하지 않는다.
Non-Canonical 은 타이머를 사용할 수 있으므로 c_cc 멤버 배열의 VTIME 인덱스에 시간을 설정할 수 있다. c_cc[VTIME] 에 0 을 할당하면 문자 입력까지 무한 대기를 한다.
c_cc[VMIN] 은 최소 문자를 처리할 값이므로 5 을 할당하면 최소 5 문자를 받을 때 까지 블록킹되어 있다.

Non-Canonical 은 VTIME 과 VMIN 을 이용하여 4 가지의 상태를 조합할 수 있다.

VMIN > 0 , VTIME = 0 인 경우
문자가 들어오기 전까지 무한 대기한 후 문자가 들어오면 처리한다.

VMIN = 0, VTIME > 0 인 경우
VTIME 은 타임아웃 값으로 사용되며 타임아웃은 VTIME * 0.1초 의 시간이다. 타임아웃이 발생하기 전에 하나의 문자만 들어오면 처리한다. 타임아웃이 되면 처리한다.

VMIN > 0, VTIME >0 인 경우
VTIME 은 문자가 들어온 후 타이머가 작동하며 해당 시간 후에 처리한다. 문자가 들어온 후 새롭게 문자가 들어오면 타이머는 초기화되어 다시 시간을 측정한다. 문자가 들어오지 않으면 처리한다. 해당 시간 동안 문자가 문자가 입력되지 않으면 무한 대기를 한다.

VMIN = 0, VTIME = 0 인 경우
프로그램 실행과 동시에 처리한다.

5) 수신된 데이터 읽기
6) 초기의 터미널 설정으로 변경
7) 장치 닫기

하이퍼터미널은 앞서 설명하였으므로 생략하고 실행 결과를 살펴보자. 실행결과의 그림에서 하얀부분은 하이퍼터미널이며 검은부분은 리눅스 콘솔창이다. 또한 소스 코드에 [ 5) 수신된 데이터 읽기 ] 부분에 while 문으로 무한반복을 하여 테스트 하였다.

<실행 결과>

1) VMIN > 0 , VTIME = 0 인 경우

VMIN 값으로 5 로 설정하였다.

2) VMIN = 0, VTIME > 0 인 경우

VTIME 은 5 로 설정하였다.

3) VMIN > 0, VTIME >0 인 경우

VMIN 과 VTIME 값은 5 로 설정하였다.

4) VMIN = 0, VTIME = 0 인 경우

실행과 동시에 처리한다.

3. Asynchronous

---

read 의 조건이 만족될 때까지 블록되는 방식으로 대부분의 API 에 디폴트로 설정되어 있다. 호출한 프로그램에 signal 을 전송하며 전송된 signal 에서 signal handler 를 처리한다.

Asynchronous 방식을 이용한 Serial 통신을 구현해보자.

<소스 코드>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/signal.h>

#define SPEED B19200
#define SPORT "/dev/ttyS0"

void Handle_Serial_Sig(int);

volatile int iBreak = 0;

int main()
{
	// 수신용 버퍼
	char cBuff[255];
	// 장치 디스크립션
	int iDev = 0;
	int iRet = 0;
	
	struct termios stOldState;
	struct termios stNewState;
	struct sigaction stSigAct;
	
	iDev = open(SPORT, O_RDWR | O_NOCTTY);

	if( 0 > iDev )
	{
		perror(SPORT);
		exit(-10);
	}
		
	bzero(&stSigAct, sizeof(stSigAct));
	stSigAct.sa_handler = Handle_Serial_Sig;
	sigaction(SIGIO, &stSigAct, NULL);

	fcntl(iDev, F_SETOWN, getpid());
	fcntl(iDev, F_SETFL, FASYNC);
	
	tcgetattr(iDev, &stOldState);
	bzero(&stNewState, sizeof(stNewState));
	
	stNewState.c_cflag = SPEED | CRTSCTS | CS8 | CLOCAL | CREAD;

	stNewState.c_iflag = IGNPAR | ICRNL;
	stNewState.c_oflag = 0;
	stNewState.c_lflag = ICANON;
	stNewState.c_cc[VMIN] = 1;
	stNewState.c_cc[VTIME] = 0;
	
	tcflush(iDev, TCIFLUSH);
	tcsetattr(iDev, TCSANOW, &stNewState);

	while(1)
	{
		if(1 == iBreak)
		{
			iRet = read(iDev, cBuff, 255);
			cBuff[iRet] = 0;
			printf("[%s]:[%d]\n", cBuff, iRet);
			break;
		}
		else
		{
			sleep(2);
		}
		printf("Go Sleep\n");
	}	

	tcsetattr(iDev, TCSANOW, &stOldState);
	
	close(iDev);
	
	return 0;
}

void Handle_Serial_Sig(int Arg)
{
	printf("Receive SIGIO Signal\n");
	iBreak = 1;
}

소스 코드를 분석해보자. 역시 앞에서 설명한 부분은 생략하고 다른 부분만 살펴보자.

1) 변수 설정

struct termios stOldState;
struct termios stNewState;
struct sigaction stSigAct;

하얀 부분이 추가된 부분이다. 이 구조체는 sys/signal.h 에 정의되어 있으며 사용하기 위해서는 include 해야한다.

2) 장치 열기

iDev = open(SPORT, O_RDWR | O_NOCTTY | O_NONBLOCK);

장치를 열 때의 O_NONBLOCK 옵션이 하나 더 추가되었다. O_NONBLOCK 은 블록킹을 하지 않도록 하는 옵션이다.

3) signal 설정

bzero(&stSigAct, sizeof(stSigAct));

stSigAct.sa_handler = Handle_Serial_Sig;
sigaction(SIGIO, &stSigAct, NULL);

stSigAct 구조체를 0 으로 초기화 한다. 그후에 stSigAct 구조체의 sa_handler 멤버에 인터럽트가 발생했을 때 처리할 서비스 루틴을 지정해준다.
sigaction() 함수는 해당 시그널과 stSigAct 구조체를 연결하고 리눅스에 등록한다. 이 때 SIGIO 는 입출력에 대한 시그널을 의미한다. SIGIO 과 같이 시그널의 종류는 bit/signum.h 에 정의 되어있다.

fcntl(iDev, F_SETOWN, getpid());fcntl(iDev, F_SETFL, FASYNC); 

시그널을 수신할 수 있도록 해당 프로세스에 설정해준다. F_SETOWN 은 SIGIO 시그널이 발생하면 해당 프로세스 그룹에 전달하도록 하는 명령이다.
다음은 장치를 비동기로 설정한다. F_SETFL 은 3 번째 인자에 지정한 값을 장치에 적용시키는 명령이다. O_APPEND, O_NONBLOCK, O_ASYNC 만 설정이 가능하며 다른 플래그를 사용하면 영향을 받지 않는다. FASYNC 는 O_ASYNC 와 같은 의미이다.

4) 현재 터미널 설정 값 저장
5) Serial 통신 설정을 위한 termios 구조체에 값을 할당 후 터미널 인터페이스 적용
6) 수신된 데이터 읽기

while(1)
{	
	if(1 == iBreak)	
	{		
		iRet = read(iDev, cBuff, 255);
		cBuff[iRet] = 0;	
		printf("[%s]:[%d]\n", cBuff, iRet);	
		break;	
	}	
	else	
	{		
		sleep(2);	
	}	
	printf("Go Sleep\n");
}

SIGIO 시그널에 의해 입출력이 발생하면 인터럽트가 발생하여 리눅스가 다음 함수를 호출한다.

void Handle_Serial_Sig(int Arg)
{	
	printf("Receive SIGIO Signal\n");	
	iBreak = 1;
}

Handle_Serial_Sig() 함수가 호출되면 iBreak 값으 1 로 변경 시킨다. 이 때 iBreak 는 전역변수로 선언되어 있다. 1 로 변경이 되면 read 함수를 호출하여 장치를 읽어 출력한 후 프로그램이 종료된다. 만약 Handle_Serial_Sig() 함수가 호출되지 않았다면 sleep 함수에 의해 계속 대기 하고 있다.

7) 초기의 터미널 설정으로 변경
8) 장치 닫기

출력 결과를 살펴보자.

<출력 결과>

Go Sleep 이 출력되는 경우는 SIGIO 시그널이 발생하지 않은 상태이다. 123456789 를 누르고 엔터를 입력하는 순간 SIGIO 시그널이 발생하게 되고 인터럽트가 발생한다. Receive SIGIO Signal 을 출력을 통해 인터럽트가 발생했음을 알 수 있다.

4. Multi-Flexing

---

여러 장치를 다루기 위해서 사용하면 유용하다. 하지만 개념이 복잡한 단점이 존재한다. select() 를 사용하여 입력을 기다리는 동안에 CPU 에 부하를 주지 않는다.

 Multi-Flexing 방식을 이용한 Serial 통신을 구현해보자.

<소스 코드>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/signal.h>

#define SPEED B19200
#define COMPORT1 "/dev/ttyS0"
#define COMPORT2 "/dev/ttyS1"

void Input_Incomming(int);

char cBuff[255];

volatile int iBreak = 0;

int main()
{
	// 장치 디스크립션
	int iMaxFD = 0;
	int iCom1 = 0;
	int iCom2 = 0;
	
	struct termios stOldSt1;
	struct termios stOldSt2;
	struct termios stNewSt1;
	struct termios stNewSt2;

	fd_set stRFd;
	
	iCom1 = open(COMPORT1, O_RDWR | O_NOCTTY);

	if( 0 > iCom1 )
	{
		perror(COMPORT1);
		exit(-10);
	}
	
	iCom2 = open(COMPORT2, O_RDWR | O_NOCTTY);

	if( 0 > iCom2 )
	{
		perror(COMPORT2);
		exit(-100);
	}

	tcgetattr(iCom1, &stOldSt1);
	tcgetattr(iCom2, &stOldSt2);
	
	bzero(&stNewSt1, sizeof(stNewSt1));

	stNewSt1.c_cflag = SPEED | CRTSCTS | CS8 | CLOCAL | CREAD;
	stNewSt1.c_iflag = IGNPAR | ICRNL;
	stNewSt1.c_oflag = 0;
	stNewSt1.c_cc[VMIN] = 1;
	
	stNewSt2 = stNewSt1;

	tcflush(iCom1, TCIFLUSH);
	tcsetattr(iCom1, TCSANOW, &stNewSt1);
	tcflush(iCom2, TCIFLUSH);
	tcsetattr(iCom2, TCSANOW, &stNewSt2);

	iMaxFD = iCom2 + 1;

	while(1)
	{
		//Set Descriptor
		FD_ZERO(&stRFd);
		FD_SET(iCom1, &stRFd);
		FD_SET(iCom2, &stRFd);

		// block until input
		select(iMaxFD, &stRFd, NULL, NULL, NULL);

		if(FD_ISSET(iCom1, &stRFd))
		{
			Input_Incomming(iCom1);
		}
		if(FD_ISSET(iCom2, &stRFd))
		{
			Input_Incomming(iCom2);
		}
	}	

	tcsetattr(iCom1, TCSANOW, &stOldSt1);
	tcsetattr(iCom2, TCSANOW, &stOldSt2);
	
	close(iCom1);
	close(iCom2);
	
	return 0;
}

void Input_Incomming(int iPort)
{
	int iRet = read(iPort, cBuff, 255);

	cBuff[iRet] = 0;
	printf("[%s]:[%d]\n", cBuff, iRet);

	return ;
}

소스 코드를 분석해보자. 장치를 여러개 사용하기 때문에 새로운 장치가 추가 할 때마다 장치를 열어주고 사용이 끝나면 닫아야한다. 터미널 설정 또한 각각 설정을 해야한다.

1) 변수 선언

#define COMPORT1 "/dev/ttyS0"
#define COMPORT2 "/dev/ttyS1"

2 개의 장치를 사용하므로 하나 더 추가해준다. 따라서 COM1 과 COM2 를 사용하게 된다.

int iMaxFD = 0;
int iCom1 = 0;
int iCom2 = 0;	

struct termios stOldSt1;
struct termios stOldSt2;
struct termios stNewSt1;
struct termios stNewSt2;

fd_set stRFd;

iMaxFD 변수는 select() 함수에서 사용되어질 파일 디스크립트의 최대값을 가진다. 장치를 2개 사용하므로 각각 장치 디스크립트 변수와 termios 구조체도 각각 2개씩 선언한다. stRFd 변수는 나중에 select 함수를 사용하기 위해 사용된다.

2) 장치 열기
3) 현재 터미널 설정 값 저장
4) Serial 통신 설정을 위한 termios 구조체에 값을 할당 후 터미널 인터페이스 적용

bzero(&stNewSt1, sizeof(stNewSt1));

stNewSt1.c_cflag = SPEED | CRTSCTS | CS8 | CLOCAL | CREAD;
stNewSt1.c_iflag = IGNPAR | ICRNL;stNewSt1.c_oflag = 0;
stNewSt1.c_cc[VMIN] = 1;	

stNewSt2 = stNewSt1;

tcflush(iCom1, TCIFLUSH);
tcsetattr(iCom1, TCSANOW, &stNewSt1);

tcflush(iCom2, TCIFLUSH);
tcsetattr(iCom2, TCSANOW, &stNewSt2);

2개의 장치가 같은 설정을 가진다면 한번더 설정 할 필요없이 하얀 부분과 같이 장치 하나를 설정하고 난 후에 할당해 주면 된다.

5) 수신된 데이터 읽기

iMaxFD = iCom2 + 1;

while(1)
{
	//Set Descriptor
	FD_ZERO(&stRFd);
	FD_SET(iCom1, &stRFd);
	FD_SET(iCom2, &stRFd);

	// block until input
	select(iMaxFD, &stRFd, NULL, NULL, NULL);

	if(FD_ISSET(iCom1, &stRFd))
	{
		Input_Incomming(iCom1);
	}
	if(FD_ISSET(iCom2, &stRFd))
	{
		Input_Incomming(iCom2);
	}
}

iMaxFD 변수에 iCom2 + 1 을 할당하는 이유는 select 함수는 상태가 변경되는 파일 디스크립트가 생길 때까지 블록킹된다. 따라서 파일 디스크립트의 최대값이 필요로 한다. 그 값을 설정하기 위해 파일 디스크립트 중 가장 큰 값을 가지는 iCom2 의 장치의 파일 디스크립트 정수값에 1 을 더한다. iCom2 의 파일디스크립트가 가장 큰 값을 가지는 이유는 가장 나중에 열었기 때문이다.
stRFD 변수는 파일 디스크립트를 리스트로 가지고 있다. FD_ZERO() 함수는 이 리스트를 초기화 해준다. FD_SET() 함수는 해당 장치의 파일 디스크립트를 리스트에 추가한다.
select() 함수가 리스트에 변경이 있을때까지 블록킹되어 있다가 어떠한 장치 하나라도 변경이 되면 블록킹이 풀린다. 이때 어떤 장치가 변경되었는지 알 수가 없다. 이를 확인하기 위한 함수가 FD_ISSET() 함수이다. 어떤 장치가 변경되었는지 물어보고 변경되었다면 변경된 장치에 대한 처리를 해주면된다.
코드에서는 Input_Incomming() 함수를 해당 장치의 인자값을 할당하여 호출한다. 

void Input_Incomming(int iPort)
{
	int iRet = read(iPort, cBuff, 255);

	cBuff[iRet] = 0;
	printf("[%s]:[%d]\n", cBuff, iRet);

	return ;
}

Input_Incomming() 함수는 수신된 데이터를 읽고 출력하는 기능을 가진다.

6) 초기의 터미널 설정으로 변경
7) 장치 닫기

테스트를 하기 전에 하이퍼터미널을 하나 더 실행해야 함을 잊지말자. 첫 번째 하이퍼터미널과 동일한 COM11 을 사용하고 두 번째 하이퍼터미널은 COM13 을 사용하면 된다. 또한 초반에 VMPlayer 설정이 되어있어야 한다. 설정 방법은 앞서 설명하였으므로 생략한다.

실행 결과는 다음과 같다.

<실행 결과>

2 개의 하이퍼터미널에서 접속하여 출력을 하고 있다. 처음 Test 1 하이퍼터미널에서 123 을 입력하면 리눅스에서 한 문자씩 처리를 한다. Test 2 하이퍼터미널에서도 역시 321 로 입력하면 한 문자씩 처리를 한다. select 함수가 블록킹되고 있다가 어떠한 장치 하나만 입력이 되면 블록킹이 풀리면서 문자를 처리한다. 여기서 한문자씩 처리 하는 이유는 stNewSt1.c_cc[VMIN] = 1;
을 해줬기 때문이다.