devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C/C++开发，异步串行接口(uart)通信示例_c++串口库

作者：我家自动化 | 2024-05-05 13:28:03

赞

踩

c++串口库

目录

一、构建简化版串口库

二、uart接口

三、UART接口调用测试

一、构建简化版串口库

        一直以来在串口通信方面都很信任libctb，其对serial/gpib通信支持win/linux，的确好用,但最近实现arm的串口通信时发现ctb还是有点复杂，因此想到构建一个相对简单的串口通信接口,主要依赖于linux的termios.h，termios 结构是在POSIX规范中定义的标准接口，通过设置termios类型的数据结构中的值和函数调用，就可以对终端接口进行控制。更多描述在命令行中man termios 查看。

        下面给出本人实践过的接口全源码及测试样例,希望对大家有所帮助。

二、uart接口

uart_linux.h

  1. #if _MSC_VER > 1000
  2. #pragma once
  3. #endif // _MSC_VER > 1000
  4.  
  5. #ifndef _UARTC_H_
  6. #define _UARTC_H_
  7. /***********************************************************************
  8.   *Copyright 2020-04-06, pyfree
  9.   *
  10.   *File Name       : uart_linux.h
  11.   *File Mark       : 
  12.   *Summary         : 
  13.   *linux uart data gather
  14.   *
  15.   *Current Version : 1.00
  16.   *Author          : pyfree
  17.   *FinishDate      :
  18.   *
  19.   *Replace Version :
  20.   *Author          :
  21.   *FinishDate      :
  23.  ************************************************************************/
  24. #include <termios.h>
  25.  
  26. namespace pyfree
  27. {
  28. 	/*
  29. 	* 打开串口
  30. 	* @param fd {int } 文件指针
  31. 	* @param name {char* } 串口名,如"/dev/ttyS*"
  32. 	* @return {int} 返回<1,异常;返回>0,为fd
  33. 	*/
  34. 	int uart_open(int &fd,const char *name);
  35. 	/*
  36. 	* 串口配置
  37. 	* @param fd {int } 文件指针
  38. 	* @param baude {int } 波特率
  39. 	* @param c_flow {int } 流标识
  40. 	* @param bits {int } 数据位
  41. 	* @param parity {char } 奇偶位
  42. 	* @param stop {int } 停止位
  43. 	* @return {int}  返回=-1,异常;返回=0,成功,为读取大小
  44. 	*/
  45. 	int uart_config(int fd,int baude,int c_flow, int bits, char parity, int stop);
  46. 	/*
  47. 	* 串口读取数据
  48. 	* @param fd {int } 文件指针
  49. 	* @param r_buf {char* } 缓存指针
  50. 	* @param lenth {int } 缓存大小
  51. 	* @param time_out_ms {等待时间 } 毫秒,默认1000
  52. 	* @return {int} 返回<=0,异常;返回>0,成功
  53. 	*/
  54. 	int uart_read(int fd, char *r_buf, int lenth, int time_out_ms=1000);
  55. 	/*
  56. 	* 串口写入数据
  57. 	* @param fd {int } 文件指针
  58. 	* @param r_buf {char* } 内容指针
  59. 	* @param lenth {int } 大小
  60. 	* @return {int} 返回<=0,异常;返回>0,成功,为写入大小
  61. 	*/
  62. 	int uart_write(int fd, char *r_buf, int lenth, int time_out_ms=1000);
  63. 	/*
  64. 	*用于清空输入、输出缓冲区 
  65. 	* @param fd {int } 文件指针
  66. 	* @param model {int } 模式,有三种取值  TCIFLUSH(用于清空输入缓冲区) TCOFLUSH(用于清空输出缓冲区) TCIOFLUSH(用于清空输入输出缓冲区)
  67. 	* @return {int} 
  68. 	*/
  69. 	int uart_clear(int fd,int model);
  70. 	/*
  71. 	* 关闭串口
  72. 	* @param fd {int } 文件指针
  73. 	* @return {int} 
  74. 	*/
  75. 	int uart_close(int fd);
  76. };
  77.  
  78. #endif

