C语言串口编程收发数据 并实现AT指令的收发 可变参数控制串口属性 树莓派4G模块_at 指令程序 c语言

对于Linux，我们都知道Linux下皆为文件，这当然也包括我们今天的主角——串口。因此对串口的操作都和对文件的操作一样(涉及到了open,read, write,close 等文件的基本操作）。

一、 Linux下串口编程的流程

串口编程可以简单概括为如下几个步骤：

​ 1.打开串口
​ 2.串口初始化
​ 3.读串口或写串口
​ 4.关闭串口

1.打开串口

既然串口在linux中被看作文件，那么在对文件进行操作前必要先对其进行打开操作。

在 Linxu中，串口设备是通过串口终端设备文件来访问的，即通过访问/dev/tty***这些设备文件实现对串口的访问。

调用open()函数来代开串口设备，通常对于串口的打开操作一般使用如下参数。其中O_NOCTTY又是必不可少的。

• O_RDWR：以可读可写的方式打开文件。

• O_NOCTTY：表示打开的是一个终端设备，程序不会成为该端口的控制终端。如果不使用此标志，任务一个输入(eg:键盘中止信号等)都将影响进程。

• O_NDELAY：表示不关心DCD信号线所处的状态(端口的另一端是否激活或者停止)。

 open("/dev/ttyUSB5", O_RDWR | O_NOCTTY | O_NDELAY) ; //打开串口设备
1

2. 串口初始化

在初始化串口之前，我们不得不掌握一些必要的知识。内容比较多，我就不在这里整理了。下面是一位好心人整理的有关串口属性的一些相关知识，不是很了解的可以look look

https://blog.csdn.net/qq_37932504/article/details/121125906

2.1 常用函数总览

#include <termios.h>
#include <unistd.h>

int tcgetattr(int fd, struct termios *termios_p); //用于获取与终端相关的参数

int tcsetattr(int fd, int optional_actions, struct termios *termios_p); //用于设置终端参数

int tcdrain(int fd); //等待直到所有写入 fd 引用的对象的输出都被传输

int tcflush(int fd, int queue_selector); //刷清(扔掉)输入缓存

int tcflow(int fd, int action); //挂起传输或接受

int cfmakeraw(struct termios *termios_p);// 制作新的终端控制属性

speed_t cfgetispeed(struct termios *termios_p); //得到输入波特率

speed_t cfgetospeed(struct termios *termios_p); //得到输出波特率

int cfsetispeed(struct termios *termios_p, speed_t speed); //设置输入波特率

int cfsetospeed(struct termios *termios_p, speed_t speed) //设置输出波特率

int tcsendbreak(int fd, int duration);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这里，我们可以看到有一个结构体struct termios现身于绝大多数的函数中，它的重要性就不言而喻了。。。

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 特殊控制字符是一些字符组合，如 Ctrl+C、 Ctrl+Z 等， 当用户键入这样的组合键，终端会采取特殊处理方式。*/
    speed_t c_ispeed;	 /* input speed 输入波特率*/
    speed_t c_ospeed;	 /* output speed 输出波特率*/
};
1
2
3
4
5
6
7
8
9
10
11

注：对于这些变量尽量不要直接对其初始化，而要将其通过“按位与”、“按位或” 等操作添加标志或清除某个标志。

注：不同的终端设备，本身硬件上就存在很大的区别，所以配置参数不是对所有终端设备都是有效的。

2.2 初始化

当然这里只是简单的初始化过程，没有什么可变性，只是一种固定的串口配置，这样只是便于理解罢了

tcgetattr(fd, &oldtermios); //获取原有的串口属性，以便后面可以恢复
tcgetattr(fd, &newtermios); //获取原有的串口属性，以此为基修改串口属性

newtermios.c_cflag|=(CLOCAL|CREAD );  // CREAD 开启串行数据接收，CLOCAL并打开本地连接模式
/*  For example:
 *   
 *      c_cflag:   0 0 0 0 1 0 0 0
 *      CLOCAL:  | 0 0 0 1 0 0 0 0
 *              --------------------
 *                 0 0 0 1 1 0 0 0
 *
 * */

