《I.MX6U嵌入式Linux C应用编程指南 V1.1》第二十七章 串口应用编程

正点原子运营

1）实验平台：正点原子阿尔法Linux开发板
2)  章节摘自【正点原子】《I.MX6U嵌入式Linux C应用编程指南 V1.1》
3）购买链接:https://detail.tmall.com/item.htm?id=609033604451
4）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/arm-linux/zdyz-i.mx6ull.html
5）正点原子官方B站：https://space.bilibili.com/394620890
6）正点原子阿尔法Linux交流群：1027879335

第二十七章 串口应用编程

本小节我们来学习Linux下串口应用编程，串口（UART）是一种非常常见的外设，串口在嵌入式开发领域当中一般作为一种调试手段，通过串口输出调试打印信息，或者通过串口发送指令给主机端进行处理；当然除了作为基本的调试手段之外，还可以通过串口与其他设备或传感器进行通信，譬如有些sensor就使用了串口通信的方式与主机端进行数据交互。
本章将会讨论如下主题内容。
串口应用编程介绍
应用编程实战



27.1串口应用编程介绍
串口全称叫做串行接口，串行接口指的是数据一个一个的按顺序传输，通信线路简单。使用两条线即可实现双向通信，一条用于发送，一条用于接收。串口通信距离远，但是速度相对会低，串口是一种很常用的工业接口。
关于串口的基础知识以及通行原理、通行数据格式等之类的问题，笔者就不给大家介绍了，免得大家嫌啰嗦。串口（UART）在嵌入式Linux系统中常作为系统的标准输入、输出设备，系统运行过程产生的打印信息通过串口输出；同理，串口也作为系统的标准输入设备，用户通过串口与Linux系统进行交互。
所以串口在Linux系统就是一个终端，提到串口，就不得不引出“终端（Terminal）”这个概念了。
27.1.1终端Terminal
终端就是处理主机输入、输出的一套设备，它用来显示主机运算的输出，并且接受主机要求的输入。典型的终端包括显示器键盘套件，打印机打字机套件等。其实本质上也就一句话，能接受输入、能显示输出，这就够了，不管到了什么时代，终端始终扮演着人机交互的角色，所谓Terminal，即机器的边缘！
只要能提供给计算机输入和输出功能，它就是终端，而与其所在的位置无关。
终端的分类
本地终端：例如对于我们的个人PC机来说，PC机连接了显示器、键盘以及鼠标等设备，这样的一个显示器/键盘组合就是一个本地终端；同样对于开发板来说也是如此，开发板也可以连接一个LCD显示器、键盘和鼠标等，同样可以构成本地终端。
用串口连接的远程终端：对于嵌入式Linux开发来说，这是最常见的终端—串口终端。譬如我们的开发板通过串口线连接到一个带有显示器和键盘的PC机，在PC机通过运行一个终端模拟程序，譬如Windows超级终端、putty、MobaXterm、SecureCRT等来获取并显示开发板通过串口发出的数据、同样还可以通过这些终端模拟程序将用户数据通过串口发送给开发板Linux系统，系统接收到数据之后便会进行相应的处理、譬如执行某个命令，这就是一种人机交互！
基于网络的远程终端：譬如我们可以通过ssh、Telnet这些协议登录到一个远程主机。
以上列举的这些都是终端，前两类称之为物理终端；最后一个称之为伪终端。前两类都是在本地就直接关联了物理设备的，譬如显示器、鼠标键盘、串口等之类的，这种终端叫做物理终端，而第三类在本地则没有关联任何物理设备，注意，不要把物理网卡当成终端关联的物理设备，它们与终端并不直接相关，所以这类不直接关联物理设备的终端叫做伪终端。
终端对应的设备节点
在Linux当中，一切皆是文件。当然，终端也不例外，每一个终端在/dev目录下都有一个对应的设备节点。
/dev/ttyX（X是一个数字编号，譬如0、1、2、3等）设备节点：ttyX（teletype的简称）是最令人熟悉的了，在Linux中，/dev/ttyX代表的都是上述提到的本地终端，包括/dev/tty1~/dev/tty63一共63个本地终端，也就是连接到本机的键盘显示器可以操作的终端。事实上，这是Linux内核在初始化时所生成的63个本地终端。如下所示：

图 27.1.1 本地终端设备节点

/dev/pts/X（X是一个数字编号，譬如0、1、2、3等）设备节点：这类设备节点是伪终端对应的设备节点，也就是说，伪终端对应的设备节点都在/dev/pts目录下、以数字编号命令。譬如我们通过ssh或Telnet这些远程登录协议登录到开发板主机，那么开发板Linux系统会在/dev/pts目录下生成一个设备节点，这个设备节点便对应伪终端，如下所示：

图 27.1.2 伪终端设备节点

串口终端设备节点/dev/ttymxcX：对于ALPHA/Mini I.MX6U开发板来说，有两个串口，也就是有两个串口终端，对应两个设备节点，如下所示：

图 27.1.3 串口终端对应的设备节点

这里为什么是0和2、而不是0和1？我们知道，I.MX6U SoC支持8个串口外设，分别是UART1~UART8;出厂系统只注册了2个串口外设，分别是UART1和UART3，所以对应这个数字就是0和2、而不是0和1，这里了解一下就行！
还需要注意的是，mxc这个名字不是一定的，这个名字的命名与驱动有关系（与硬件平台有关），如果你换一个硬件平台，那么它这个串口对应的设备节点就不一定是mxcX了；譬如ZYNQ平台，它的系统中串口对应的设备节点就是/dev/ttyPSX（X是一个数字编号），所以说这个名字它不是统一的，但是名字前缀都是以“tty”开头，以表明它是一个终端。
在Linux系统下，我们可以使用who命令来查看计算机系统当前连接了哪些终端（一个终端就表示有一个用户使用该计算机），如下所示：

图 27.1.4 查看系统连接了哪些终端

