(七)Linux库的串口开发

---

基于官方提供的串口测试

代码部分

创龙T113-i官方资料包给的代码：

uart_rw.c，功能很高端，支持读取、写入和回环测试三种模式！

/* Copyright 2018 Tronlong Elec. Tech. Co. Ltd. All Rights Reserved. */#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <sys/time.h>
#include <fcntl.h>
#include <termios.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include <libgen.h>
#include <signal.h>
#include <getopt.h>#define NOPASS_CONDITIONS 3
#define INADEQUATE_CONDITIONS 10enum Mode { READ, WRITE, LOOPBACK };/* Exit flag */
volatile bool g_quit = false;/* Short option names */
static const char g_shortopts [] = ":d:s:rwvhl";/* Option names */
static const struct option g_longopts [] = {{ "device",      required_argument,      NULL,        'd' },{ "read",        no_argument,            NULL,        'r' },{ "write",       no_argument,            NULL,        'w' },{ "loopback",    no_argument,            NULL,        'l' },{ "size",        required_argument,      NULL,        's' },{ "version",     no_argument,            NULL,        'v' },{ "help",        no_argument,            NULL,        'h' },{ 0, 0, 0, 0 }
};static void usage(FILE *fp, int argc, char **argv) {fprintf(fp,"Usage: %s [options]\n\n""Options:\n"" -d | --device        Device such as '/dev/ttyS0'\n"" -r | --read          Read\n"" -w | --write         Write\n"" -l | --loopback      loopback test\n"" -s | --size          Read size\n"" -v | --version       Display version information\n"" -h | --help          Show help content\n"" e.g. %s -d /dev/ttyS1 -r -s 256\n""      %s -d /dev/ttyS1 -w -s 1024\n""      %s -d /dev/ttyS1 -l -s 1024\n\n""", argv[0], argv[0], argv[0], argv[0]);
}static void opt_parsing_err_handle(int argc, char **argv, int flag) {/* Exit if no input parameters are entered  */int state = 0;if (argc < 2) {printf("No input parameters are entered, please check the input.\n");state = -1;} else {/* Feedback Error parameter information then exit */if (optind < argc || flag) {printf("Error:  Parameter parsing failed\n");if (flag)printf("\tunrecognized option '%s'\n", argv[optind-1]);while (optind < argc) {printf("\tunrecognized option '%s'\n", argv[optind++]);}state = -1;}}if (state == -1) {printf("Tips: '-h' or '--help' to get help\n\n");exit(2);}
}void sig_handle(int arg) {g_quit = true;
}int init_serial(int *fd, const char *dev) {struct termios opt;/* open serial device */if ((*fd = open(dev, O_RDWR)) < 0) {perror("open()");return -1;}/* define termois */if (tcgetattr(*fd, &opt) < 0) {perror("tcgetattr()");return -1;}opt.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);opt.c_oflag  &= ~OPOST;/* Character length, make sure to screen out this bit before setting the data bit */opt.c_cflag &= ~CSIZE;/* No hardware flow control */opt.c_cflag &= ~CRTSCTS;/* 8-bit data length */opt.c_cflag |= CS8;/* 1-bit stop bit */opt.c_cflag &= ~CSTOPB;/* No parity bit */opt.c_iflag |= IGNPAR;/* Output mode */opt.c_oflag = 0;/* No active terminal mode */opt.c_lflag = 0;/* Input baud rate */if (cfsetispeed(&opt, B115200) < 0)return -1;/* Output baud rate */if (cfsetospeed(&opt, B115200) < 0)return -1;/* Overflow data can be received, but not read */if (tcflush(*fd, TCIFLUSH) < 0)return -1;if (tcsetattr(*fd, TCSANOW, &opt) < 0)return -1;return 0;
}int serial_write(int *fd, const char *data, size_t size) {int ret = write(*fd, data, size);if ( ret < 0 ) {perror("write");tcflush(*fd, TCOFLUSH);}return ret;
}int serial_read(int *fd, char *data, size_t size) {size_t read_left = size;size_t read_size = 0;char *read_ptr = data;struct timeval timeout = {5, 0};memset(data, 0, size);fd_set rfds;while (!g_quit) {FD_ZERO(&rfds);FD_SET(*fd, &rfds);timeout.tv_sec = 5;timeout.tv_usec = 0;if (read_left == 0)break;switch (select(*fd+1, &rfds, NULL, NULL, &timeout)) {case -1:perror("select()");break;case 0:perror("timeout and retry");break;default:if (FD_ISSET(*fd,&rfds)) {read_size = read(*fd, read_ptr, read_left);if (read_size == 0)break;read_ptr += read_size;read_left -= read_size;}}}return read_size;
}int run_read_mode(char *dev, size_t size) {char *buf = NULL;int fd = -1;int ret = -1;ret = init_serial(&fd, dev);if (ret < 0) {close(fd);return -1;}printf("Mode : read\n");if (size <= 0) {printf ("Error : Incorrect size settings\n");exit(INADEQUATE_CONDITIONS);}buf = (char*)malloc(size + 1);buf[size] = '\0';ret = serial_read(&fd, buf, size);printf("recv: %s\nsize: %d\n", buf, ret);free(buf);return 0;
}int run_write_mode(char *dev, size_t size) {int fd = -1;int ret = -1;ret = init_serial(&fd, dev);if (ret < 0) {close(fd);return -1;}printf("Mode : write\n");if (size <= 0) {printf("Error : Incorrect size settings\n");exit(INADEQUATE_CONDITIONS);}int i = 0;char context;size_t write_size = 0;while (!g_quit) {if (i > 7)i = 0;context = (char)('0' + i);write_size += serial_write(&fd, &context, sizeof(context));i ++;if (size == write_size)break;}printf("send size: %zd\n", write_size);return 0;
}int run_loopback_test(char *dev, size_t size) {int fd;int ret;size_t buf_size;int serial_buf_size;ret = init_serial(&fd, dev);if (ret < 0)return -1;printf("Start uart loopback testing.\n");/* Serial port buffer size generally defaults to 2k - 4k */char *write_buf = (char*)malloc(size);char *read_buf = (char*)malloc(size);buf_size = size;while (buf_size > 0){if(buf_size > 1024) {serial_buf_size = 1024;} else {serial_buf_size = buf_size;}// Generate random data to write.memset(write_buf, rand() % 26 + 65, serial_buf_size);memset(read_buf, 0, serial_buf_size);ret = serial_write(&fd, write_buf, serial_buf_size);/* delay > 1024 / 115200 * 1000000 */usleep(90000);ret = serial_read(&fd, read_buf, serial_buf_size);ret = memcmp(read_buf, write_buf, serial_buf_size);if (ret != 0) {printf("Result : Test failed\n");goto release;}buf_size -= 1024;}printf("send size: %zd\n", size);printf("recv size: %zd\n", size);printf("Result : Test pass\n");release:free(write_buf);free(read_buf);close (fd);if (ret != 0) {return NOPASS_CONDITIONS;} else {return 0;}
}int main(int argc, char *argv[]) {int c = 0;int flag = 0;int mode = -1;size_t size = 0;char *dev = NULL;int ret = -1;/* Parsing input parameters */while ((c = getopt_long(argc, argv, g_shortopts, g_longopts, NULL)) != -1) {switch (c) {case 'd':dev = optarg;break;case 'r':mode = READ;break;case 'w':mode = WRITE;break;case 'l':mode = LOOPBACK;break;case 's':size = atoi(optarg);break;case 'v':/* Display the version */printf("version : 1.0\n");exit(0);case 'h':usage(stdout, argc, argv);exit(0);default :flag = 1;break;}}opt_parsing_err_handle(argc, argv, flag);/* Ctrl+c handler */signal(SIGINT, sig_handle);switch (mode) {case READ:if(run_read_mode(dev, size) < 0) {return INADEQUATE_CONDITIONS;}break;case WRITE:if(run_write_mode(dev, size) < 0) {return INADEQUATE_CONDITIONS;}break;case LOOPBACK:ret = run_loopback_test(dev, size);if(ret < 0) {return INADEQUATE_CONDITIONS;} else if(ret == NOPASS_CONDITIONS) {return NOPASS_CONDITIONS;}break;default:break;}return 0;
}

解析代码部分

不深究可以不看，了解函数啥功能即可。

1. usage 函数

• 作用：打印帮助信息给用户。
• 参数：
  • FILE *fp: 输出流，可以是标准输出(stdout)或标准错误(stderr)。
  • argc, argv[]: 命令行参数的数量和值，用于在示例中显示程序名。
• 行为：当用户请求帮助(-h 或 --help)时调用，向用户提供如何使用该工具的信息。

2. opt_parsing_err_handle 函数

• 作用：处理命令行选项解析过程中的错误。
• 参数：
  • argc, argv[]: 命令行参数的数量和值。
  • flag: 标记是否有未知选项被识别。
• 行为：如果命令行参数为空或者存在无法识别的选项，则打印错误信息并提示用户使用 -h 获取帮助，然后退出程序。

3. sig_handle 函数

• 作用：信号处理器，用来响应中断信号（如Ctrl+C）。
• 参数：int arg，传递给信号处理器的信号编号。
• 行为：设置全局变量 g_quit 为真，通知其他部分停止工作。

4. init_serial 函数

• 作用：初始化串行端口配置。
• 参数：
  • fd: 文件描述符指针，将被设置为打开的串行端口。
  • dev: 设备路径字符串，例如 /dev/ttyS0。
• 行为：根据提供的设备路径打开串行端口，并配置波特率、数据位、停止位等参数。它还会清除终端模式并禁用硬件流控制。

5. serial_write 函数

• 作用：向串行端口写入数据。
• 参数：
  • fd: 文件描述符指针。
  • data: 指向要发送的数据的指针。
  • size: 要发送的数据大小。
• 行为：尝试将指定数量的字节写入到串行端口，失败时刷新输出缓冲区并报告错误。

6. serial_read 函数

• 作用：从串行端口读取数据。
• 参数：
  • fd: 文件描述符指针。
  • data: 指向存储接收到的数据的缓冲区。
  • size: 预期接收的数据量。
• 行为：使用 select 函数等待数据到达，然后尽可能多地读取数据直到达到预期大小或超时。如果发生错误或超时，会给出相应的错误信息。

7. run_read_mode 函数

• 作用：执行读取模式操作。
• 参数：
  • dev: 设备路径。
  • size: 期望读取的数据大小。
• 行为：以非阻塞方式读取指定大小的数据，并将其打印出来。如果指定大小无效，则报错退出。

8. run_write_mode 函数

• 作用：执行写入模式操作。
• 参数：
  • dev: 设备路径。
  • size: 要写入的数据大小。
• 行为：循环地写入字符到串行端口，直到写入了指定大小的数据。每次写入后，字符递增，模拟连续的数据流。

9. run_loopback_test 函数

• 作用：执行回环测试。
• 参数：
  • dev: 设备路径。
  • size: 测试过程中使用的数据大小。
• 行为：生成随机数据写入串行端口，然后立即尝试读回相同的数据，比较两者是否一致。如果不一致，则认为测试失败；否则，测试通过。

进行测试

第一步编译

用交叉编译工具进行编译。

不会配置交叉编译链的，请参考：（二）编译原生SDK以及配置交叉编译链中配置交叉编译链的部分。

arm-linux-gnueabi-gcc uart_rw.c -o uart_rw

查看一下可执行文件类型，避免错误。

第二步发送到板子

借助基于ssh的scp工具，不会的可以参考（四）配置有线网口、SSH登陆、文件传输以及运行交叉编译程序测试中SHH登陆以及文件传输部分。

scp ./uart_rw root@192.168.1.101:/root/zhua

出现问题：

根据提示，解决问题，并再次发送：

第三步调试

测试前注意

如何运行可执行文件，查看如何运行

./uart_rw -h

当然直接读代码也是可以的，参考这部分：

注意一下波特率是115200，可以从代码中了解到：

最后查看用的串口4是否开启（可以自行指定），注意创龙的是ttyAS4,跟传统的名称还是有区别的

ls /dev

可以在设备文件夹下看到，说明串口的设备是成功加载到了系统中。如果看不到，请进一步修改设备树，书写设备驱动文件（不会的，请参考后面的章节），再次编译镜像，进行烧录。

先测回环

 ./uart_rw -d /dev/ttyAS4 -l -s 1024

记得要把串口4的TX和RX短接。另外我开启的是串口4。

再测写

注意这里写的内容就是0-7 来回循环，看代码便知。

./uart_rw --device /dev/ttyAS4 --write --size 16

或者简写参数

./uart_rw -d /dev/ttyAS4 -w -s 16

最后测读

这里我读8个长度，用串口助手发送87654321。

./uart_rw --device /dev/ttyAS4 --read --size 8

或者简写

./uart_rw -d /dev/ttyAS4 -r -s 8

中间提示的，timeout and retry： Success应该是一帧数据的帧检测，可以参考蓝桥杯专栏的（十六）串口UART进行学习。

基于原生Linux串口开发

功能简单，借助线程操作，支持读写同步。

步骤：初始化串口，开启父子线程，父线程读操作，子线程写操作。

代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <sys/time.h>
#include <fcntl.h>
#include <termios.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include <libgen.h>
#include <signal.h>int init_serial(int *fd, const char *dev) {struct termios opt;/* open serial device */if ((*fd = open(dev, O_RDWR)) < 0) {perror("open()");return -1;}/* define termois */if (tcgetattr(*fd, &opt) < 0) {perror("tcgetattr()");return -1;}opt.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);opt.c_oflag  &= ~OPOST;/* Character length, make sure to screen out this bit before setting the data bit */opt.c_cflag &= ~CSIZE;/* No hardware flow control */opt.c_cflag &= ~CRTSCTS;/* 8-bit data length */opt.c_cflag |= CS8;/* 1-bit stop bit */opt.c_cflag &= ~CSTOPB;/* No parity bit */opt.c_iflag |= IGNPAR;/* Output mode */opt.c_oflag = 0;/* No active terminal mode */opt.c_lflag = 0;/* Input baud rate */if (cfsetispeed(&opt, B115200) < 0)return -1;/* Output baud rate */if (cfsetospeed(&opt, B115200) < 0)return -1;/* Overflow data can be received, but not read */if (tcflush(*fd, TCIFLUSH) < 0)return -1;if (tcsetattr(*fd, TCSANOW, &opt) < 0)return -1;return 0;
}int serial_write(int *fd, const char *data, size_t size) {int ret = write(*fd, data, size);if ( ret < 0 ) {perror("write");tcflush(*fd, TCOFLUSH);}return ret;
}int serial_read(int *fd, size_t size) 
{int read_size = 0;char data[128] = {'\0'};while(1){read_size = read(*fd, data, size);if(read_size!=0){printf("read_size = %d,context = %s\n",read_size,data);memset(data,'\0',128);read_size = 0;}}return 0;
}int main(int argc ,char *argv[])
{__pid_t pid = 0;char *writedata = "write from root\n";int ret= -1;int fd = -1;if(argc<2){printf("tips:./myuart /dev/xxx\n");printf("argc = %d,argv[0] = %s,,argv[1] = %s\n",argc,argv[0],argv[1]);}ret = init_serial(&fd, argv[1]);if(ret == -1){return -1;}//开启2个线程pid = fork();if(pid>0){  //父进程 就是父进程的pid号	serial_read(&fd,128);}else if(pid==0){   //子进程while(1){serial_write(&fd,writedata,strlen(writedata));sleep(3);}}else{      //fork线程错误错误perror("fork faild\n");return -1;}return 0;
}

