串口操作
串口操作需要的头文件
#include /*标准输入输出定义*/
#include /*标准函数库定义*/
#
#include /*Unix标准函数定义*/
#include
#include
#include /*文件控制定义*/
#include /*PPSIX终端控制定义*/
#include /*错误号定义*/
打开串口
在Linux下串口文件是位于/dev下的。串口一为/dev/ttyS0，串口二为/dev/ttyS1。打开串口是通过使用标准的文件打开函数操作：
int fd;
/*以读写方式打开串口*/
fd = open( "/dev/ttyS0", O_RDWR);
if (fd==-1)
{
/*不能打开串口一*/
perror("提示错误！");
}
设置串口最基本的设置串口包括波特率设置，效验位和停止位设置。串口的设置主要是设置struct termios结构体的各成员值。
struct termio
{ unsigned short c_iflag; /*输入模式标志*/
unsigned short c_oflag; /*输出模式标志*/
unsigned short c_cflag; /*控制模式标志*/
unsigned short c_lflag; /* local mode flags */
unsigned char c_line; /* line discipline */
unsigned char c_cc[NCC]; /* control characters */
};
设置这个结构体很复杂，我这里就只说说常见的一些设置：波特率设置下面是修改波特率的代码：
struct termios Opt;
tcgetattr(fd, &Opt);
cfsetispeed(&Opt,B19200); /*设置为19200Bps*/
cfsetospeed(&Opt,B19200);
tcsetattr(fd,TCANOW,&Opt);
设置波特率的例子函数：
/**
*@brief设置串口通信速率
*@param fd类型int打开串口的文件句柄
*@param speed类型int串口速度
*@return void
*/int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,
B38400, B19200, B9600, B4800, B2400, B1200, B300, };
int name_arr[] = {38400, 19200, 9600, 4800, 2400, 1200, 300, 38400,
19200, 9600, 4800, 2400, 1200, 300, };
void set_speed(int fd, int speed){
int i;
int status;
struct termios Opt;
tcgetattr(fd, &Opt);
for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++) {
if (speed == name_arr[i]) {
tcflush(fd, TCIOFLUSH);
cfsetispeed(&Opt, speed_arr[i]);
cfsetospeed(&Opt, speed_arr[i]);
status = tcsetattr(fd1, TCSANOW, &Opt);
if (status != 0) {
perror("tcsetattr fd1");
return;
}
tcflush(fd,TCIOFLUSH);
}
}
}
设置效验的函数：
/**
*@brief设置串口数据位，停止位和效验位
*@param fd类型int打开的串口文件句柄
*@param databits类型int数据位取值为7或者8
*@param stopbits类型int停止位取值为1或者2
*@param parity类型int效验类型取值为N,E,O,,S
*/int set_Parity(int fd,int databits,int stopbits,int parity)
{
struct termios options;
if ( tcgetattr( fd,&options) != 0) {
perror("SetupSerial 1");
return(FALSE);
}
options.c_cflag &= ~CSIZE;
switch (databits) /*设置数据位数*/
{
case 7:
options.c_cflag |= CS7;
break;
case 8:
options.c_cflag |= CS8;
break;
default:
fprintf(stderr,"Unsupported data sizen"); return (FALSE);
}
switch (parity)
{
case 'n':
case 'N':
options.c_cflag &= ~PARENB; /* Clear parity enable */
options.c_iflag &= ~INPCK; /* Enable parity checking */
break;
case 'o':
case 'O':
options.c_cflag |= (PARODD | PARENB); /*设置为奇效验*/
options.c_iflag |= INPCK; /* Disnable parity checking */
break;
case 'e':
case 'E':
options.c_cflag |= PARENB; /* Enable parity */
options.c_cflag &= ~PARODD; /*转换为偶效验*/
options.c_iflag |= INPCK; /* Disnable parity checking */
break;
case 'S':
case 's': /*as no parity*/
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;break;
default:
fprintf(stderr,"Unsupported parityn");
return (FALSE);
}
/*设置停止位*/
switch (stopbits)
{
case 1:
options.c_cflag &= ~CSTOPB;
break;
case 2:
options.c_cflag |= CSTOPB;
break;
default:
fprintf(stderr,"Unsupported stop bitsn");
return (FALSE);
}
/* Set input parity option */
if (parity != 'n')
options.c_iflag |= INPCK;
tcflush(fd,TCIFLUSH);
options.c_cc[VTIME] = 150; /*设置超时15 seconds*/
options.c_cc[VMIN] = 0; /* Update the options and do it NOW */
if (tcsetattr(fd,TCSANOW,&options) != 0)
{
perror("SetupSerial 3");
return (FALSE);
}
return (TRUE);
}
需要注意的是:如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式(Raw Mode)方式来通讯，设置方式如下：
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); /*Input*/
options.c_oflag &= ~OPOST; /*Output*/
读写串口设置好串口之后，读写串口就很容易了，把串口当作文件读写就是。
·发送数据char buffer[1024];int Length;int nByte;nByte = write(fd, buffer ,Length)
·读取串口数据使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。可以使用操作文件的函数来实现异步读取，如fcntl，或者select等来操作。
char buff[1024];int Len;int readByte = read(fd,buff,Len);
关闭串口关闭串口就是关闭文件。
close(fd);
例子下面是一个简单的读取串口数据的例子，使用了上面定义的一些函数和头文件
/**********************************************************************代码说明：使用串口二测试的，发送的数据是字符，但是没有发送字符串结束符号，所以接收到后，后面加上了结束符号。in我测试使用的是单片机发送数据到第二个串口，测试通过。**********************************************************************/
#define FALSE -1
#define TRUE 0
/*********************************************************************/
int OpenDev(char *Dev)
{
int fd = open( Dev, O_RDWR );
//| O_NOCTTY | O_NDELAY
if (-1 == fd)
{
perror("Can't Open Serial Port");
return -1;
}
else
return fd;
}
int main(int argc, char **argv){
int fd;
int nread;
char buff[512];
char *dev = "/dev/ttyS1"; //串口二
fd = OpenDev(dev);
set_speed(fd,19200);
if (set_Parity(fd,8,1,'N') == FALSE) {
printf("Set Parity Errorn");
exit (0);
}
while (1) //循环读取数据
{
while((nread = read(fd, buff, 512))>0)
{
printf("nLen %dn",nread);
buff[nread+1] = '';
printf( "n%s", buff);
}
}
//close(fd);
// exit (0);
}
Linux下串口编程入门
文档选项
打印本页
将此页作为电子邮件发送
级别： 初级
左锦([email protected]),副总裁,南沙资讯科技园
2003年7月03日
Linux操作系统从一开始就对串行口提供了很好的支持，本文就Linux下的串行口通讯编程进行简单的介绍。
串口简介
串行口是计算机一种常用的接口，具有连接线少，通讯简单，得到广泛的使用。常用的串口是RS-232-C接口（又称EIA RS-232-C）它是在1970年由美国电子工业协会（EIA）联合贝尔系统、 调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。它的全名是"数据终端设备（DTE）和数据通讯设备（DCE）之间串行二进制数据交换接口技术标准"该标准规定采用一个25个脚的DB25连接器，对连接器的每个引脚的信号内容加以规定，还对各种信号的电平加以规定。传输距离在码元畸变小于4%的情况下，传输电缆长度应为50英尺。
Linux操作系统从一开始就对串行口提供了很好的支持，本文就Linux下的串行口通讯编程进行简单的介绍，如果要非常深入了解，建议看看本文所参考的《Serial Programming Guide for POSIX Operating Systems》
计算机串口的引脚说明
序号
信号名称
符号
流向
功能
2
发送数据
TXD
DTE→DCE
DTE发送串行数据
3
接收数据
RXD
DTE←DCE
DTE接收串行数据
4
请求发送
RTS
DTE→DCE
DTE请求DCE将线路切换到发送方式
5
允许发送
CTS
DTE←DCE
DCE告诉DTE线路已接通可以发送数据
6
数据设备准备好
DSR
DTE←DCE
DCE准备好
7
信号地
信号公共地
8
载波检测
DCD
DTE←DCE
表示DCE接收到远程载波
20
数据终端准备好
DTR
DTE→DCE
DTE准备好
22
振铃指示
RI
DTE←DCE
表示DCE与线路接通，出现振铃
回页首
串口操作
串口操作需要的头文件
#include/*标准输入输出定义*/
#include/*标准函数库定义*/
#include/*Unix标准函数定义*/
#include
#include
#include/*文件控制定义*/
#include/*PPSIX终端控制定义*/
#include/*错误号定义*/
回页首
打开串口
在Linux下串口文件是位于/dev下的
串口一 为/dev/ttyS0
串口二 为/dev/ttyS1
打开串口是通过使用标准的文件打开函数操作：
int fd;
/*以读写方式打开串口*/
fd = open( "/dev/ttyS0", O_RDWR);
if (-1 == fd){
/*不能打开串口一*/
perror("提示错误！");
}
回页首
设置串口
最基本的设置串口包括波特率设置，效验位和停止位设置。
串口的设置主要是设置struct termios结构体的各成员值。
struct termio
{unsigned shortc_iflag;/*输入模式标志*/
unsigned shortc_oflag;/*输出模式标志*/
unsigned shortc_cflag;/*控制模式标志*/
unsigned shortc_lflag;/* local mode flags */
unsigned charc_line;/* line discipline */
unsigned charc_cc[NCC];/* control characters */
};
设置这个结构体很复杂，我这里就只说说常见的一些设置：
波特率设置
下面是修改波特率的代码：
structtermios Opt;
tcgetattr(fd, &Opt);
cfsetispeed(&Opt,B19200);/*设置为19200Bps*/
cfsetospeed(&Opt,B19200);
tcsetattr(fd,TCANOW,&Opt);
设置波特率的例子函数：
/**
*@brief设置串口通信速率
*@paramfd类型int打开串口的文件句柄
*@paramspeed类型int串口速度
*@returnvoid
*/
int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,
B38400, B19200, B9600, B4800, B2400, B1200, B300, };
int name_arr[] = {38400,19200,9600,4800,2400,1200,300, 38400,
19200,9600, 4800, 2400, 1200,300, };
void set_speed(int fd, int speed){
inti;
intstatus;
struct termiosOpt;
tcgetattr(fd, &Opt);
for ( i= 0;i < sizeof(speed_arr) / sizeof(int);i++) {
if(speed == name_arr[i]) {
tcflush(fd, TCIOFLUSH);
cfsetispeed(&Opt, speed_arr[i]);
cfsetospeed(&Opt, speed_arr[i]);
status = tcsetattr(fd1, TCSANOW, &Opt);
if(status != 0) {
perror("tcsetattr fd1");
return;
}
tcflush(fd,TCIOFLUSH);
}
}
}
效验位和停止位的设置：
无效验
8位
Option.c_cflag &= ~PARENB;
Option.c_cflag &= ~CSTOPB;
Option.c_cflag &= ~CSIZE;
Option.c_cflag |= ~CS8;
奇效验(Odd)
7位
Option.c_cflag |= ~PARENB;
Option.c_cflag &= ~PARODD;
Option.c_cflag &= ~CSTOPB;
Option.c_cflag &= ~CSIZE;
Option.c_cflag |= ~CS7;
偶效验(Even)
7位
Option.c_cflag &= ~PARENB;
Option.c_cflag |= ~PARODD;
Option.c_cflag &= ~CSTOPB;
Option.c_cflag &= ~CSIZE;
Option.c_cflag |= ~CS7;
Space效验
7位
Option.c_cflag &= ~PARENB;
Option.c_cflag &= ~CSTOPB;
Option.c_cflag &= &~CSIZE;
Option.c_cflag |= CS8;
设置效验的函数：
/**
*@brief设置串口数据位，停止位和效验位
*@paramfd类型int打开的串口文件句柄
*@paramdatabits类型int数据位取值为7或者8
*@paramstopbits类型int停止位取值为1或者2
*@paramparity类型int效验类型取值为N,E,O,,S
*/
int set_Parity(int fd,int databits,int stopbits,int parity)
{
struct termios options;
if( tcgetattr( fd,&options)!=0) {
perror("SetupSerial 1");
return(FALSE);
}
options.c_cflag &= ~CSIZE;
switch (databits) /*设置数据位数*/
{
case 7:
options.c_cflag |= CS7;
break;
case 8:
options.c_cflag |= CS8;
break;
default:
fprintf(stderr,"Unsupported data size\n"); return (FALSE);
}
switch (parity)
{
case 'n':
case 'N':
options.c_cflag &= ~PARENB;/* Clear parity enable */
options.c_iflag &= ~INPCK;/* Enable parity checking */
break;
case 'o':
case 'O':
options.c_cflag |= (PARODD | PARENB); /*设置为奇效验*/
options.c_iflag |= INPCK;/* Disnable parity checking */
break;
case 'e':
case 'E':
options.c_cflag |= PARENB;/* Enable parity */
options.c_cflag &= ~PARODD;/*转换为偶效验*/
options.c_iflag |= INPCK;/* Disnable parity checking */
break;
case 'S':
case 's':/*as no parity*/
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;break;
default:
fprintf(stderr,"Unsupported parity\n");
return (FALSE);
}
/*设置停止位*/
switch (stopbits)
{
case 1:
options.c_cflag &= ~CSTOPB;
break;
case 2:
options.c_cflag |= CSTOPB;
break;
default:
fprintf(stderr,"Unsupported stop bits\n");
return (FALSE);
}
/* Set input parity option */
if (parity != 'n')
options.c_iflag |= INPCK;
tcflush(fd,TCIFLUSH);
options.c_cc[VTIME] = 150; /*设置超时15 seconds*/
options.c_cc[VMIN] = 0; /* Update the options and do it NOW */
if (tcsetattr(fd,TCSANOW,&options) != 0)
{
perror("SetupSerial 3");
return (FALSE);
}
return (TRUE);
}
需要注意的是:
如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式(Raw Mode)方式来通讯，设置方式如下：
options.c_lflag&= ~(ICANON | ECHO | ECHOE | ISIG);/*Input*/
options.c_oflag&= ~OPOST;/*Output*/
回页首
读写串口
设置好串口之后，读写串口就很容易了，把串口当作文件读写就是。
发送数据
charbuffer[1024];intLength;intnByte;nByte = write(fd, buffer ,Length)
读取串口数据
使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。
可以使用操作文件的函数来实现异步读取，如fcntl，或者select等来操作。
charbuff[1024];intLen;intreadByte = read(fd,buff,Len);
回页首
关闭串口
关闭串口就是关闭文件。
close(fd);
回页首
例子
下面是一个简单的读取串口数据的例子，使用了上面定义的一些函数和头文件
/**********************************************************************代码说明：使用串口二测试的，发送的数据是字符，
但是没有发送字符串结束符号，所以接收到后，后面加上了结束符号。我测试使用的是单片机发送数据到第二个串口，测试通过。
**********************************************************************/
#define FALSE-1
#define TRUE0
/*********************************************************************/
int OpenDev(char *Dev)
{
intfd = open( Dev, O_RDWR );//| O_NOCTTY | O_NDELAY
if (-1 == fd)
{
perror("Can't Open Serial Port");
return -1;
}
else
return fd;
}
int main(int argc, char **argv){
int fd;
int nread;
char buff[512];
char *dev= "/dev/ttyS1"; //串口二
fd = OpenDev(dev);
set_speed(fd,19200);
if (set_Parity(fd,8,1,'N') == FALSE){
printf("Set Parity Error\n");
exit (0);
}
while (1) //循环读取数据
{
while((nread = read(fd, buff, 512))>0)
{
printf("\nLen %d\n",nread);
buff[nread+1] = '\0';
printf( "\n%s", buff);
}
}
//close(fd);
// exit (0);
}
参考资料
Serial Programming Guide for POSIX Operating Systems
Linux的源代码
代码下载:代码
Linux串口编程-中英文简体对照版(续)
时间：2004-08-01
3.Program Examples示例程序
All examples have been derived fromminiterm.c. The type ahead buffer is limited to 255 characters, just like the maximum string length for canonical input processing (or).
See the comments in the code for explanation of the use of the different input modes. I hope that the code is understandable. The example for canonical input is commented best, the other examples are commented only where they differ from the example for canonical input to emphasize the differences.
The descriptions are not complete, but you are encouraged to experiment with the examples to derive the best solution for your application.
Don't forget to give the appropriate serial ports the right permissions (e. g.:chmod a+rw /dev/ttyS1)!
所有的示例来自于miniterm.c. The type ahead缓存器限制在255字节的大小,这与标准输入(canonical input)进程的字符串最大长度相同(或).
代码中的注释解释了不同输入模式的使用以希望这些代码能够易于理解。标准输入程序的示例做了最详细的注解,其它的示例则只是在不同于标准输入示例的地方做了强调。
叙述不是很完整,但可以激励你对这范例做实验,以延生出合于你所需应用程序的最佳解.
不要忘记赋予串口正确的权限(也就是:chmod a+rw /dev/ttyS1)!
3.1.Canonical Input Processing标准输入模式
#include
#include
#include
#include
#include
/* baudrate settings are defined in , which is included by */
//波特率的设置定义在.包含在里
#define BAUDRATE B38400
/* change this definition for the correct port */
//定义您所需要的串口号
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /*POSIX compliant source POSIX系统兼容*/
#define FALSE 0
#define TRUE 1
volatile int STOP=FALSE;
main() {
int fd,c, res;
struct termios oldtio,newtio;
char buf[255];
/* Open modem device for reading and writing and not as controlling
tty because we don't want to get killed if linenoise sends CTRL-C.
开启设备用于读写，但是不要以控制tty的模式，因为我们并不希望在发送Ctrl-C
后结束此进程
*/
fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY );
if (fd <0) {perror(MODEMDEVICE); exit(-1); }
tcgetattr(fd,&oldtio); /* save current serial port settings */
//储存当前的串口设置
bzero(&newtio, sizeof(newtio)); /* clear struct for new port settings */
//清空新的串口设置结构体
/*
BAUDRATE: Set bps rate. You could also use cfsetispeed and cfsetospeed.
CRTSCTS : output hardware flow control (only used if the cable has all
ecessary lines. See sect. 7 of Serial-HOWTO)
CS8 : 8n1 (8bit,no parity,1 stopbit)
CLOCAL : local connection, no modem contol
CREAD : enable receiving characters
BAUDRATE:设置串口的传输速率bps,也可以使用cfsetispeed和cfsetospeed来设置
CRTSCTS :输出硬件流控(只能在具完整线路的缆线下工作，参考Serial-HOWTO第七节)
CS8 : 8n1 (每一帧8比特数据,无奇偶校验位,1比特停止位)
CLOCAL :本地连接，无调制解调器控制
CREAD :允许接收数据
*/
newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
/*
IGNPAR : ignore bytes with parity errors
ICRNL : map CR to NL (otherwise a CR input on the other computer will not
terminate input) otherwise make device raw (no other input processing)
IGNPAR :忽略奇偶校验出错的字节
ICRNL :把CR映像成NL (否则从其它机器传来的CR无法终止输入)或者就把设备设
为raw状态（没有额外的输入处理）
*/
newtio.c_iflag = IGNPAR | ICRNL;
/*
Raw output. Raw模式输出
*/
newtio.c_oflag = 0;
/*
ICANON : enable canonical input
disable all echo functionality, and don't send signals to calling program
ICANON :启动标准输出，关闭所有回显echo功能，不向程序发送信号
*/
newtio.c_lflag = ICANON;
/*
initialize all control characters
default values can be found in /usr/include/termios.h, and
are given in the comments, but we don't need them here
初始化所有的控制字符，默认值可以在/usr/include/termios.h找到，
并且做了注解，不过这里我们并不需要考虑这些
*/
newtio.c_cc[VINTR] = 0; /* Ctrl-c */
newtio.c_cc[VQUIT] = 0; /* Ctrl-\ */
newtio.c_cc[VERASE] = 0; /* del */
newtio.c_cc[VKILL] = 0; /* @ */
newtio.c_cc[VEOF] = 4; /* Ctrl-d */
newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
/*不使用字符间的计时器*/
newtio.c_cc[VMIN] = 1; /* blocking read until 1 character arrives */
/*阻塞，直到读取到一个字符*/
newtio.c_cc[VSWTC] = 0; /* '\0' */
newtio.c_cc[VSTART] = 0; /* Ctrl-q */
newtio.c_cc[VSTOP] = 0; /* Ctrl-s */
newtio.c_cc[VSUSP] = 0; /* Ctrl-z */
newtio.c_cc[VEOL] = 0; /* '\0' */
newtio.c_cc[VREPRINT] = 0; /* Ctrl-r */
newtio.c_cc[VDISCARD] = 0; /* Ctrl-u */
newtio.c_cc[VWERASE] = 0; /* Ctrl-w */
newtio.c_cc[VLNEXT] = 0; /* Ctrl-v */
newtio.c_cc[VEOL2] = 0; /* '\0' */
/*
now clean the modem line and activate the settings for the port
清空数据线，启动新的串口设置
*/
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);
/*
terminal settings done, now handle input
In this example, inputting a 'z' at the beginning of a line will
exit the program.
终端设置完成，现在就可以处理数据了
在本程序中，在一行的开始输入一个'z'会终止该程序
*/
while (STOP==FALSE) { /* loop until we have a terminating condition */
//循环直到满足终止条件
/* read blocks program execution until a line terminating character is
input, even if more than 255 chars are input. If the number
of characters read is smaller than the number of chars available,
subsequent reads will return the remaining chars. res will be set
to the actual number of characters actually read
即使输入超过255个字节，读取的程序段还是会一直等到行结束符出现才会停止。
如果读到的字符少于应刚获得的字符数，则剩下的字符串会在下一次读取时读到。
res用来获得每次真正读到的字节数
*/
res = read(fd,buf,255);
buf[res]=0; /* set end of string, so we can printf */
//设置字符串结束符，从而可以顺利使用printf
printf(":%s:%d\n", buf, res);
if (buf[0]=='z') STOP=TRUE;
}
/* restore the old port settings恢复旧的串口设置*/
tcsetattr(fd,TCSANOW,&oldtio);
}
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, andc_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 afcntl(fd, F_SETFL, FNDELAY);before reading to get the same result.
By modifyingnewtio.c_cc[VTIME]andnewtio.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],就可以测试以上的设置了。
#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异步输入模式
#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 afd_set. This is a bit array, which has a bit entry for every valid file descriptor number.selectwill accept afd_setwith the bits set for the relevant file descriptors and returns afd_set, in which the bits for the file descriptors are set where input, output, or an exception occurred. All handling offd_setis done with the provided macros. See also the manual pageselect(2).
这一部分的内容很少，只是作为一个提示，因此这段代码也很简短。而且这部分内容不仅适用于串口编程，而且适用于任意的一组文件描述符。
select调用及其相应的宏，使用fd_set.这是一个比特数组，其中每一个比特代表了一个有效的文件描述符号。select调用接收一个有效的文件描述符结构，并返回fd_set比特数组，如果此比特数组中有某一个位设为1，就表示对应的文件描述符发生了输入，输出或者有例外事件。所有fg_set的处理都由宏提供了，具体参考man select 2。
#include
#include
#include
main()
{
intfd1, fd2;/* input sources 1 and 2输入源1和2 */
fd_set readfs;/* file descriptor set */
intmaxfd;/* maximum file desciptor used用到的文件描述符的最大值*/
intloop=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替代：
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函数会立刻退出。
Other Sources of Information其它资源信息
·The Linux Serial-HOWTO describes how to set up serial ports and contains hardware information.
Linux Serial HOWTO介绍了如何安装串口，并包括了硬件信息。
·Serial Programming Guide for POSIX Compliant Operating Systems, by Michael Sweet.
POSIX兼容的操作系统上的串口编程
·The manual pagetermios(3)describes all flags for thetermiosstructure.
man termios 3介绍了所有termios结构里的设置。