uart_linux.cpp

  1. #include "uart_unix.h"
  2.  
  3. #include <stdio.h>
  4. #include <fcntl.h>
  5. #include <assert.h>
  6. #include <termios.h>
  7. #include <unistd.h>
  8. #include <sys/time.h>
  9. #include <sys/types.h>
  10. #include <errno.h>
  11.  
  12. int pyfree::uart_open(int &fd,const char *name)
  13. {
  14.     //检测串口路径是否存在
  15.     assert(name);								
  16.     //以读写形式、不将此终端作为此进程的终端控制器、非阻塞的形式打开串口
  17.     fd = open(name,O_RDWR|O_NOCTTY|O_NDELAY);	
  18.     if(fd == -1)
  19.     {
  20.         char e_buf[64]={0};
  21.         sprintf(e_buf,"uart open %s failed!",name);
  22.         perror(e_buf);
  23.         return -1;
  24.     }
  25.     //设置串口非阻塞，因为这里是以非阻塞形式打开的，第三个参数为0，返回值：成功返回0，失败返回-1，失败原因存入errno
  26.     if(fcntl(fd,F_SETFL,0)<0)						
  27.     {
  28.         perror("fcntl failed!");
  29.         return -1;
  30.     }
  31.     return fd;
  32. };
  33.  
  34. int pyfree::uart_config(int fd,int baude,int c_flow, int bits, char parity, int stop)
  35. {
  36.     struct termios uart;
  37.     //用于获取termios结构体属性。成功返回0，失败返回非0
  38.     if(tcgetattr(fd,&uart)!=0)
  39.     {
  40.         perror("tcgetattr failed!");
  41.         return -1;
  42.     }
  43.  
  44.     switch(baude)
  45.     {
  46.     case 4800:
  47.         cfsetispeed(&uart,B4800);//设置输入波特率
  48.         cfsetospeed(&uart,B4800);//设置输出波特率
  49.         break;
  50.     case 9600:
  51.         cfsetispeed(&uart,B9600);
  52.         cfsetospeed(&uart,B9600);
  53.         break;
  54.     case 19200:
  55.         cfsetispeed(&uart,B19200);
  56.         cfsetospeed(&uart,B19200);
  57.         break;
  58.     case 38400:
  59.         cfsetispeed(&uart,B38400);
  60.         cfsetospeed(&uart,B38400);
  61.         break;
  62.     default:
  63.         fprintf(stderr,"Unknown baude!");
  64.         return -1;
  65.     }
  66.     switch(c_flow)
  67.     {
  68.     case 'N':
  69.     case 'n':
  70.         uart.c_cflag &= ~CRTSCTS;//不进行硬件流控制
  71.         break;
  72.     case 'H':
  73.     case 'h':
  74.         uart.c_cflag |= CRTSCTS;//进行硬件流控制
  75.         break;
  76.     case 'S':
  77.     case 's':
  78.         uart.c_cflag |= (IXON | IXOFF | IXANY);//进行软件流控制
  79.         break;
  80.     default:
  81.         fprintf(stderr,"Unknown c_cflag");
  82.         return -1;
  83.     }
  84.     switch(bits)
  85.     {
  86.     case 5:
  87.         uart.c_cflag &= ~CSIZE;//屏蔽其他标志位
  88.         uart.c_cflag |= CS5;//数据位为5位
  89.         break;
  90.     case 6:
  91.         uart.c_cflag &= ~CSIZE;
  92.         uart.c_cflag |= CS6;
  93.         break;
  94.     case 7:
  95.         uart.c_cflag &= ~CSIZE;
  96.         uart.c_cflag |= CS7;
  97.         break;
  98.     case 8:
  99.         uart.c_cflag &= ~CSIZE;
  100.         uart.c_cflag |= CS8;
  101.       break;
  102.     default:
  103.         fprintf(stderr,"Unknown bits!");
  104.         return -1;
  105.     }
  106.     switch(parity)
  107.     {
  108.     case 'n':
  109.     case 'N':
  110.         uart.c_cflag &= ~PARENB;//PARENB：产生奇偶校验
  111.         uart.c_cflag &= ~INPCK;//INPCK：使奇偶校验起作用
  112.         break;
  113.     case 's':
  114.     case 'S':
  115.         uart.c_cflag &= ~PARENB;
  116.         uart.c_cflag &= ~CSTOPB;//使用两位停止位
  117.         break;
  118.     case 'o':
  119.     case 'O':
  120.         uart.c_cflag |= PARENB;
  121.         uart.c_cflag |= PARODD;//使用奇校验
  122.         uart.c_cflag |= INPCK;
  123.         uart.c_cflag |= ISTRIP;//使字符串剥离第八个字符，即校验位
  124.         break;
  125.     case 'e':
  126.     case 'E':
  127.         uart.c_cflag |= PARENB;
  128.         uart.c_cflag &= ~PARODD;//非奇校验，即偶校验
  129.         uart.c_cflag |= INPCK;
  130.         uart.c_cflag |= ISTRIP;
  131.         break;
  132.     default:
  133.         fprintf(stderr,"Unknown parity!\n");
  134.         return -1;
  135.     }
  136.     switch(stop)
  137.     {
  138.     case 1:
  139.         uart.c_cflag &= ~CSTOPB;//CSTOPB：使用两位停止位
  140.         break;
  141.     case 2:
  142.         uart.c_cflag |= CSTOPB;
  143.         break;
  144.     default:
  145.         fprintf(stderr,"Unknown stop!\n");
  146.         return -1;
  147.     }
  148.  
  149.     uart.c_oflag &= ~OPOST;//OPOST:表示数据经过处理后输出
  150.     if(tcsetattr(fd,TCSANOW,&uart)<0)//激活配置，失败返回-1
  151.     {
  152.         return -1;
  153.     }
  154.  
  155.     uart.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG );//使串口工作在原始模式下
  156.     uart.c_cc[VTIME] = 0;//设置等待时间为0
  157.     uart.c_cc[VMIN] = 1;//设置最小接受字符为1
  158.     tcflush(fd,TCIFLUSH);//清空输入缓冲区
  159.     if(tcsetattr(fd,TCSANOW,&uart)<0)//激活配置
  160.     {
  161.         perror("tcgetattr failed!");
  162.         return -1;
  163.     }
  164.     return 0;
  165. }
  166.  
  167. int pyfree::uart_read(int fd, char *r_buf, int lenth, int time_out_ms/*=1000*/)
  168. {
  169.     fd_set rfds;
  170.     struct timeval time;
  171.     ssize_t cnt = 0;
  172.     /*将读文件描述符加入描述符集合*/
  173.     FD_ZERO(&rfds);
  174.     FD_SET(fd,&rfds);
  175.     /*设置超时为*/
  176.     time.tv_sec = (time_t)(time_out_ms/1000);
  177.     time.tv_usec = (long)1000*(time_out_ms%1000);
  178.     /*实现多路IO*/
  179.     int ret = select(fd+1, &rfds ,NULL, NULL, &time);
  180.     switch (ret) {
  181.     case -1:
  182.         fprintf(stderr,"select error!\n");
  183.         break;
  184.     case 0:
  185.         fprintf(stderr, "time over!\n");
  186.         break;
  187.     default:
  188.         cnt = read(fd, r_buf, lenth);
  189.         if(cnt == -1)
  190.         {
  191.             fprintf(stderr, "read failed!\n");
  192.             return -1;
  193.         }
  194.         return cnt;
  195.     }
  196.     return ret;
  197. }
  198.  
  199. int pyfree::uart_write(int fd, char *r_buf, int lenth, int time_out_ms/*=1000*/)//串口写入数据
  200. {
  201.     fd_set rfds;
  202.     struct timeval time;
  203.     ssize_t cnt = 0;
  204.     /*将读文件描述符加入描述符集合*/
  205.     FD_ZERO(&rfds);
  206.     FD_SET(fd,&rfds);
  207.     /*设置超时为*/
  208.     time.tv_sec = (time_out_ms/1000);
  209.     time.tv_usec = 1000*(time_out_ms%1000);
  210.     /*实现多路IO*/
  211.     int ret = select(fd+1, &rfds ,NULL, NULL, &time);
  212.     switch (ret) {
  213.     case -1:
  214.         fprintf(stderr,"select error!\n");
  215.         break;
  216.     case 0:
  217.         fprintf(stderr, "time over!\n");
  218.         break;
  219.     default:
  220.         cnt = write(fd, r_buf, lenth);
  221.         if(cnt!=lenth)
  222.         {
  223.             fprintf(stderr, "write failed!\n");
  224.             return -1;
  225.         }
  226.         return cnt;
  227.     }
  228.     return ret;
  229. }
  230.  
  231. int pyfree::uart_clear(int fd,int model)
  232. {
  233.     assert(fd);
  234.     int ret = tcflush(fd,model);
  235.     if(ret<0){
  236.         fprintf(stderr, "tcflush failed!\n");
  237.     }
  238.     return ret;
  239. }
  240.  
  241. int pyfree::uart_close(int fd)
  242. {
  243.     assert(fd);//assert先检查文件描述符是否存在
  244.     close(fd);
  245.     return 0;
  246. }
  247.  
  248.