可以看到，开发板系统当前有两个终端连接到它，一个就是我们的串口终端，也就是开发板的USB调试串口（对应/dev/ttymxc0）；另一个则是伪终端，这是笔者通过ssh连接的。
27.1.2串口应用编程
现在我们已经知道了串口在Linux系统中是一种终端设备，并且在我们的开发板上，其设备节点为/dev/ttymxc0（UART1）和/dev/ttymxc2（UART3）。
其实串口的应用编程也很简单，无非就是通过ioctl()对串口进行配置，调用read()读取串口的数据、调用write()向串口写入数据，是的，就是这么简单！但是我们不这么做，因为Linux为上层用户做了一层封装，将这些ioctl()操作封装成了一套标准的API，我们就直接使用这一套标准API编写自己的串口应用程序即可！
笔者把这一套接口称为termios API，这些API其实是C库函数，可以使用man手册查看到它们的帮助信息；这里需要注意的是，这一套接口并不是针对串口开发的，而是针对所有的终端设备，串口是一种终端设备，计算机系统本地连接的鼠标、键盘也是终端设备，通过ssh远程登录连接的伪终端也是终端设备。
要使用termios API，需要在我们的应用程序中包含termios.h头文件。
27.1.3struct termios结构体
对于终端来说，其应用编程内容无非包括两个方面的内容：配置和读写；对于配置来说，一个很重要的数据结构便是struct termios结构体，该数据结构描述了终端的配置信息，这些参数能够控制、影响终端的行为、特性，事实上，终端设备应用编程（串口应用编程）主要就是对这个结构体进行配置。
struct termios结构体定义如下：
示例代码 27.1.1 struct termios结构体

1. struct termios
   
2. {
   
3.     tcflag_t c_iflag;           /* input mode flags */
   
4.     tcflag_t c_oflag;          /* output mode flags */
   
5.     tcflag_t c_cflag;          /* control mode flags */
   
6.     tcflag_t c_lflag;           /* local mode flags */
   
7.     cc_t c_line;              /* line discipline */
   
8.     cc_t c_cc[NCCS];         /* control characters */
   
9.     speed_t c_ispeed;         /* input speed */
   
10.     speed_t c_ospeed;         /* output speed */
    
11. };

复制代码

如上定义所示，影响终端的参数按照不同模式分为如下几类：
输入模式；
输出模式；
控制模式；
本地模式；
线路规程；
特殊控制字符；
输入速率；
输出速率。
接下来，简单地给大家介绍下如何去配置这些参数、它们分别表示什么意思。
一、输入模式：c_iflag
输入模式控制输入数据（终端驱动程序从串口或键盘接收到的字符数据）在被传递给应用程序之前的处理方式。通过设置struct termios结构体中c_iflag成员的标志对它们进行控制。所有的标志都被定义为宏，除c_iflag成员外，c_oflag、c_cflag以及c_lflag成员也都采用这种方式进行配置。
可用于c_iflag成员的宏如下所示：

表 27.1.1 用于c_iflag成员的标志

以上所列举出的这些宏，我们可以通过man手册查询到它们的详细描述信息，执行命令" man 3 termios "，如下图所示：

图 27.1.5 通过man手册查询

二、输出模式：c_oflag
输出模式控制输出字符的处理方式，即由应用程序发送出去的字符数据在传递到串口或屏幕之前是如何处理的。可用于c_oflag成员的宏如下所示：

表 27.1.2 用于c_oflag成员的标志

三、控制模式：c_cflag
控制模式控制终端设备的硬件特性，譬如对于串口来说，该字段比较重要，可设置串口波特率、数据位、校验位、停止位等硬件特性。通过设置struct termios结构中c_cflag成员的标志对控制模式进行配置。可用于c_cflag成员的标志如下所示：

表 27.1.3 用于c_cflag成员的标志

在struct termios结构体中，有一个c_ispeed成员变量和c_ospeed成员变量，在其它一些系统中，可能会使用这两个变量来指定串口的波特率；在Linux系统下，则是使用CBAUD位掩码所选择的几个bit位来指定串口波特率。事实上，termios API中提供了cfgetispeed()和cfsetispeed()函数分别用于获取和设置串口的波特率。
四、本地模式：c_lflag
本地模式用于控制终端的本地数据处理和工作模式。通过设置struct termios结构体中c_lflag成员的标志对本地模式进行配置。可用于c_lflag成员的标志如下所示：

表 27.1.4 用于c_lflag成员的标志

五、特殊控制字符：c_cc
特殊控制字符是一些字符组合，如Ctrl+C、Ctrl+Z等，当用户键入这样的组合键，终端会采取特殊处理方式。struct termios结构体中c_cc数组将各种特殊字符映射到对应的支持函数。每个字符位置（数组下标）由对应的宏定义的，如下所示
VEOF：文件结尾符EOF，对应键为Ctrl+D；该字符使终端驱动程序将输入行中的全部字符传递给正在读取输入的应用程序。如果文件结尾符是该行的第一个字符，则用户程序中的read返回0，表示文件结束。
VEOL：附加行结尾符EOL，对应键为Carriage return（CR）；作用类似于行结束符。
VEOL2：第二行结尾符EOL2，对应键为Line feed（LF）；
VERASE：删除操作符ERASE，对应键为Backspace（BS）；该字符使终端驱动程序删除输入行中的最后一个字符；
VINTR：中断控制字符INTR，对应键为Ctrl+C；该字符使终端驱动程序向与终端相连的进程发送SIGINT信号；
VKILL：删除行符KILL，对应键为Ctrl+U，该字符使终端驱动程序删除整个输入行；
VMIN：在非规范模式下，指定最少读取的字符数MIN；
VQUIT：退出操作符QUIT，对应键为Ctrl+Z；该字符使终端驱动程序向与终端相连的进程发送SIGQUIT信号。
VSTART：开始字符START，对应键为Ctrl+Q；重新启动被STOP暂停的输出。
VSTOP：停止字符STOP，对应键为Ctrl+S；字符作用“截流”，即阻止向终端的进一步输出。用于支持XON/XOFF流控。
VSUSP：挂起字符SUSP，对应键为Ctrl+Z；该字符使终端驱动程序向与终端相连的进程发送SIGSUSP信号，用于挂起当前应用程序。
VTIME：非规范模式下，指定读取的每个字符之间的超时时间（以分秒为单位）TIME。
在以上所列举的这些宏定义中，TIME和MIN值只能用于非规范模式，可用于控制非规范模式下read()调用的一些行为特性，后面再向大家介绍。
六、总结说明
上面已经给大家介绍了struct termios结构体中c_iflag成员（输入模式）、c_oflag成员（输出模式）、c_cflag成员（控制模式）以及c_lflag成员（本地控制）这四个参数，这些参数能够分别控制、影响终端的行为特性。
这里有两个问题需要向大家说明，首先第一个是关于这些成员变量赋值的问题。
对于这些变量尽量不要直接对其初始化，而要将其通过“按位与”、“按位或”等操作添加标志或清除某个标志。譬如，通常不会这样对变量进行初始化：