newtermios.c_cflag &=~CSIZE;          // 先清零数据位
/*  For example:
 *
 *      CSIZE = 0 1 1 1 0 0 0 0 ---> ~CSIZE = 1 0 0 0 1 1 1 1
 *
 *      c_cflag:    0 0 1 0 1 1 0 0
 *      ~CSIZE:  &  1 0 0 0 1 1 1 1     
 *              -----------------------
 *                  0 0 0 0 1 1 0 0
 *
 * 这样与数据位无关的部分就保留了下来，单单把数据位全部清零了
 *
 * */

newtermios.c_cflag |= CS8;            //设置8bits数据位

newtermios.c_cflag &= ~PARENB;        //无校验位

/* 设置9600波特率  */
cfsetispeed(&newtermios, B9600);
cfsetospeed(&newtermios, B9600);

newtermios.c_cflag &= ~CSTOPB;       // 设置1位停止位

newtermios.c_cc[VTIME] = 0; 		// 非规范模式读取时的超时时间
newtermios.c_cc[VMIN]  = 0; 		// 非规范模式读取时的最小字符数

tcflush(fd ,TCIFLUSH);/* tcflush清空终端未完成的输入/输出请求及数据；TCIFLUSH表示清空正收到的数据，且不读取出来 */

tcsetattr(fd, TCSANOW, &newtermios);  //设置串口属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

3. 串口的读写

​ 串口的读写就比较简单了，像上面我们说的一样Linux下皆为文件。因此对串口调用read, write就行了。因为无论是读还是写，我们都是对同一串口进行操作的，所以在这里就不分程序操作了，而是使用select多路复用来实现自发自收的功能。

