Serial Programming HOWTO——Linux 串口编程HOWTO

转自：http://bbs.loveunix.net/viewthread.php?tid=35896

1. Introduction 简介
This is the Linux Serial Programming HOWTO. All about how to program communications
with other devices / computers over a serial line under Linux. Different techniques
are explained: Canonical I/O (only complete lines are transmitted/received),
asyncronous I/O, and waiting for input from multiple sources.

This is the first update to the initial release of the Linux Serial Programming HOWTO.
The primary purpose of this update is to change the author information and convert
the document to DocBook format. In terms of technical content, very little if anything
has changed at this time. Sweeping changes to the technical content aren't going to
happen overnight, but I'll work on it as much as time allows.

If you've been waiting in the wings for someone to take over this HOWTO, you've
gotten your wish. Please send me any and all feedback you have, it'd be very much
appreciated.

All examples were tested using a i386 Linux Kernel 2.0.29.

本文是为 Linux 串口程序编写的 HOWTO. 主要讨论如何在 Linux 环境下，编写串口与其它
计算机设备进行通讯的程序。文中所谈到的技术包括: 标准的 I/O (只具备传送/接收线
的), 异步 I/O, 以及等待来自多信号源输入的程序。

本文是初始的 linux serial programming howto 的第一个升级版。主要升级了一些作者信
息，把文件转换为 DocBook 格式。就技术内容而言，几乎没什幺大的改变。大规模的技术
内容的改变是不可能一夜之间发生的，如果时间允许，我会尽量做一些工作。

如果你正在一边等着有谁来接管这份 HOWTO,那你的心愿达成了。我会感谢你发来的任何反
馈信息。

所有的示例都在 i386 Linux Kernel 2.0.29 下测试通过。

1.1. Copyright Information 版权信息

This document is copyrighted © 1997 Peter Baumann, © 2001 Gary Frerking and is
distributed under the terms of the Linux Documentation Project (LDP) license, stated below.

Unless otherwise stated, Linux HOWTO documents are copyrighted by their respective
authors. Linux HOWTO documents may be reproduced and distributed in whole or in part,
in any medium physical or electronic, as long as this copyright notice is retained
on all copies. Commercial redistribution is allowed and encouraged; however, the
author would like to be notified of any such distributions.

Linux Serial-Programming-HOWTO 的版权© 1997 归 Peter Baumann 所有，© 2001
归 Gary Frerking 所有，并且以 LDP lisence (附后)发布。

除非另做申明，Linux HOWTO 文件的版权归各自的作者所有。Linux HOWTO 文件可以完整或
部份的以实物或电子版形式复制或者发布, 只要能在所有的拷贝中保留版权申明即可。我们
鼓励允许商业的发布，不过, 如果以此形式发布的话，请告知作者。

All translations, derivative works, or aggregate works incorporating any Linux HOWTO
documents must be covered under this copyright notice. That is, you may not produce
a derivative work from a HOWTO and impose additional restrictions on its distribution.
Exceptions to these rules may be granted under certain conditions; please contact
the Linux HOWTO coordinator at the address given below.
In
short, we wish to promote dissemination of this information through as many channels
as possible. However, we do wish to retain copyright on the HOWTO documents, and
would like to be notified of any plans to redistribute the HOWTOs.

If you have any questions, please contact

所有的翻译, 以及其它派生的工作, 或整合合并任何 Linux HOWTO 文件都必须在此版权申
明的规范下进行. 也就是说, 你不可以在从 HOWTO 所衍生的工作中, 散布的文件上附加额
外的限制条款。除了这些规则，都可获得某种条件的授与; 请见后面的地址来联络 Linux
HOWTO 协调员。

简而言之, 我们希望尽可能得透过各种渠道来促进这份资料的流通, 不过, 我们强烈希望将
此版权宣告置于 HOWTO 的文件上, 并且希望任何想重新发布 HOWTO 的人可以通知我们一
下。