1. struct termios ter;
   
2. 
   
3. ter.c_iflag = IGNBRK | BRKINT | PARMRK;

复制代码

而是要像下面这样：

1. ter.c_iflag |= (IGNBRK | BRKINT | PARMRK | ISTRIP);

复制代码

说完第一个问题之后，我们来看看第二个问题。
前面我们介绍了很多的标志，但是并非所有标志对于实际的终端设备来说都是有效的，就拿串口终端来说，串口可以配置波特率、数据位、停止位等这些硬件参数，但是其它终端是不一定支持这些配置的，譬如本地终端键盘、显示器，这些设备它是没有这些硬件概念的。
因为这些终端设备都使用了这一套API来编程，然而不同的终端设备，本身硬件上就存在很大的区别，所以会导致这些配置参数并不是对所有终端设备都是有效的。在使用过程中也不需要去搞懂所有标志的作用，事实上，快速掌握一项技术的核心点才是一种学习能力！
27.1.4终端的三种工作模式
当ICANON标志被设置时表示启用终端的规范模式，什么规范模式？这里给大家简单地说明一下。
终端有三种工作模式，分别为规范模式（canonical mode）、非规范模式（non-canonical mode）和原始模式（raw mode）。通过在struct termios结构体的c_lflag成员中设置ICANNON标志来定义终端是以规范模式（设置ICANNON标志）还是以非规范模式（清除ICANNON标志）工作，默认情况为规范模式。
在规范模式下，所有的输入是基于行进行处理的。在用户输入一个行结束符（回车符、EOF等）之前，系统调用read()函数是读不到用户输入的任何字符的。除了EOF之外的行结束符（回车符等）与普通字符一样会被read()函数读取到缓冲区中。在规范模式中，行编辑是可行的，而且一次read()调用最多只能读取一行数据。如果在read()函数中被请求读取的数据字节数小于当前行可读取的字节数，则read()函数只会读取被请求的字节数，剩下的字节下次再被读取。
在非规范模式下，所有的输入是即时有效的，不需要用户另外输入行结束符，而且不可进行行编辑。在非规范模式下，对参数MIN(c_cc[VMIN])和TIME(c_cc[VTIME])的设置决定read()函数的调用方式。
上一小节给大家提到过，TIME和MIN的值只能用于非规范模式，两者结合起来可以控制对输入数据的读取方式。根据TIME和MIN的取值不同，会有以下4种不同情况：
MIN = 0和TIME = 0：在这种情况下，read()调用总是会立即返回。若有可读数据，则读取数据并返回被读取的字节数；否则读取不到任何数据并返回0。
MIN > 0和TIME = 0：在这种情况下，read()函数会被阻塞，直到有MIN个字符可以读取时才返回，返回值是读取的字符数量。到达文件尾时返回0。
MIN = 0和TIME > 0：在这种情况下，只要有数据可读或者经过TIME个十分之一秒的时间，read()函数则立即返回，返回值为被读取的字节数。如果超时并且未读到数据，则read()函数返回0。
MIN > 0和TIME > 0：在这种情况下，当有MIN个字节可读或者两个输入字符之间的时间间隔超过TIME个十分之一秒时，read()函数才返回。因为在输入第一个字符后系统才会启动定时器，所以，在这种情况下，read()函数至少读取一个字节后才返回。
原始模式（Raw mode）
按照严格意义来讲，原始模式是一种特殊的非规范模式。在原始模式下，所有的输入数据以字节为单位被处理。在这个模式下，终端是不可回显的，并且禁用终端输入和输出字符的所有特殊处理。在我们的应用程序中，可以通过调用cfmakeraw()函数将终端设置为原始模式。
cfmakeraw()函数内部其实就是对struct termios结构体进行了如下配置：

1. termios_p->c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
   
2.                 | INLCR | IGNCR | ICRNL | IXON);
   
3. termios_p->c_oflag &= ~OPOST;
   
4. termios_p->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
   
5. termios_p->c_cflag &= ~(CSIZE | PARENB);
   
6. termios_p->c_cflag |= CS8;

复制代码

什么时候会使用原始模式？串口在Linux系统下是作为一种终端设备存在，终端通常会对用户的输入、输出数据进行相应的处理，如前所述！
但是串口并不仅仅只扮演着人机交互的角色（数据以字符的形式传输、也就数说传输的数据其实字符对应的ASCII编码值）；串口本就是一种数据串行传输接口，通过串口可以与其他设备或传感器进行数据传输、通信，譬如很多sensor就使用了串口方式与主机端进行数据交互。那么在这种情况下，我们就得使用原始模式，意味着通过串口传输的数据不应进行任何特殊处理、不应将其解析成ASCII字符。
27.1.5打开串口设备
好了，前面已经向大家详细地介绍了struct termios结构体以及终端的三种工作模式，为我们接下来的要讲解的内容打下了一个基础。从本小节开始，我们来看看如何编写串口应用程序。
首先第一步便是打开串口设备，使用open()函数打开串口的设备节点文件，得到文件描述符：