测试

执行指令：

./myuart /dev/ttyAS4

注意使用的是串口4，波特率115200。

优化基于Linux原生串口开发

向官方牛x的功能靠近一点点！

实现指定长短的发送，可以双方互不干扰。

这里是开启两个线程，一个是发送线程，一个是接收线程。在原有的Linux原生串口代码的基础上改进，之前使用的fork函数，创建的父子线程有局限性，资源争夺问题，数据共享等问题，所以这里借助pthread_create直接创建两个新的线程。

可以参考（十四）基于Linux的串口开发中基于Linux库的开发，几乎一样。

代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <sys/time.h>
#include <fcntl.h>
#include <termios.h>
#include <string.h>
#include <errno.h>
#include <stdbool.h>
#include <libgen.h>
#include <signal.h>
#include <pthread.h>int fd = -1;int init_serial(int *fd, const char *dev) {struct termios opt;/* open serial device */if ((*fd = open(dev, O_RDWR)) < 0) {perror("open()");return -1;}/* define termois */if (tcgetattr(*fd, &opt) < 0) {perror("tcgetattr()");return -1;}opt.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);opt.c_oflag  &= ~OPOST;/* Character length, make sure to screen out this bit before setting the data bit */opt.c_cflag &= ~CSIZE;/* No hardware flow control */opt.c_cflag &= ~CRTSCTS;/* 8-bit data length */opt.c_cflag |= CS8;/* 1-bit stop bit */opt.c_cflag &= ~CSTOPB;/* No parity bit */opt.c_iflag |= IGNPAR;/* Output mode */opt.c_oflag = 0;/* No active terminal mode */opt.c_lflag = 0;/* Input baud rate */if (cfsetispeed(&opt, B115200) < 0)return -1;/* Output baud rate */if (cfsetospeed(&opt, B115200) < 0)return -1;/* Overflow data can be received, but not read */if (tcflush(*fd, TCIFLUSH) < 0)return -1;if (tcsetattr(*fd, TCSANOW, &opt) < 0)return -1;return 0;
}int serial_write(int *fd, const char *data, size_t size) {int ret = write(*fd, data, size);if ( ret < 0 ) {perror("write");tcflush(*fd, TCOFLUSH);}return ret;
}int serial_read(int *fd, size_t size) 
{int read_size = 0;char data[128] = {'\0'};while(1){read_size = read(*fd, data, size);if(read_size!=0){printf("read_size = %d,context = %s\n",read_size,data);memset(data,'\0',128);read_size = 0;}}return 0;
}void* recive()
{printf("recive pthread========ok========\n");while(1){serial_read(&fd,128);}}char *writedata = NULL;
int nwrite = 0;void* send()
{printf("send pthread========ok========\n");while(1){printf("please enter n size what you want to write and press Enter to end \n");scanf("%d",&nwrite);writedata = (char *)malloc(nwrite*sizeof(char));scanf("%s",writedata);serial_write(&fd,writedata,strlen(writedata));free(writedata);writedata = NULL;}
}int main(int argc ,char *argv[])
{pthread_t recivet;pthread_t sendt;int ret= -1;if(argc<2){printf("tips:./myuart /dev/xxx\n");printf("argc = %d,argv[0] = %s,,argv[1] = %s\n",argc,argv[0],argv[1]);}ret = init_serial(&fd, argv[1]);if(ret == -1){return -1;}pthread_create(&recivet,NULL,recive,NULL);//接收线程pthread_create(&sendt,NULL,send,NULL);//发送进程while(1){//啥事也不干 3秒睡一次sleep(3);}return 0;
}

测试

注意这里因为用到的pthread_create函数是POSIX线程（pthreads）库的一部分，因此在编译和链接程序时需要链接到这个库，可以通过在编译命令中添加 -lpthread 选项来实现。否则会失败。

必须链接库编译

arm-linux-gnueabi-gcc myuart.c -o myuart -lpthread

输入数据格式一定要注意，因为使用的scanf这个函数，严格遵守它的规范，用回车或者空格断开数据。