如果你有问题, 请通过 email linux-howto@metalab.unc.edu 进行联系.

1.2. Disclaimer 申明

No liability for the contents of this documents can be accepted. Use the concepts,
examples and other content at your own risk. As this is a new edition of this document,
there may be errors and inaccuracies, that may of course be damaging to your system.
Proceed with caution, and although this is highly unlikely, the author(s) do not
take any responsibility for that.

All copyrights are held by their by their respective owners, unless specifically
noted otherwise. Use of a term in this document should not be regarded as affecting
the validity of any trademark or service mark.

Naming of particular products or brands should not be seen as endorsements.

You are strongly recommended to take a backup of your system before major installation
and backups at regular intervals.

使用本文的概念，例子及其它内容的风险由您自己承担，我们对此造成的后果不负责任。
由于这是份新的文档，可能存在着错误或误差，而有可能导致对您的系统的损害。请小心操
作，虽然这是几乎不可能发生的，作者不对此承担任何责任。

除非特别标注，所有的版权归其各自的作者。使用此文档不可标住任何商标或服务标记。

特定的产品或品牌的命名不可被理解为是认可的。（晕，这一段应该请律师来翻）。

强烈推荐您在重大的安装前备份系统，并且做到定期备份。

1.3. New Versions 版本更新

As previously mentioned, not much is new in terms of technical content yet.

如前面所提到的，此版本在技术内容上较前一版本并没有什幺大的更新。

1.4. Credits 感谢

The original author thanked Mr. Strudthoff, Michael Carter, Peter Waltenberg,
Antonino Ianella, Greg Hankins, Dave Pfaltzgraff, Sean Lincolne, Michael Wiedmann,
and Adrey Bonar.

原作者感谢 Strudthoff, Michael Carter, Peter Waltenberg, Antonino Ianella, Greg
Hankins, Dave Pfaltzgraff, Sean Lincolne, Michael Wiedmann, and Adrey Bonar 诸位
先生。

1.5. Feedback 意见反馈

Feedback is most certainly welcome for this document. Without your submissions and
input, this document wouldn't exist. Please send your additions, comments and criticisms
to the following email address : .

非常欢迎对此文档提出反馈意见。有任何补充，评论，批评请发信到： gary@frerking.org

2. Getting started 入门

2.1. Debugging 调试