1. int fd;
   
2. 
   
3. fd = open("/dev/ttymxc2", O_RDWR | O_NOCTTY);
   
4. if (0 > fd) {
   
5.         perror("open error");
   
6.         return -1;
   
7. }

复制代码

调用open()函数时，使用了O_NOCTTY标志，该标志用于告知系统/dev/ttymxc2它不会成为进程的控制终端。
27.1.6获取终端当前的配置参数：tcgetattr()函数
通常，在配置终端之前，我们会先获取到终端当前的配置参数，将其保存到一个struct termios结构体对象中，这样可以在之后、很方便地将终端恢复到原来的状态，这也是为了安全起见以及后续的调试方便。
tcgetattr()函数可以获取到串口终端当前的配置参数，tcgetattr函数原型如下所示（可通过命令"man 3 tcgetattr"查询）：

1. #include <termios.h>
   
2. #include <unistd.h>
   
3. 
   
4. int tcgetattr(int fd, struct termios *termios_p);

复制代码

首先在我们的应用程序中需要包含termios.h头文件和unistd.h头文件。
第一个参数对应串口终端设备的文件描述符fd。
调用tcgetattr函数之前，我们需要定义一个struct termios结构体变量，将该变量的指针作为tcgetattr()函数的第二个参数传入；tcgetattr()调用成功后，会将终端当前的配置参数保存到termios_p指针所指的对象中。
函数调用成功返回0；失败将返回-1，并且会设置errno以告知错误原因。
使用示例如下：

1. struct termios old_cfg;
   
2. 
   
3. if (0 > tcgetattr(fd, &old_cfg)) {
   
4.         /* 出错处理 */
   
5.         do_something();
   
6. }

复制代码

27.1.7对串口终端进行配置
假设我们需要采用原始模式进行串口数据通信。
1)配置串口终端为原始模式
调用<termios.h>头文件中申明的cfmakeraw()函数可以将终端配置为原始模式：

1. struct termios new_cfg;
   
2. 
   
3. memset(&new_cfg, 0x0, sizeof(struct termios));
   
4. 
   
5. //配置为原始模式
   
6. cfmakeraw(&new_cfg);

复制代码

这个函数没有返回值。
2)接收使能
使能接收功能只需在struct termios结构体的c_cflag成员中添加CREAD标志即可，如下所示：

1. new_cfg.c_cflag |= CREAD;                //接收使能

复制代码

3)设置串口的波特率
设置波特率有专门的函数，用户不能直接通过位掩码来操作。设置波特率的主要函数有cfsetispeed()和cfsetospeed()，这两个函数在<termios.h>头文件中申明，使用方法很简单，如下所示：

1. cfsetispeed(&new_cfg, B115200);
   
2. cfsetospeed(&new_cfg, B115200);

复制代码

B115200是一个宏，前面已经给大家介绍了，B115200表示波特率为115200。
cfsetispeed()函数设置数据输入波特率，而cfsetospeed()函数设置数据输出波特率。一般来说，用户需将终端的输入和输出波特率设置成一样的。
除了之外，我们还可以直接使用cfsetspeed()函数一次性设置输入和输出波特率，该函数也是在<termios.h>头文件中申明，使用方式如下：

1. cfsetspeed(&new_cfg, B115200);

复制代码

这几个函数在成功时返回0，失败时返回-1。
4)设置数据位大小
与设置波特率不同，设置数据位大小并没有现成可用的函数，我们需要自己通过位掩码来操作、设置数据位大小。设置方法也很简单，首先将c_cflag成员中CSIZE位掩码所选择的几个bit位清零，然后再设置数据位大小，如下所示：

1. new_cfg.c_cflag &= ~CSIZE;
   
2. new_cfg.c_cflag |= CS8;                //设置为8位数据位

复制代码

5)设置奇偶校验位
通过27.1.3小节的内容可知，串口的奇偶校验位配置一共涉及到struct termios结构体中的两个成员变量：c_cflag和c_iflag。首先对于c_cflag成员，需要添加PARENB标志以使能串口的奇偶校验功能，只有使能奇偶校验功能之后才会对输出数据产生校验位，而对输入数据进行校验检查；同时对于c_iflag成员来说，还需要添加INPCK标志，这样才能对接收到的数据执行奇偶校验，代码如下所示：

1. //奇校验使能
   
2. new_cfg.c_cflag |= (PARODD | PARENB);
   
3. new_cfg.c_iflag |= INPCK;
   
4. 
   
5. //偶校验使能
   
6. new_cfg.c_cflag |= PARENB;
   
7. new_cfg.c_cflag &= ~PARODD; /* 清除PARODD标志，配置为偶校验 */
   
8. new_cfg.c_iflag |= INPCK;
   
9. 
   
10. //无校验
    
11. new_cfg.c_cflag &= ~PARENB;
    
12. new_cfg.c_iflag &= ~INPCK;

复制代码

6)设置停止位
停止位则是通过设置c_cflag成员的CSTOPB标志而实现的。若停止位为一个比特，则清除CSTOPB标志；若停止位为两个，则添加CSTOPB标志即可。以下分别是停止位为一个和两个比特时的代码：

1. // 将停止位设置为一个比特
   
2. new_cfg.c_cflag &= ~CSTOPB;
   
3. 
   
4. // 将停止位设置为2个比特
   
5. new_cfg.c_cflag |= CSTOPB;

复制代码

