3.2. Non-Canonical Input Processing 非标准输入模式
In non-canonical input processing mode, input is not assembled into lines and input
processing (erase, kill, delete, etc.) does not occur. Two parameters control the
behavior of this mode: c_cc[VTIME] sets the character timer, and c_cc[VMIN] sets
the minimum number of characters to receive before satisfying the read.
If
MIN > 0 and TIME = 0, MIN sets the number of characters to receive before
the read is satisfied. As TIME is zero, the timer is not used.
If
MIN = 0 and TIME > 0, TIME serves as a timeout value. The read will be
satisfied if a single character is read, or TIME is exceeded (t = TIME *0.1 s).
If TIME is exceeded, no character will be returned.
If
MIN > 0 and TIME > 0, TIME serves as an inter-character timer. The read
will be satisfied if MIN characters are received, or the time between two characters
exceeds TIME. The timer is restarted every time a character is received and only
becomes active after the first character has been received.
If
MIN = 0 and TIME = 0, read will be satisfied immediately. The number of
characters currently available, or the number of characters requested will be returned.
According to Antonino (see contributions), you could issue a fcntl(fd, F_SETFL, FNDELAY);
before reading to get the same result.
By modifying newtio.c_cc[VTIME] and newtio.c_cc[VMIN] all modes described above can be tested.
在非标准输入模式中，输入的数据并不组合成行，也不会进行 erase, kill, delete 等输
入处理。我们只是用两个参数来控制这种模式的输入行为： c_cc[VTIME] 设定字符输入间
隔时间的计时器，而 c_cc[VMIN] 设置满足读取函数的最少字节数。
MIN > 0, TIME = 0 ： 读取函数在读到了 MIN 值的字符数后返回。
MIN = 0, TIME > 0 ： TIME 决定了超时值，读取函数在读到一个字节的字符，或者等待读
取时间超过 TIME （t = TIME * 0.1s）以后返回，也就是说，即使没有从串口中读到数
据，读取函数也会在 TIME 时间后返回。
MIN > 0, TIME > 0 ： 读取函数会在收到了 MIN 字节的数据后，或者超过 TIME 时间没收
到数据后返回。此计时器会在每次收到字符的时候重新计时，也只会在收到第一个字节后才
启动。
MIN = 0, TIME = 0 ： 读取函数会立即返回。实际读取到的字符数，或者要读到的字符
数，会作为返回值返回。根据 Antonino（参考 conditions）, 可以使用 fcntl(fd, F_SETFL,
FNDELAY), 在读取前获得同样的结果。
改变了 nettio.c_cc[VTIME] 和 newtio.c_cc[VMIN], 就可以测试以上的设置了。
CODE
#include
#include
#include
#include
#include
#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* POSIX compliant source */
#define FALSE 0
#define TRUE 1
volatile int STOP=FALSE;
main() {
int fd,c, res;
struct termios oldtio,newtio;
char buf[255];
fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY );
if (fd <0) {perror(MODEMDEVICE); exit(-1); }
tcgetattr(fd,&oldtio); /* save current port settings */
bzero(&newtio, sizeof(newtio));
newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
newtio.c_iflag = IGNPAR;
newtio.c_oflag = 0;
/* set input mode (non-canonical, no echo,...) */
// 设置输入模式为非标准输入
newtio.c_lflag = 0;
newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
// 不是用字符间隔计时器
newtio.c_cc[VMIN] = 5; /* blocking read until 5 chars received */
//收到5个字符数以后，read 函数才返回
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);
while (STOP==FALSE) { /* loop for input */
res = read(fd,buf,255); /* returns after 5 chars have been input */
buf[res]=0; /* so we can printf... */
printf(":%s:%d\n", buf, res);
if (buf[0]=='z') STOP=TRUE;
}
tcsetattr(fd,TCSANOW,&oldtio);
3.3. Asynchronous Input 异步输入模式
CODE
#include
#include
#include
#include
#include
#include
#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* POSIX compliant source */
#define FALSE 0
#define TRUE 1
volatile int STOP=FALSE;
void signal_handler_IO (int status); /* definition of signal handler */
// 定义信号处理程序
int wait_flag=TRUE; /* TRUE while no signal received */
// TRUE 代表没有受到信号，正在等待中
main() {
int fd,c, res;
struct termios oldtio,newtio;
struct sigaction saio;
/* definition of signal action */
// 定义信号处理的结构
char buf[255];
/* open the device to be non-blocking (read will return immediatly) */
// 是用非阻塞模式打开设备 read 函数立刻返回，不会阻塞
fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd <0) {perror(MODEMDEVICE); exit(-1); }
/* install the signal handler before making the device asynchronous */
// 在进行设备异步传输前，安装信号处理程序
saio.sa_handler = signal_handler_IO;
saio.sa_mask = 0;
saio.sa_flags = 0;
saio.sa_restorer = NULL;
sigaction(SIGIO,&saio,NULL);
/* allow the process to receive SIGIO */
// 允许进程接收 SIGIO 信号
fcntl(fd, F_SETOWN, getpid());
/* Make the file descriptor asynchronous (the manual page says only
O_APPEND and O_NONBLOCK, will work with F_SETFL...) */
// 设置串口的文件描述符为异步，man上说，只有 O_APPEND 和 O_NONBLOCK 才能使用F_SETFL
fcntl(fd, F_SETFL, FASYNC);
tcgetattr(fd,&oldtio); /* save current port settings */
/* set new port settings for canonical input processing */
// 设置新的串口为标准输入模式
newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
newtio.c_iflag = IGNPAR | ICRNL;
newtio.c_oflag = 0;
newtio.c_lflag = ICANON;
newtio.c_cc[VMIN]=1;
newtio.c_cc[VTIME]=0;
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);
/* loop while waiting for input. normally we would do something
useful here 循环等待输入，通常我们会在这里做些其它的事情 */
while (STOP==FALSE) {
printf(".\n");usleep(100000);
/* after receiving SIGIO, wait_flag = FALSE, input is availableand can be read */
// 在收到 SIGIO 信号后，wait_flag = FALSE, 表示有输入进来，可以读取了
if (wait_flag==FALSE) {
res = read(fd,buf,255);
buf[res]=0;
printf(":%s:%d\n", buf, res);
if (res==1) STOP=TRUE; /* stop loop if only a CR was input */
wait_flag = TRUE; /* wait for new input 等待新的输入*/
}
}
/* restore old port settings */
tcsetattr(fd,TCSANOW,&oldtio);
}
/***************************************************************************
* signal handler. sets wait_flag to FALSE, to indicate above loop that *
* characters have been received. *
***************************************************************************/
// 信号处理函数，设置 wait_flag 为 FALSE, 以告知上面的循环函数串口收到字符了
void signal_handler_IO (int status) {
printf("received SIGIO signal.\n");
wait_flag = FALSE;
}
3.4. Waiting for Input from Multiple Sources 等待来自多个源的输入
This section is kept to a minimum. It is just intended to be a hint, and therefore
the example code is kept short. This will not only work with serial ports, but with
any set of file descriptors.
The select call and accompanying macros use a fd_set. This is a bit array, which
has a bit entry for every valid file descriptor number. select will accept a fd_set
with the bits set for the relevant file descriptors and returns a fd_set, in which
the bits for the file descriptors are set where input, output, or an exception
occurred. All handling of fd_set is done with the provided macros. See also the
manual page select(2).
这一部分的内容很少，只是作为一个提示，因此这段代码也很简短。而且这部分内容不仅适
用于串口编程，而且适用于任意的一组文件描述符。
select 调用及其相应的宏，使用 fd_set. 这是一个比特数组，其中每一个比特代表了一个
有效的文件描述符号。 select 调用接收一个有效的文件描述符结构，并返回 fd_set 比特
数组，如果此比特数组中有某一个位设为1，就表示对应的文件描述符发生了输入，输出或
者有例外事件。所有 fg_set 的处理都由宏提供了，具体参考 man select 2 。
CODE
#include
#include
#include
main()
{
int fd1, fd2; /* input sources 1 and 2 输入源 1 和 2 */
fd_set readfs; /* file descriptor set */
int maxfd; /* maximum file desciptor used用到的文件描述符的最大值 */
int loop=1; /* loop while TRUE 循环标志 */
/* open_input_source opens a device, sets the port correctly, and
returns a file descriptor */
// open_input_source 函数打开一个设备，正确设置端口，并返回文件描述符
fd1 = open_input_source("/dev/ttyS1"); /* COM2 */
if (fd1<0) exit(0);
fd2 = open_input_source("/dev/ttyS2"); /* COM3 */
if (fd2<0) exit(0);
maxfd = MAX (fd1, fd2)+1; /* maximum bit entry (fd) to test */
/* loop for input */
while (loop) {
FD_SET(fd1, &readfs); /* set testing for source 1 */
FD_SET(fd2, &readfs); /* set testing for source 2 */
/* block until input becomes available 阻塞直到有输入进来 */
select(maxfd, &readfs, NULL, NULL, NULL);
if (FD_ISSET(fd1)) /* input from source 1 available源1有输入*/
handle_input_from_source1();
if (FD_ISSET(fd2)) /* input from source 2 available 源2有输入*/
handle_input_from_source2();
}
}
The given example blocks indefinitely, until input from one of the sources becomes available. If you need to timeout on input, just replace the select call by:
这个例子会导致未知的阻塞，知道其中一个源有数据输入。如果你需要为输入设置一个超时值，就用下面的select 替代：
CODE
int res;
struct timeval Timeout;
/* set timeout value within input loop 在输入循环中设置超时值 */
Timeout.tv_usec = 0; /* milliseconds 设置毫秒数*/
Timeout.tv_sec = 1; /* seconds 设置秒数 */
res = select(maxfd, &readfs, NULL, NULL, &Timeout);
if (res==0)
/* number of file descriptors with input = 0, timeout occurred. 所有的文件描述符都没有得到输入，超时退出返回0 */
This example will timeout after 1 second. If a timeout occurs, select will return 0, but beware that Timeout is decremented by the time actually waited for input by select. If the timeout value is zero, select will return immediatly.
这个例子会在1秒以后超时退出，如果发生超时，select 返回0,请注意 Timeout 是根据select实际等待输入的时间递减的，如果把timeout 设为0， select 函数会立刻退出。