The best way to debug your code is to set up another Linux box, and connect the two
computers via a null-modem cable. Use miniterm (available from the LDP programmers
guide (ftp://sunsite.unc.edu/pub/Linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz
in the examples directory) to transmit characters to your Linux box. Miniterm can
be compiled very easily and will transmit all keyboard input raw over the serial
port. Only the define statement #define MODEMDEVICE "/dev/ttyS0" has to be checked.
Set it to ttyS0 for COM1, ttyS1 for COM2, etc.. It is essential for testing, that
all characters are transmitted raw (without output processing) over the line. To
test your connection, start miniterm on both computers and just type away. The
characters input on one computer should appear on the other computer and vice versa.
The input will not be echoed to the attached screen.

调试代码最好的方法，是另外建立一台Linux主机（Linux box），采用非调制解调器的串口
线（null-modem）连接两台机器。还可以使用minicom (可以从 LDP 编程指南上获得：
ftp://sunsite.unc.edu/pub/Linux/docs/LDP/.../lpg-0.4.tar.gz 里的
examples 目录)来传输字符到你的 Linux 主机。Miniterm 很容易编译而且会直接把键盘的
输入不做处理(raw 方式)地传到串口。只需要把定义申明 #define MODEMDIVICE “/dev/ttyS0”
改一下。 COM1 口就设置成 ttyS0, COM2 口就是 ttyS1, 以此类推… 测试是必需的，所有
的字符直接通过缆线传输，不进行任何输出处理。为了测试你的连接，在你的两台机器上开
启minicom，然后随意输入一些字符。从一台电脑中输入的字符应该能显示在另一台设备
上，反之亦然。输入的字符不会回显(echo) 在本地的屏幕上.

To make a null-modem cable you have to cross the TxD (transmit) and RxD (receive)
lines. For a description of a cable see sect. 7 of the Serial-HOWTO.

自制非调制解调器的串口连接线（null-modem cable）时，你需要将一端的传送端（TxD）
与另一端的接收端（RxD）连接，一端的接收端与另外一端的传送端连接，详情见
Serial-HOWTO第七节。

It is also possible to perform this testing with only one computer, if you have
two unused serial ports. You can then run two miniterms off two virtual consoles.
If you free a serial port by disconnecting the mouse, remember to redirect /dev/mouse
if it exists. If you use a multiport serial card, be sure to configure it correctly.
I had mine configured wrong and everything worked fine as long as I was testing
only on my computer. When I connected to another computer, the port started loosing
characters. Executing two programs on one computer just isn't fully asynchronous.

如果你的电脑有两个空闲的串口端口的话，那幺只要使用一台机器就可以做这些试验了，你
可以在两个虚拟控制台上各运行一个miniterm，分别用来发送和接收结果。如果你使用串口
鼠标，记得在试验前将 /dev/mouse 复位向。如果你使用多端口的串口卡（multiport serial
card）,一定要确保此设备配置正确，我的电脑就曾因为配置错误，而出现这样的问题：当
我在自己的机器上测试的时候一切正常，而连接到其它电脑上的时候，端口开始丢失数据。
注意，在一台机器上运行两个串口应用程序，并不是完全异步的。

2.2. Port Settings 端口设置

The devices /dev/ttyS* are intended to hook up terminals to your Linux box, and
are configured for this use after startup. This has to be kept in mind when programming
communication with a raw device. E.g. the ports are configured to echo characters
sent from the device back to it, which normally has to be changed for data transmission.

设备 /dev/ttyS* 会被当作连接到你的 Linux 机器的终端设备，而且在系统启动后就已经
配置好了。这一点是在你写 raw 设备的串口通信程序时必需牢记的. 举例来说，这个串口
被设定为回显（echo）所有自此设备送出的字符, 通常在做数据传输时，需要改变这种工作
模式。

All parameters can be easily configured from within a program. The configuration
is stored in a structure struct termios, which is defined in :

CODE

#define NCCS 19
struct termios {
tcflag_t c_iflag; /* input mode flags */
tcflag_t c_oflag; /* output mode flags */
tcflag_t c_cflag; /* control mode flags */
tcflag_t c_lflag; /* local mode flags */
cc_t c_line; /* line discipline */
cc_t c_cc[NCCS]; /* control characters */
}

所有的参数都可以在程序中轻松配置。配置保存在结构体 struct termios 中，这个结构是在中定义的

CODE

#define NCCS 19
struct termios {
tcflag_t c_iflag; /* 输入模式标志 */
tcflag_t c_oflag; /* 输出模式标志 */
tcflag_t c_cflag; /* 控制模式标志 */
tcflag_t c_lflag; /* 本地模式标志 */
cc_t c_line; /* 行控制 line discipline */
cc_t c_cc[NCCS]; /* 控制字符 control characters */
}

This file also includes all flag definitions. The input mode flags in c_iflag handle
all input processing, which means that the characters sent from the device can be
processed before they are read with read. Similarly c_oflag handles the output processing.
c_cflag contains the settings for the port, as the baudrate, bits per character,
stop bits, etc.. The local mode flags stored in c_lflag determine if characters are
echoed, signals are sent to your program, etc.. Finally the array c_cc defines the
control characters for end of file, stop, etc.. Default values for the control
characters are defined in . The flags are described in the manual
page termios(3). The structure termios contains the c_line (line discipline) element,
which is not used in POSIX compliant systems.

这个文件也包括了所有标志 (flag) 的定义。c_iflag 中的输入模式标志，进行所有的输入
处理，也就是说从其它设备传来的字符，在被read函数读入之前，会先按照标志进行预处
理。同样的，c_oflag 定义了所有的输出处理。c_cflag 包括了对端口的设置，比如波特
率，停止符号等等。c_lflag 包括了，决定了字符是否回显，信号是否发送到你的程序，等
等所有的本地工作方式。c_cc 定义了所有的控制符号，例如文件结束符和停止符等等，所
有的这些参数的默认值都定义在中，man手册页termios(3)中有这些参数的
具体描述。termio结构体中还包括在不能在 POSIX 系统中使用的c_line参数(行控制)

2.3. Input Concepts for Serial Devices 串口设备的输入概念

Here three different input concepts will be presented. The appropriate concept
has to be chosen for the intended application. Whenever possible, do not loop reading
single characters to get a complete string. When I did this, I lost characters,
whereas a read for the whole string did not show any errors.

这里将介绍串行设备三种不同的输入方式，你需要为你的程序选择合适的工作方式。任何可
能的情况下，不要采用循环读取单字符的方式来获取一个字符串。我以前这样做的时候，就
丢失了字符，而读取整个字符串的 read 方法，则没有这种错误。

2.3.1. Canonical Input Processing 标准输入模式

This is the normal processing mode for terminals, but can also be useful for communicating
with other dl input is processed in units of lines, which means that a read will
only return a full line of input. A line is by default terminated by a NL (ASCII
LF), an end of file, or an end of line character. A CR (the DOS/Windows default
end-of-line) will not terminate a line with the default settings.

Canonical input processing can also handle the erase, delete word, and reprint
characters, translate CR to NL, etc..

这是终端设备的标准处理模式, 在与其它 dl 的以行为单位的输入通讯中也很有用。这种方
式中， read 会传回一整行完整的输入. 一行的结束，默认是以 NL (ASCII值 LF), 文件结
束符, 或是一个行结束字符。默认设置中, CR ( DOS/Windows 里的默认行结束符) 并不是
行结束标志。

标准的输入处理还可以处理清除, 删除字, 重画字符, 转换 CR 为 NL 等等功能。

2.3.2. Non-Canonical Input Processing 非标准输入模式

Non-Canonical Input Processing will handle a fixed amount of characters per read,
and allows for a character timer. This mode should be used if your application will
always read a fixed number of characters, or if the connected device sends bursts
of characters.

非标准输入处理可以用于需要每次读取固定数量字符的情况下, 并允许使用字符接收时间的
定时器。这种模式可以用在每次读取固定长度字符串的程序中, 或者所连接的设备会突然送
出大量字符的情况下。

2.3.3. Asynchronous Input 异步输入模式

The two modes described above can be used in synchronous and asynchronous mode.
Synchronous is the default, where a read statement will block, until the read is
satisfied. In asynchronous mode the read statement will return immediatly and send
a signal to the calling program upon completion. This signal can be received by
a signal handler.

前面叙述的两种模式都可以用在同步与异步的传输模式。默认是在同步的模式下工作的, 也
就是在尚未读完数据之前, read 的状态会被阻塞(block)。而在异步模式下，read 的状态
会立即返回并送出一个信号到所调用的程序直到完成工作。这个信号可以由信号处理程序 handler来接收。

2.3.4. Waiting for Input from Multiple Sources 等待来自多信号源的输入

This is not a different input mode, but might be useful, if you are handling multiple
devices. In my application I was handling input over a TCP/IP socket and input over
a serial connection from another computer quasi-simultaneously. The program example
given below will wait for input from two different input sources. If input from one
source becomes available, it will be processed, and the program will then wait for
new input.

The approach presented below seems rather complex, but it is important to keep in
mind that Linux is a multi-processing operating system. The select system call will
not load the CPU while waiting for input, whereas looping until input becomes
available would slow down other processes executing at the same time.

本节介绍的不是另一个输入模式，不过如果你要处理来自多个设备的数据的话，可能会很有
用。在我的应用程序中，我需要同时通过一个 TCP/IP socket 和一个串口来处理其它计算
机传来的输入。下面给出的示例程序将等待来自两个不同输入源的输入。如果其中一个信号
源出现, 程序就会进行相应处理, 同时程序会继续等待新的输入。

后面提出的方法看起来相当覆杂, 但请记住 Linux 是一个多进程的操作系统。系统调用
select 并不会在等待输入信号时增加 CPU 的负担，而如果使用轮询方式来等待输入信号的
话，则将拖慢其它正在执行的进程。

3. Program Examples 示例程序

All examples have been derived from miniterm.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 标准输入模式

CODE

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
/* 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);
}

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 <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
#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 函数会立刻退出。

4. 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 page termios(3) describes all flags for the termios structure.

man termios 3 介绍了所有 termios 结构里的设置。

Serial Programming HOWTO——Linux 串口编程HOWTO相关推荐

Linux 串口编程一一些背景
在大部分讲解 Linux 编程书籍的时候会发现没有单独的串口编程章节,实际上串口编程已经被概括在了"终端"或者"终端IO"章节里面.在上一篇博客中对经常出现的几 ...
嵌入式Linux 串口编程系列3——通过VTIM、VMIN、select实现串口不定长数据接收功能
上一篇文章中,我们详细分析了VTIM和VMIN的功能, <嵌入式Linux 串口编程系列2--termios的VMIN和VTIME深入理解> 也明白了这两个参数设计的初衷和使用方法,接下来 ...
Linux串口编程_termios
1.1 Linux串口编程主要是设置structtermios结构体的个成员值.Termios是在POSIX规范中定义的标准接口,表示终端设备(包括虚拟终端丶串口等),串口是一种终端设备,一般通过终端 ...
Linux串口编程详解
Linux串口编程详解(阻塞模式.非阻塞模式.select函数) 之前一直觉得串口编程很简单,这两天仔细研究后发现串口里的各种参数还挺复杂,稍不注意就容易出错,这里总结一下网上的各种文章及自己的理解与 ...
Linux 串口编程四串口设备程序开发
Linux 串口编程和程序相对来说是很简单的,之所以用博客连载来展示,主要是想在学会使用的基础上掌握相关背景,原理以及注意事项.相信在遇到问题的时候,我们就不会对于技术的概念和 API 的使用浅尝辄止 ...
Linux 串口编程三使用termios与API进行串口程序开发
在 termios 结构体以及内部终端控制标志中,并非所有的参数对于实际的物理串口都是有效的,在使用过程中也不需要对于所有标志的作用都有所理解.事实上,快速掌握一项技术的核心点也是一种学习能力.对于使 ...
Linux 串口编程二深入了解 termios
前言这一系列串口编程重点在应用层编程,但是在讲解原理与相关概念时需要对驱动框架有个基础的认识.如果只是浅尝辄止,以后在遇到串口驱动与应用层程序调试难免遇到瓶颈.关于 tty驱动架构参见我的其他博客: ...
Linux串口编程 —— 发送的数据无法被接收，且被原封不动返回
Linux串口编程--发送的数据无法被接收,且被原封不动返回问题描述使用 #include <fcntl.h> /*文件控制定义*/ #include <termios.h> ...
linux串口编程-termios结构
linux串口编程简单起来可以十分简单,但是复杂起来,也可以异常复杂.因为linux串口不仅仅是个串口,它跟终端联系起来.一般串口编程,绕不开的是struct termios结构体,其定义如下: #d ...

Serial Programming HOWTO——Linux 串口编程HOWTO

Serial Programming HOWTO——Linux 串口编程HOWTO相关推荐

最新文章

热门文章