7)设置MIN和TIME的值
如前面所介绍那样，MIN和TIME的取值会影响非规范模式下read()调用的行为特征，原始模式是一种特殊的非规范模式，所以MIN和TIME在原始模式下也是有效的。
在对接收字符和等待时间没有特别要求的情况下，可以将MIN和TIME设置为0，这样则在任何情况下read()调用都会立即返回，此时对串口的read操作会设置为非阻塞方式，如下所示：

1. new_cfg.c_cc[VTIME] = 0;
   
2. new_cfg.c_cc[VMIN] = 0;

复制代码

27.1.8缓冲区的处理
我们在使用串口之前，需要对串口的缓冲区进行处理，因为在我们使用之前，其缓冲区中可能已经存在一些数据等待处理或者当前正在进行数据传输、接收，所以使用之前，所以需要对此情况进行处理。这时就可以调用<termios.h>中声明的tcdrain()、tcflow()、tcflush()等函数来处理目前串口缓冲中的数据，它们的函数原型如下所示：

1. #include <termios.h>
   
2. #include <unistd.h>
   
3. 
   
4. int tcdrain(int fd);
   
5. int tcflush(int fd, int queue_selector);
   
6. int tcflow(int fd, int action);

复制代码

调用tcdrain()函数后会使得应用程序阻塞，直到串口输出缓冲区中的数据全部发送完毕为止！
调用tcflow()函数会暂停串口上的数据传输或接收工作，具体情况取决于参数action，参数action可取值如下：
TCOOFF：暂停数据输出（输出传输）；
TCOON：重新启动暂停的输出；
TCIOFF：发送STOP字符，停止终端设备向系统发送数据；
TCION：发送一个START字符，启动终端设备向系统发送数据；
再来看看tcflush()函数，调用该函数会清空输入/输出缓冲区中的数据，具体情况取决于参数queue_selector，参数queue_selector可取值如下：
TCIFLUSH：对接收到而未被读取的数据进行清空处理；
TCOFLUSH：对尚未传输成功的输出数据进行清空处理；
TCIOFLUSH：包括前两种功能，即对尚未处理的输入/输出数据进行清空处理。
以上这三个函数，调用成功时返回0；失败将返回-1、并且会设置errno以指示错误类型。
通常我们会选择tcdrain()或tcflush()函数来对串口缓冲区进行处理。譬如直接调用tcdrain()阻塞：

1. tcdrain(fd);

复制代码

或者调用tcflush()清空缓冲区：

1. tcflush(fd, TCIOFLUSH);

复制代码

27.1.9写入配置、使配置生效：tcsetattr()函数
前面已经完成了对struct termios结构体各个成员进行配置，但是配置还未生效，我们需要将配置参数写入到终端设备（串口硬件），使其生效。通过tcsetattr()函数将配置参数写入到硬件设备，其函数原型如下所示：

1. #include <termios.h>
   
2. #include <unistd.h>
   
3. 
   
4. int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);

复制代码

调用该函数会将参数termios_p所指struct termios对象中的配置参数写入到终端设备中，使配置生效！
而参数optional_actions可以指定更改何时生效，其取值如下：
TCSANOW：配置立即生效。
TCSADRAIN：配置在所有写入fd的输出都传输完毕之后生效。
TCSAFLUSH：所有已接收但未读取的输入都将在配置生效之前被丢弃。
该函数调用成功时返回0；失败将返回-1,、并设置errno以指示错误类型。
譬如，调用tcsetattr()将配置参数写入设备，使其立即生效：

1. tcsetattr(fd, TCSANOW, &new_cfg);

复制代码

27.1.10读写数据：read()、write()
所有准备工作完成之后，接着便可以读写数据了，直接调用read()、write()函数即可！
27.2串口应用编程实战
通过上一节的介绍，详细大家已经知道了如何对串口进行应用编程，其实总的来说还是非常简单地，本小节我们进行编程实战，在串口终端的原始模式下，使用串口进行数据传输，包括通过串口发送数据、以及读取串口接收到的数据，并将其打印出来。
示例代码笔者已经写好了，如下所示：
本例程源码对应的路径为：开发板光盘->11、Linux C应用编程例程源码->27_uart->uart_test.c。
示例代码 27.2.1 串口数据传输示例代码

1. /***************************************************************
   
2. Copyright &#169; ALIENTEK Co., Ltd. 1998-2021. All rights reserved.
   
3. 文件名 : uart_test.c
   
4. 作者 : 邓涛
   
5. 版本 : V1.0
   
6. 描述 : 串口在原始模式下进行数据传输--应用程序示例代码
   
7. 其他 : 无
   
8. 论坛 : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
   
9. 日志 : 初版 V1.0 2021/7/20 邓涛创建
   
10. ***************************************************************/
    
11. 
    
12. #define _GNU_SOURCE     //在源文件开头定义_GNU_SOURCE宏
    
13. #include <stdio.h>
    
14. #include <stdlib.h>
    
15. #include <sys/types.h>
    
16. #include <sys/stat.h>
    
17. #include <fcntl.h>
    
18. #include <unistd.h>
    
19. #include <sys/ioctl.h>
    
20. #include <errno.h>
    
21. #include <string.h>
    
22. #include <signal.h>
    
23. #include <termios.h>
    
24. 
    
25. typedef struct uart_hardware_cfg {
    
26.     unsigned int baudrate;      /* 波特率 */
    
27.     unsigned char dbit;         /* 数据位 */
    
28.     char parity;                /* 奇偶校验 */
    
29.     unsigned char sbit;         /* 停止位 */
    
30. } uart_cfg_t;
    
31. 
    
32. static struct termios old_cfg;  //用于保存终端的配置参数
    
33. static int fd;      //串口终端对应的文件描述符
    
34. 
    
35. /**
    
36. ** 串口初始化操作
    
37. ** 参数device表示串口终端的设备节点
    
38. **/
    
39. static int uart_init(const char *device)
    