三、UART接口调用测试

        demo_test,如果想在虚拟的linux系统测试，有无实物设备，方案选择如下：

采用"VSPD虚拟串口.zip"串口工具安装并创建一个串口对COM4<->COM5  

采用"sscom.exe"工具模拟设备端,打开并设置其端口选择COM5,19200 8 N 1  ，其支持定时发送

（如果没有这两款工具，可以去我个人空间下载：pyfree-IotEdge: c++开发的一套物联网边缘服务系统，当前主要包含采集和调度两个子系统，采集子系统用于设备的供电、态势、IT资源等信息采集,支持串口、网口、蓝牙等采集接口，以及采集数据的分析、中转、级联；调度子系统通过可定制的定期、定时、轮询、条件、启停等任务策略以及可视化监控终端实现设备态势的自动化调度与运维 - Gitee.com）

        主机win系统，安装VMware，在该工具创建虚拟机,安装linux系统,在虚拟机关闭时，进入虚拟机设置页面，添加串行端口，指定使用物理串行端口，选择COM4(前提需要创建虚拟串口对)  则对应虚拟linux系统/dev/ttyS0

  1. #include "uart_unix.h"
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. int main()
  8. {
  9. 	int fd;
  10. 	int ret;
  11. 	char r_buf[256];
  12. 	bzero(r_buf,256);
  13. 	fd = pyfree::uart_open(fd, "/dev/ttyS0");//选择的是/dev/ttyS0串口
  14. 	if(fd == -1)
  15. 	{
  16. 		fprintf(stderr,"open failed!\n");
  17. 		exit(EXIT_FAILURE);
  18. 	}
  19. 	fprintf(stderr,"open success!\n");
  20. 	if(pyfree::uart_config(fd,19200,'N',8,'N',1) == -1)
  21. 	{
  22. 		fprintf(stderr,"configure failed!\n");
  23. 		exit(EXIT_FAILURE);
  24. 	}
  25. 	fprintf(stderr,"config success!\n");
  26. 	pyfree::uart_clear(fd,TCIOFLUSH);
  27. 	while (1) {
  28. 		ret = pyfree::uart_read(fd,r_buf,256,1000);                
  29. 		if(ret == -1)
  30. 		{
  31. 			fprintf(stderr, "uart_read failed!\n");
  32. 			exit(EXIT_FAILURE);
  33. 		}
  34. 		if(ret>0){
  35. 			printf("buf:%s\n", r_buf);
  36. 			// ret = pyfree::uart_write(fd,r_buf,strlen(r_buf));   
  37. 			// if(ret == -1)
  38. 			// {
  39. 			// 	fprintf(stderr, "uart_write failed!\n");
  40. 			// 	exit(EXIT_FAILURE);
  41. 			// }
  42. 		}
  43. 	}
  44.  
  45. 	ret = pyfree::uart_close(fd);
  46. 	if(ret == -1)
  47. 	{
  48. 		fprintf(stderr, "close failed!\n");
  49. 		exit(EXIT_FAILURE);
  50. 	}
  51.  
  52. 	exit(EXIT_SUCCESS);
  53. }
本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号