while(1)
{
        FD_ZERO(&fdset);
        FD_SET(fd, &fdset);				//文件描述符
        FD_SET(STDIN_FILENO, &fdset);  //标准输入

        rv = select(fd+1, &fdset, NULL, NULL, NULL);
        if(rv < 0)
        {
            printf("select() failed: %s\n", strerror(errno));
            goto cleanup;
        }

        if(rv == 0)
        {
            printf("select() time out!\n");
            goto cleanup;
        }
        
/* ----------写串口 -----------*/
        if(FD_ISSET(STDIN_FILENO, &fdset))
        {
                memset(wr_buf, 0, sizeof(wr_buf));
                fgets(wr_buf, sizeof(wr_buf), stdin);

                rv = write(fd, wr_buf, strlen(wr_buf));
                if(rv < 0)
                {
                        printf("Write() error:%s\n",strerror(errno));
                        goto cleanup;
                }
         }

/* -----------读串口----------- */
         if(FD_ISSET(fd, &fdset))
         {
                memset(rd_buf, 0, sizeof(rd_buf));
                rv = read(fd, rd_buf, sizeof(rd_buf));
                if(rv <= 0)
                {
                       printf("Read() error:%s\n",strerror(errno));
                       goto cleanup;
                }

                printf("Read %d bytes data from serial port: %s\n", rv, rd_buf);
          }
          sleep(5);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

4. 串口关闭

串口关闭就比较简单了，但是不要忘记了一件重要的事情哦~

恢复原有的串口属性~~

tcsetattr(fd, TCSANOW, &newtermios);  //恢复默认的串口属性

close(fd);
1
2
3

二、代码——串口编程实现自发自收

将上面的代码结合如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <sys/types.h>

int main(int argc, char **argv)
{
    int                 fd, rv;
    char                wr_buf[128];
    char                rd_buf[128];
    fd_set              fdset;
    struct termios      oldtermios;
    struct termios      newtermios;

    fd = open("/dev/ttyUSB5", O_RDWR | O_NOCTTY | O_NDELAY) ; //打开串口设备
    if(fd < 0)
    {
        printf("open failure: %s\n", strerror(errno));

                goto cleanup;
    }

    printf("Open sucess!\n") ;

    memset(&newtermios, 0, sizeof(newtermios)) ;

    rv = tcgetattr(fd, &oldtermios); //获取原有串口属性
    rv = tcgetattr(fd, &newtermios); //获取原有串口属性，并在此更改
    if(rv != 0)
    {
        printf("tcgetattr() failure:%s\n", strerror(errno)) ;

        goto cleanup;
    }

    newtermios.c_cflag|=(CLOCAL|CREAD );        // CREAD 开启串行数据接收，CLOCAL并打开本地连接模式

    newtermios.c_cflag &=~CSIZE;                        // 先清零数据位

    newtermios.c_cflag |= CS8;                          //设置8bits数据位

    newtermios.c_cflag &= ~PARENB;                      //无校验位

    /* 设置9600波特率  */
    cfsetispeed(&newtermios, B9600);
    cfsetospeed(&newtermios, B9600);

    newtermios.c_cflag &= ~CSTOPB;              // 设置1位停止位

    newtermios.c_cc[VTIME] = 0; // 非规范模式读取时的超时时间
    newtermios.c_cc[VMIN]  = 0; // 非规范模式读取时的最小字符数

    tcflush(fd ,TCIFLUSH);/* tcflush清空终端未完成的输入/输出请求及数据；TCIFLUSH表示清空正收到的数据，且不读取出来 */

    if((tcsetattr(fd, TCSANOW,&newtermios))!=0)
    {
        printf("tcsetattr failed:%s\n", strerror(errno));
        goto cleanup ;
    }

    while(1)
    {
        FD_ZERO(&fdset);
        FD_SET(fd, &fdset);
        FD_SET(STDIN_FILENO, &fdset);

        rv = select(fd+1, &fdset, NULL, NULL, NULL);
        if(rv < 0)
        {
            printf("select() failed: %s\n", strerror(errno));
            goto cleanup;
        }

        if(rv == 0)
        {
            printf("select() time out!\n");

            goto cleanup;
        }
        
        /* ------写串口 ------*/
        if(FD_ISSET(STDIN_FILENO, &fdset))
        {
                memset(wr_buf, 0, sizeof(wr_buf));
                fgets(wr_buf, sizeof(wr_buf), stdin);

                rv = write(fd, wr_buf, strlen(wr_buf));
                if(rv < 0)
                {
                        printf("Write() error:%s\n",strerror(errno));
                        goto cleanup;
                }
         }

         /* ------读串口------ */
         if(FD_ISSET(fd, &fdset))
         {
                memset(rd_buf, 0, sizeof(rd_buf));
                rv = read(fd, rd_buf, sizeof(rd_buf));
                if(rv <= 0)
                {
                       printf("Read() error:%s\n",strerror(errno));
                       goto cleanup;
                }

                printf("Read %d bytes data from serial port: %s\n", rv, rd_buf);
          }
      }

cleanup:
    tcsetattr(fd, TCSANOW,&oldtermios);  //恢复默认属性
    close(fd);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

如下图所示，是代码的运行结果：这里我们可以看到，收到的确实就是发送的消息，但是返回值却是比我们肉眼可见的字符长度多了“1”，这其实是因为，我们在获取标准输入的字符串的时候，在最后还接受了一个“\n”的换行符。这里可以去了解一下fgets()函数的使用方法。

三、可变参数控制串口属性的函数封装

但是要知道的是，我们操作串口的时候，对于串口属性的设置参数不是一尘不变的，所以为了提高代码的可重用性，我们可以使用可变参数来设置串口的属性~~

3.1 头文件——serial_port.h

#ifndef  _SERIALPORT_H_
#define  _SERIALPORT_H_

#define SERIALNAME_LEN 128

typedef struct attr_s{
        int             flow_ctrl;                      //流控制
        int             baud_rate;                      //波特率
        int             data_bits;                      //数据位
        char            parity;                         //奇偶校验位
        int             stop_bits;                      //停止位
}attr_t;

extern int serial_open(char *fname);						//打开串口
extern int serial_close(int fd, struct termios *termios_p);		//关闭串口
extern int serial_init(int fd, struct termios *oldtermios, attr_t *attr);  //串口初始化
extern int serial_send(int fd, char *msg, int msg_len);		//写数据到串口
extern int serial_recv(int fd, char *recv_msg, int size);	//接收串口数据

#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

这里封装了一个结构体，将所有需要用到的串口属性都放在了里面，这样，我在设计后面的函数时，就可以直接传结构体指针，再根据功能的实际要求，使用自己需要的成员即可。

3.2 函数定义——serial_port.c

打开串口——serial_open

int serial_open(char *fname)
{
    int fd, rv;

    if(NULL == fname)
    {
        printf("%s,Invalid parameter\n",__func__);
        return -1;
    }

    if((fd = open(fname,O_RDWR|O_NOCTTY|O_NDELAY)) < 0)
    {
        printf("Open %s failed: %s\n",fname, strerror(errno));

        return -1;
    }

    /* 判断串口的状态是否处于阻塞态*/
    if((rv = fcntl(fd, F_SETFL, 0)) < 0)
    {
        printf("fcntl failed!\n");

        return -2;
    }
    else
    {
        printf("fcntl=%d\n",rv);
    }

    if(0 == isatty(fd))  //是否为终端设备
    {
        printf("%s:[%d] is not a Terminal equipment.\n", fname, fd);
        return -3;
    }

    printf("Open %s successfully!\n", fname);

    return fd;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

关闭串口——serial_close

int serial_close (int fd, struct termios *termios_p)
{
    /* 清空串口通信的缓冲区 */
    if(tcflush(fd,TCIOFLUSH))
    {
        printf("%s, tcflush() fail: %s\n", __func__, strerror(errno));
        return -1;
    }

    /* 将串口设置为原有属性, 立即生效 */
    if(tcsetattr(fd,TCSANOW,termios_p))
    {
        printf("%s, set old options fail: %s\n",__func__,strerror(errno));
        return -2;
    }

    close(fd);
        printf("close OK..............");

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

串口初始化——serial_init

int serial_init(int fd, struct termios *oldtermios, struct attr_s  *attr)
{
    char                  baudrate[32] = {0};
    struct termios        newtermios;

    memset(&newtermios,0,sizeof(struct termios));
    memset(oldtermios,0,sizeof(struct termios));

    if(!attr)
    {
        printf("%s invalid parameter.\n", __func__);
        return -1;
    }

    /* 获取默认串口属性 */
    if(tcgetattr(fd, oldtermios))
    {
        printf("%s, get termios to oldtermios failure:%s\n",__func__,strerror(errno));
        return -2;
    }

    /* 先获取默认属性，后在此基础上修改 */
    if(tcgetattr(fd, &newtermios))
    {
        printf("%s, get termios to newtermios failure:%s\n",__func__,strerror(errno));
        return -3;
    }


    /* 修改控制模式，保证程序不会占用串口 */
    newtermios.c_cflag |= CLOCAL;


    /* 启动接收器，能够从串口中读取输入数据 */
    newtermios.c_cflag |= CREAD;



    /*
     * ICANON: 标准模式
     * ECHO: 回显所输入的字符
     * ECHOE: 如果同时设置了ICANON标志，ERASE字符删除前一个所输入的字符，WERASE删除前一个输入的单词
     * ISIG: 当接收到INTR/QUIT/SUSP/DSUSP字符，生成一个相应的信号
     *
     * 在原始模式下，串口输入数据是不经过处理的，在串口接口接收的数据被完整保留。

    newtermios.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);

     * */

    /*
     * BRKINT: BREAK将会丢弃输入和输出队列中的数据(flush)，并且如果终端为前台进程组的控制终端，则BREAK将会产生一个SIGINT信号发送到这个前台进程组
     * ICRNL: 将输入中的CR转换为NL
     * INPCK: 允许奇偶校验
     * ISTRIP: 剥离第8个bits
     * IXON: 允许输出端的XON/XOF流控
     *
    newtermios.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
     * */


    /* --------设置数据流控制------- */
    switch(attr->flow_ctrl)
    {
        case 0:                         //不使用流控制
            newtermios.c_cflag &=~CRTSCTS;
            break;

        case 1:                         //使用硬件流控制
            newtermios.c_cflag |= CRTSCTS;
            break;

        case 2:                         //使用软件流控制
            newtermios.c_cflag |= IXON| IXOFF|IXANY;
            break;

        default:
            break;
    }


    /* 设置波特率，否则默认设置其为B115200 */
    if(attr->baud_rate)
    {
        sprintf(baudrate,"B%d",attr->baud_rate);

        cfsetispeed(&newtermios, (int)baudrate); //设置输入输出波特率
        cfsetospeed(&newtermios, (int)baudrate);
    }
    else
    {
        cfsetispeed(&newtermios, B115200);
        cfsetospeed(&newtermios, B115200);
    }


    /* ------设置数据位-------*/
    newtermios.c_cflag &= ~CSIZE;   //先把数据位清零，然后再设置新的数据位

    switch(attr->data_bits)
    {
        case '5':
            newtermios.c_cflag |= CS5;
            break;

        case '6':
            newtermios.c_cflag |= CS6;
            break;

        case '7':
            newtermios.c_cflag |= CS7;
            break;

        case '8':
            newtermios.c_cflag |= CS8;
            break;

        default:
            newtermios.c_cflag |= CS8;  //默认数据位为8
            break;
    }

    /* -------设置校验方式------- */
    switch(attr->parity)
    {
        /* 无校验 */
        case 'n':
        case 'N':
            newtermios.c_cflag &= ~PARENB;
            newtermios.c_iflag &= ~INPCK;
            break;

        /* 偶校验 */
        case 'e':
        case 'E':
            newtermios.c_cflag |= PARENB;
            newtermios.c_cflag &= ~PARODD;
            newtermios.c_iflag |= INPCK;
            break;

        /* 奇校验 */
        case 'o':
        case 'O':
            newtermios.c_cflag |= (PARODD | PARENB);
            newtermios.c_iflag |= INPCK;

        /* 设置为空格 */
        case 's':
        case 'S':
            newtermios.c_cflag &= ~PARENB;
            newtermios.c_cflag &= ~CSTOPB;

        /* 默认无校验 */
        default:
            newtermios.c_cflag &= ~PARENB;
            newtermios.c_iflag &= ~INPCK;
            break;

    }

    /* -------设置停止位-------- */
    switch(attr->stop_bits)
    {
        case '1':
            newtermios.c_cflag &= ~CSTOPB;
            break;

        case '2':
            newtermios.c_cflag |= CSTOPB;
            break;

        default:
            newtermios.c_cflag &= ~CSTOPB;
            break;
    }

    /* OPOST: 表示处理后输出，按照原始数据输出 */
    newtermios.c_oflag &= ~(OPOST);


    newtermios.c_cc[VTIME] = 0;  //最长等待时间
    newtermios.c_cc[VMIN] = 0;  //最小接收字符

    //attr->mSend_Len = 128;  //若命令长度大于mSend_Len,则每次最多发送为mSend_Len

    /* 刷新串口缓冲区 / 如果发生数据溢出，接收数据，但是不再读取*/
    if(tcflush(fd,TCIFLUSH))
    {
        printf("%s, clear the cache failure:%s\n", __func__, strerror(errno));
        return -4;
    }

    /* 设置串口属性，立刻生效 */
    if(tcsetattr(fd,TCSANOW,&newtermios) != 0)
    {
        printf("%s, tcsetattr failure: %s\n", __func__, strerror(errno));
        return -5;
    }

    printf("Serial port Init Successfully!\n");

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203

写数据到串口—— serial_send

​ 接下来的两个函数的定义可以有，但是没必要，因为我这里并没有多加什么东西。如果写的内容要进行封装打包，或者解析的话，就需要加上这两个定义了。

int serial_send (int fd, char *msg, int msg_len)
{
    int rv = 0;

    rv = write(fd, msg, msg_len);
    if(rv == msg_len)
    {
        return rv;
    }
    else
    {
        tcflush(fd, TCOFLUSH);

        return -1;
    }

    return rv;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

从串口读取数据—— serial_recv

int serial_recv(int fd, char *recv_msg, int size)
{
    int     rv;    
    
    rv = read(fd, recv_msg, size);
    if(rv)
    {
        return rv;
    }
    else
    {
        return -1;
    }
    /********************************
    *
    *      这里可以自由发挥
    *
    ********************************/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.3 主程序（已更新为收发AT指令）

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

#define SERIAL_DEBUG

#ifdef SERIAL_DEBUG
#define serial_print(format, args...) printf(format,##args)
#else
#define serial_print(format, args...) do{} while(0)
#endif

void sig_stop(int signum);
void usage();
void adjust_msg(char *buf);

int run_stop = 0;

int main(int argc, char **argv)
{
        int                     fd, rv, ch, i;
        char                *fname = "/dev/ttyUSB6"; //如果未指定，使用该设备节点
        char                buf[64] = {0};
        char                send_msg[128];
        char                recv_msg[128];
        fd_set              fdset;
        attr_t              attr;
        struct termios      oldtio;


        struct option    opts[] = {
                {"help"    , no_argument          , NULL, 'h'},
                {"flowctrl", required_argument, NULL, 'f'},
                {"baudrate", required_argument, NULL, 'b'},
                {"databits", required_argument, NULL, 'd'},
                {"parity"  , required_argument, NULL, 'p'},
                {"stopbits", required_argument, NULL, 's'},
                {"name"    , required_argument, NULL, 'n'},
                {NULL      , 0                            , NULL,  0 }
        };

        if(argc < 2)
        {
                serial_print("WARN: without arguments!");
                usage();
                return -1;
        }

        while((ch = getopt_long(argc,argv,"hf:b:d:p:s:n:",opts,NULL)) != -1)
        {
                switch(ch)
                {
                        case 'h':
                                usage();
                                return 0;

                        case 'f':
                                attr.flow_ctrl = atoi(optarg);
                                break;

                        case 'b':
                                attr.baud_rate = atoi(optarg);
                                break;

                        case 'd':
                                attr.data_bits = atoi(optarg);
                                break;

                        case 'p':
                                attr.parity = *optarg;
                                break;

                        case 's':
                                attr.stop_bits = atoi(optarg);
                                break;

                        case 'n':
                                fname = optarg;
                                break;
                }
        }

        if((fd = serial_open(fname)) < 0)
        {
                serial_print("Open %s failure: %s\n", fname, strerror(errno));
                return -1;
        }

        if(serial_init(fd, &oldtio, &attr) < 0)
        {
                return -2;
        }

        signal(SIGINT, sig_stop);
        signal(SIGTERM, sig_stop);

        while(!run_stop)
        {
                FD_ZERO(&fdset);        //清空所有文件描述符
                FD_SET(STDIN_FILENO,&fdset);    //添加标准输入到fdset中
                FD_SET(fd,&fdset);                              //添加文件描述符fd到fdset中

                /*      使用select多路复用监听标准输入和串口fd */
                rv = select(fd + 1, &fdset, NULL, NULL, NULL);
                if(rv < 0)
                {
                        serial_print("Select failure......\n");
                        break;
                }

                if(rv == 0)
                {
                        serial_print("Time Out.\n");
                        goto cleanup;
                }

                //有事件发生
                if(FD_ISSET(STDIN_FILENO,&fdset))
                {
                        memset(send_msg, 0, sizeof(send_msg));

                        /* 从标准输入读取命令 */
                        fgets(send_msg, sizeof(send_msg), stdin);
                        
/* 处理要发送的数据，因为我们从fgets函数获取的字符串末尾是"\n"，而发送AT指令需要的是"\r"*/
                        adjust_msg(send_msg);

                //      serial_print("Serial port will send: %s\n", send_msg);
                        if((rv = serial_send(fd, send_msg, strlen(send_msg))) < 0)
                        {
                                serial_print("Write failed.\n");
                                goto cleanup;
                        }


#ifndef SERIAL_DEBUG

/*  逐一打印一下发送的的数据都是什么  */
                        for(i = 0; i < rv; i++)
                        {
                                serial_print("Byte: %c\t ASCII: 0x%x\n", send_msg[i], (int)send_msg[i]);
                        }

                        serial_print("INFO:------Write success!\n\n");
#endif

                        fflush(stdin);

                }

                if(FD_ISSET(fd,&fdset))
                {
                        memset(recv_msg, 0, sizeof(recv_msg));

                        rv = serial_recv(fd, recv_msg, sizeof(recv_msg));
                        if(rv <= 0)
                        {
                                serial_print("Read failed: %s\n",strerror(errno));
                                break;
                        }

                        printf("%s", recv_msg);

#ifndef SERIAL_DEBUG
                        serial_print("Receive %d bytes data: %s",rv, recv_msg);

/*  逐一打印一下收到的数据一个一个都是什么  */
                        for(i = 0; i < rv; i++)
                        {
                                serial_print("Byte: %c\t ASCII: 0x%x\n", recv_msg[i], (int)recv_msg[i]);
                        }
#endif

                        fflush(stdout);
                }

                sleep(3);
        }

cleanup:
        serial_close(fd, &oldtio);

        return 0;
}

void adjust_msg(char *buf)
{
    int i = strlen(buf);
    strcpy(&buf[i-1],"\r");
}

void sig_stop(int signum)
{
        serial_print("catch the signal: %d\n", signum);
        run_stop = 1;
}

void usage()
{
        serial_print("-h(--help    ): aply the usage of this file\n");
        serial_print("-f(--flowctrl): arguments: 0(no use) or 1(hard) or 2(soft)\n");
        serial_print("-b(--baudrate): arguments with speed number\n");
        serial_print("-d(--databits): arguments: 5 or 6 or 7 or 8 bits\n");
        serial_print("-p(--parity  ): arguments: n/N(null) e/E(even) o/O(odd) s/S(space)\n");
        serial_print("-s(--stopbits): arguments: 1 or 2 stopbits\n");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

四、补充一下串口实现AT指令的收发

先简单讲一下AT指令收发的实际数据是什么，然后在最后小小的验证一波~~

使用AT指令与串口进行通信，是一种“礼尚往来”的通信方式，即当控制端输入一个AT指令后，与之通信的外部设备将会回复一个结果，就这样一对一的进行。

以最简单的AT指令为例，当串口连接好以后，使用

busybox microcom -s 115200 ttyUSB2
1

每输入一次AT设备都会回复一个OK，就可以利用不同的指令，结合设备的返回码来与设备通信。

其实，当我敲下AT 回车后，发送给设备的指令实际是

AT<CR>
1

也就是 “AT\r”

“\r” 是指回到行首，但不会换到下一行,而当我们收到OK时，实际上是收到了

<CR><LF><OK><CR><LF>
1

也就是 “\r\nOK\r\n”
" /r/n " 合起来才是Windows下的Enter，即回到行首并新建一行。从上面的图中可以看到，OK的确换到了新的一行，当我们在敲AT时，又是在新的一行。

这里就是验证的结果了~

ATE1模式下，发送的数据会接收一遍，再接收应答数据
“\r”和“\n”的ASCII值分别为十六进制的 d 和 a

参考链接：https://blog.csdn.net/weixin_45121946/article/details/107130238