40. {
    
41.     /* 打开串口终端 */
    
42.     fd = open(device, O_RDWR | O_NOCTTY);
    
43.     if (0 > fd) {
    
44.         fprintf(stderr, "open error: %s: %s\n", device, strerror(errno));
    
45.         return -1;
    
46.     }
    
47. 
    
48.     /* 获取串口当前的配置参数 */
    
49.     if (0 > tcgetattr(fd, &old_cfg)) {
    
50.         fprintf(stderr, "tcgetattr error: %s\n", strerror(errno));
    
51.         close(fd);
    
52.         return -1;
    
53.     }
    
54. 
    
55.     return 0;
    
56. }
    
57. 
    
58. /**
    
59. ** 串口配置
    
60. ** 参数cfg指向一个uart_cfg_t结构体对象
    
61. **/
    
62. static int uart_cfg(const uart_cfg_t *cfg)
    
63. {
    
64.     struct termios new_cfg = {0};   //将new_cfg对象清零
    
65.     speed_t speed;
    
66. 
    
67.     /* 设置为原始模式 */
    
68.     cfmakeraw(&new_cfg);
    
69. 
    
70.     /* 使能接收 */
    
71.     new_cfg.c_cflag |= CREAD;
    
72. 
    
73.     /* 设置波特率 */
    
74.     switch (cfg->baudrate) {
    
75.     case 1200: speed = B1200;
    
76.         break;
    
77.     case 1800: speed = B1800;
    
78.         break;
    
79.     case 2400: speed = B2400;
    
80.         break;
    
81.     case 4800: speed = B4800;
    
82.         break;
    
83.     case 9600: speed = B9600;
    
84.         break;
    
85.     case 19200: speed = B19200;
    
86.         break;
    
87.     case 38400: speed = B38400;
    
88.         break;
    
89.     case 57600: speed = B57600;
    
90.         break;
    
91.     case 115200: speed = B115200;
    
92.         break;
    
93.     case 230400: speed = B230400;
    
94.         break;
    
95.     case 460800: speed = B460800;
    
96.         break;
    
97.     case 500000: speed = B500000;
    
98.         break;
    
99.     default:    //默认配置为115200
    
100.         speed = B115200;
     
101.         printf("default baud rate: 115200\n");
     
102.         break;
     
103.     }
     
104. 
     
105.     if (0 > cfsetspeed(&new_cfg, speed)) {
     
106.         fprintf(stderr, "cfsetspeed error: %s\n", strerror(errno));
     
107.         return -1;
     
108.     }
     
109. 
     
110.     /* 设置数据位大小 */
     
111.     new_cfg.c_cflag &= ~CSIZE;  //将数据位相关的比特位清零
     
112.     switch (cfg->dbit) {
     
113.     case 5:
     
114.         new_cfg.c_cflag |= CS5;
     
115.         break;
     
116.     case 6:
     
117.         new_cfg.c_cflag |= CS6;
     
118.         break;
     
119.     case 7:
     
120.         new_cfg.c_cflag |= CS7;
     
121.         break;
     
122.     case 8:
     
123.         new_cfg.c_cflag |= CS8;
     
124.         break;
     
125.     default:    //默认数据位大小为8
     
126.         new_cfg.c_cflag |= CS8;
     
127.         printf("default data bit size: 8\n");
     
128.         break;
     
129.     }
     
130. 
     
131.     /* 设置奇偶校验 */
     
132.     switch (cfg->parity) {
     
133.     case 'N':       //无校验
     
134.         new_cfg.c_cflag &= ~PARENB;
     
135.         new_cfg.c_iflag &= ~INPCK;
     
136.         break;
     
137.     case 'O':       //奇校验
     
138.         new_cfg.c_cflag |= (PARODD | PARENB);
     
139.         new_cfg.c_iflag |= INPCK;
     
140.         break;
     
141.     case 'E':       //偶校验
     
142.         new_cfg.c_cflag |= PARENB;
     
143.         new_cfg.c_cflag &= ~PARODD; /* 清除PARODD标志，配置为偶校验 */
     
144.         new_cfg.c_iflag |= INPCK;
     
145.         break;
     
146.     default:    //默认配置为无校验
     
147.         new_cfg.c_cflag &= ~PARENB;
     
148.         new_cfg.c_iflag &= ~INPCK;
     
149.         printf("default parity: N\n");
     
150.         break;
     
151.     }
     
152. 
     
153.     /* 设置停止位 */
     
154.     switch (cfg->sbit) {
     
155.     case 1:     //1个停止位
     
156.         new_cfg.c_cflag &= ~CSTOPB;
     
157.         break;
     
158.     case 2:     //2个停止位
     
159.         new_cfg.c_cflag |= CSTOPB;
     
160.         break;
     
161.     default:    //默认配置为1个停止位
     
162.         new_cfg.c_cflag &= ~CSTOPB;
     
163.         printf("default stop bit size: 1\n");
     
164.         break;
     
165.     }
     
166. 
     
167.     /* 将MIN和TIME设置为0 */
     
168.     new_cfg.c_cc[VTIME] = 0;
     
169.     new_cfg.c_cc[VMIN] = 0;
     
170. 
     
171.     /* 清空缓冲区 */
     
172.     if (0 > tcflush(fd, TCIOFLUSH)) {
     
173.         fprintf(stderr, "tcflush error: %s\n", strerror(errno));
     
174.         return -1;
     
175.     }
     
176. 
     
177.     /* 写入配置、使配置生效 */
     
178.     if (0 > tcsetattr(fd, TCSANOW, &new_cfg)) {
     
179.         fprintf(stderr, "tcsetattr error: %s\n", strerror(errno));
     
180.         return -1;
     
181.     }
     
182. 
     
183.     /* 配置OK 退出 */
     
184.     return 0;
     
185. }
     
186. 
     
187. /***
     
188. --dev=/dev/ttymxc2
     
189. --brate=115200
     
190. --dbit=8
     
191. --parity=N
     
192. --sbit=1
     
193. --type=read
     
194. ***/
     
195. /**
     
196. ** 打印帮助信息
     
197. **/
     
198. static void show_help(const char *app)
     
199. {
     
200.     printf("Usage: %s [选项]\n"
     
201.         "\n必选选项:\n"
     
202.         "  --dev=DEVICE     指定串口终端设备名称, 譬如--dev=/dev/ttymxc2\n"
     
203.         "  --type=TYPE      指定操作类型, 读串口还是写串口, 譬如--type=read(read表示读、write表示写、其它值无效)\n"
     
204.         "\n可选选项:\n"
     
205.         "  --brate=SPEED    指定串口波特率, 譬如--brate=115200\n"
     
206.         "  --dbit=SIZE      指定串口数据位个数, 譬如--dbit=8(可取值为: 5/6/7/8)\n"
     
207.         "  --parity=PARITY  指定串口奇偶校验方式, 譬如--parity=N(N表示无校验、O表示奇校验、E表示偶校验)\n"
     
208.         "  --sbit=SIZE      指定串口停止位个数, 譬如--sbit=1(可取值为: 1/2)\n"
     
209.         "  --help           查看本程序使用帮助信息\n\n", app);
     
210. }
     
211. 
     
212. /**
     
213. ** 信号处理函数，当串口有数据可读时，会跳转到该函数执行
     
214. **/
     
215. static void io_handler(int sig, siginfo_t *info, void *context)
     
216. {
     
217.     unsigned char buf[10] = {0};
     
218.     int ret;
     
219.     int n;
     
220. 
     
221.     if(SIGRTMIN != sig)
     
222.         return;
     
223. 
     
224.     /* 判断串口是否有数据可读 */
     
225.     if (POLL_IN == info->si_code) {
     
226.         ret = read(fd, buf, 8);     //一次最多读8个字节数据
     
227.         printf("[ ");
     
228.         for (n = 0; n < ret; n++)
     
229.             printf("0x%hhx ", buf[n]);
     
230.         printf("]\n");
     
231.     }
     
232. }
     
233. 
     
234. /**
     
235. ** 异步I/O初始化函数
     
236. **/
     
237. static void async_io_init(void)
     
238. {
     
239.     struct sigaction sigatn;
     
240.     int flag;
     
241. 
     
242.     /* 使能异步I/O */
     
243.     flag = fcntl(fd, F_GETFL);  //使能串口的异步I/O功能
     
244.     flag |= O_ASYNC;
     
245.     fcntl(fd, F_SETFL, flag);
     
246. 
     
247.     /* 设置异步I/O的所有者 */
     
248.     fcntl(fd, F_SETOWN, getpid());
     
249. 
     
250.     /* 指定实时信号SIGRTMIN作为异步I/O通知信号 */
     
251.     fcntl(fd, F_SETSIG, SIGRTMIN);
     
252. 
     
253.     /* 为实时信号SIGRTMIN注册信号处理函数 */
     
254.     sigatn.sa_sigaction = io_handler;   //当串口有数据可读时，会跳转到io_handler函数
     
255.     sigatn.sa_flags = SA_SIGINFO;
     
256.     sigemptyset(&sigatn.sa_mask);
     
257.     sigaction(SIGRTMIN, &sigatn, NULL);
     
258. }
     
259. 
     
260. int main(int argc, char *argv[])
     
261. {
     
262.     uart_cfg_t cfg = {0};
     
263.     char *device = NULL;
     
264.     int rw_flag = -1;
     
265.     unsigned char w_buf[10] = {0x11, 0x22, 0x33, 0x44,
     
266.                 0x55, 0x66, 0x77, 0x88};    //通过串口发送出去的数据
     
267.     int n;
     
268. 
     
269.     /* 解析出参数 */
     
270.     for (n = 1; n < argc; n++) {
     
271. 
     
272.         if (!strncmp("--dev=", argv[n], 6))
     
273.             device = &argv[n][6];
     
274.         else if (!strncmp("--brate=", argv[n], 8))
     
275.             cfg.baudrate = atoi(&argv[n][8]);
     
276.         else if (!strncmp("--dbit=", argv[n], 7))
     
277.             cfg.dbit = atoi(&argv[n][7]);
     
278.         else if (!strncmp("--parity=", argv[n], 9))
     
279.             cfg.parity = argv[n][9];
     
280.         else if (!strncmp("--sbit=", argv[n], 7))
     
281.             cfg.sbit = atoi(&argv[n][7]);
     
282.         else if (!strncmp("--type=", argv[n], 7)) {
     
283.             if (!strcmp("read", &argv[n][7]))
     
284.                 rw_flag = 0;        //读
     
285.             else if (!strcmp("write", &argv[n][7]))
     
286.                 rw_flag = 1;        //写
     
287.         }
     
288.         else if (!strcmp("--help", argv[n])) {
     
289.             show_help(argv[0]); //打印帮助信息
     
290.             exit(EXIT_SUCCESS);
     
291.         }
     
292.     }
     
293. 
     
294.     if (NULL == device || -1 == rw_flag) {
     
295.         fprintf(stderr, "Error: the device and read|write type must be set!\n");
     
296.         show_help(argv[0]);
     
297.         exit(EXIT_FAILURE);
     
298.     }
     
299. 
     
300.     /* 串口初始化 */
     
301.     if (uart_init(device))
     
302.         exit(EXIT_FAILURE);
     
303. 
     
304.     /* 串口配置 */
     
305.     if (uart_cfg(&cfg)) {
     
306.         tcsetattr(fd, TCSANOW, &old_cfg);   //恢复到之前的配置
     
307.         close(fd);
     
308.         exit(EXIT_FAILURE);
     
309.     }
     
310. 
     
311.     /* 读|写串口 */
     
312.     switch (rw_flag) {
     
313.     case 0:  //读串口数据
     
314.         async_io_init();        //我们使用异步I/O方式读取串口的数据，调用该函数去初始化串口的异步I/O
     
315.         for ( ; ; )
     
316.             sleep(1);           //进入休眠、等待有数据可读，有数据可读之后就会跳转到io_handler()函数
     
317.         break;
     
318.     case 1:   //向串口写入数据
     
319.         for ( ; ; ) {                   //循环向串口写入数据
     
320.             write(fd, w_buf, 8);         //一次向串口写入8个字节
     
321.             sleep(1);                       //间隔1秒钟
     
322.         }
     
323.         break;
     
324.     }
     
325. 
     
326.     /* 退出 */
     
327.     tcsetattr(fd, TCSANOW, &old_cfg);   //恢复到之前的配置
     
328.     close(fd);
     
329.     exit(EXIT_SUCCESS);
     
330. }

复制代码

代码稍稍有点长，不过与串口相关的代码并不是很多，代码中所涉及到的所有内容在前面的章节中都给大家详细介绍过。
首先来看下main()函数，进入到main()函数之后有一个for()循环，这是对用户传参进行了解析，我们这个应用程序设计的时候，允许用户传入相应的参数，譬如用户可以指定串口终端的设备节点、串口波特率、数据位个数、停止位个数、奇偶校验等，具体的使用方法，大家可以看一看show_help()函数。
接下来调用了uart_init()函数，这是一个自定义的函数，用于初始化串口，实际上就做了两件事：打开串口终端设备、获取串口终端当前的配置参数，将其保存到old_cfg变量中。
接着调用uart_cfg()函数，这也是一个自定义函数，用于对串口进行配置，包括将串口配置为原始模式、使能串口接收、设置串口波特率、数据位个数、停止位个数、奇偶校验，以及MIN和TIME值的设置，最后清空缓冲区，将配置参数写入串口设备使其生效，具体的代码大家自己去看，代码的注释都已经写的很清楚了！
最后根据用户传参中，--type选项所指定类型进行读串口或写串口操作，如果--type=read表示本次测试是进行串口读取操作，如果--type=write表示本次测试是进行串口写入操作。
对于读取串口数据，程序使用了异步I/O的方式读取数据，首先调用async_io_init()函数对异步I/O进行初始化，注册信号处理函数。当检测到有数据可读时，会跳转到信号处理函数io_handler()执行，在这个函数中读取串口的数据并将其打印出来，这里需要注意的是，本例程一次最多读取8个字节数据，如果可读数据大于8个字节，多余的数据会在下一次read()调用时被读取出来。
对于写操作，我们直接调用write()函数，每隔一秒钟向串口写入8个字节数据[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88]。
好了，这个示例代码就给大家介绍完了，非常简单，没什么难点，相信各位聪明的读者绝对能看懂！如果看不懂？那可能就……呵呵了！
接下来我们要编译示例代码：

图 27.2.1 编译示例代码

27.3在开发板上进行测试
将上小节编译得到的可执行文件拷贝到开发板Linux系统/home/root目录下，如下所示：

图 27.3.1 将串口测试程序拷贝到开发板

ALPHA I.MX6U开发板上一共预留出了两个串口，一个USB串口（对应I.MX6U的UART1）、一个RS232/RS485串口（对应I.MX6U的UART3），如图 27.3.2和图 27.3.3所示。

图 27.3.2 RS232/RS485串口

图 27.3.3 USB串口

注意，板子上的485和232接口是共用了I.MX6U的UART3，这两个接口无法同时使用，可通过配置底板上的JP1端子来使能RS232或RS485接口，使用跳线帽将每一列上面的两个针脚连接起来，此时RS232接口被使能、而RS485接口不能使用；如果使用跳线帽将下面两个针脚连接起来，如图 27.3.2中所示，则此时RS485接口被使能、RS232接口不能使用。
本次测试笔者使用RS232串口，注意不能使用USB串口进行测试，它是系统的控制台终端。由于Mini开发板只有一个USB串口，没有RS232或RS485接口，所以不太好测试，当然并不是说没有办法进行测试；虽然Mini板上没有232或485接口，但是串口用到的I/O都已经通过扩展口引出了，你使用一个USB转TTL模块也是可以测试的。
将板上的RS232接口通过<USB转RS232>串口线连接到PC机。
接下来进行测试，首先执行如下命令查看测试程序的帮助信息：

1. ./testApp --help

复制代码

图 27.3.4 查看测试程序的帮助信息

可选选项表示是可选的，如果没有指定则会使用默认值！
先进行读测试：

1. ./testApp --dev=/dev/ttymxc2 --type=read

复制代码

图 27.3.5 读测试

执行测试程序时，笔者没有指定波特率、数据位个数、停止位个数以及奇偶校验等，程序将使用默认的配置，波特率115200、数据位个数为8、停止位个数为1、无校验！
程序执行之后，在Windows下打开串口调试助手上位机软件，譬如正点原子的XCOM串口调试助手：

图 27.3.6 串口调试助手

打开XCOM之后，对其进行配置、并打开串口，如下所示：

图 27.3.7 配置上位机并打开串口

点击发送按钮向开发板RS232串口发送8个字节数据[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88]，此时我们的应用程序便会读取到串口的数据，这些数据就是PC机串口调试助手发送过来的数据，如下所示：

图 27.3.8 应用程序读取到串口的数据

测试完读串口后，我们再来测试向串口写数据，按Ctrl+C结束测试程序，再次执行测试程序，本次测试写串口，如下所示：

1. ./testApp --dev=/dev/ttymxc2 --type=write

复制代码

图 27.3.9 测试写串口

执行测试程序后，测试程序会每隔1秒中将8个字节数据[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88]写入到RS232串口，此时PC端串口调试助手便会接收到这些数据，如下所示：

图 27.3.10 串口调试助手接收到开发板RS232串口发送过来的数据

本章内容到此结束！

lijia1999

源码在哪可以下载呢

yijiu98

v1.2版本应用开发怎么还没有更行啊