Linux uart应用程序

已于 2023-04-06 17:27:04 修改
阅读量408 收藏 2
点赞数 1
分类专栏： Linux应用程序编程 文章标签： linux 运维 服务器
于 2023-03-21 18:35:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40177571/article/details/129694564
版权

实现目的

在工作中需要长时间给串口发送数据用来测试稳定性，基于此开发了一个小的demo，话不多说直接上代码。

源码

#include <stdio.h>      /*标准输入输出定义*/
#include <stdlib.h>     /*标准函数库定义*/
#include <string.h>
#include <unistd.h>     /*Unix标准函数定义*/
#include <sys/types.h>  /**/
#include <sys/stat.h>   /**/
#include <fcntl.h>      /*文件控制定义*/
#include <termios.h>    /*PPSIX终端控制定义*/
#include <errno.h>      /*错误号定义*/
#include <sys/time.h>

#define DEF_BAUD	115200
#define SPEED_CNT	5
#define BUF_SIZE	100

/*用来接收轨道数据*/
char buffer[BUF_SIZE];

int speed_arr[SPEED_CNT] = {
	B9600, B19200, B38400, 
	B57600,	B115200
};

int name_arr[SPEED_CNT] = {
	9600, 19200, 38400,
	57600, 115200
};

time_t timeStamp()
{
	time_t time_now = time(NULL);
	return time_now;
}

/**
*@brief  设置串口通信速率
*@param  fd     类型 int  打开串口的文件句柄
*@param  speed  类型 int  串口速度
*@return  0 success or -1 err
*/
int set_speed(int fd, int speed)
{
	int i;
	int status;
	struct termios opt;
	
	tcgetattr(fd, &opt);

	for (i= 0; i<SPEED_CNT; i++)
	{
		if (speed == name_arr[i])
		{
			tcflush(fd, TCIOFLUSH);
			/*  设置串口的波特率 */
			cfsetispeed(&opt, speed_arr[i]);
			cfsetospeed(&opt, speed_arr[i]);
			status = tcsetattr(fd, TCSANOW, &opt);

			if (status != 0)
			{
				perror("tcsetattr set_speed");
				return -1;
			}
			
			return 0;
     	}
		/*清空所有正在发生的IO数据*/
		tcflush(fd, TCIOFLUSH);
   }
   
	printf("Cannot find suitable speed\n");
	return -1;
}

/**
*@brief   设置串口数据位，停止位和效验位
*@param  fd     类型  int  打开的串口文件句柄*
*@param  databits 类型  int 数据位   取值 为 7 或者8*
*@param  stopbits 类型  int 停止位   取值为 1 或者2*
*@param  parity  类型  int  效验类型 取值为N,E,O,,S
*@return  0 success or -1 err
*/
int set_parity(int fd, int databits, int stopbits, int parity)
{

	struct termios options;
	if (tcgetattr(fd, &options) != 0)
	{
		perror("tcgetattr");
		return -1;
	}

	options.c_cflag &= ~CSIZE;
	switch (databits) /*设置数据位数*/
	{
		case 7:
			options.c_cflag |= CS7;
			break;
		case 8:
			options.c_cflag |= CS8;
			break;
		default:
			fprintf(stderr, "Unsupported data size\n");

			return -1;
	}
	
	switch (parity)
  	{
		case 'n':
		case 'N':
			options.c_cflag &= ~PARENB;   /* Clear parity enable */
			options.c_iflag &= ~INPCK;     /* Enable parity checking */
			options.c_iflag &= ~(ICRNL|IGNCR);
			options.c_lflag &= ~(ICANON );
			break;
		case 'o':
		case 'O':
			options.c_cflag |= (PARODD | PARENB);  /* 设置为奇效验*/ 
			options.c_iflag |= INPCK;             /* Disnable parity checking */
			break;
		case 'e':
		case 'E':
			options.c_cflag |= PARENB;     /* Enable parity */
			options.c_cflag &= ~PARODD;   /* 转换为偶效验*/  
			options.c_iflag |= INPCK;       /* Disnable parity checking */
			break;
		case 'S':
		case 's':  /*as no parity*/
			options.c_cflag &= ~PARENB;
			options.c_cflag &= ~CSTOPB;
			break;
		default:
			fprintf(stderr, "Unsupported parity\n");
			return -1;
	}

	/* 设置停止位*/   
	switch (stopbits)
  	{
		case 1:
			options.c_cflag &= ~CSTOPB;
			break;
		case 2:
			options.c_cflag |= CSTOPB;
			break;
		default:
			fprintf(stderr,"Unsupported stop bits\n");
			return -1;
	}

	/* Set input parity option */
	if ((parity != 'n') || (parity != 'N'))
  		options.c_iflag |= INPCK;

	/* 若以O_NONBLOCK 方式open，这两个设置没有作用，等同于都为0 */
	/* 若非O_NONBLOCK 方式open，具体作用可参考其他博客，关键词linux VTIME */
    options.c_cc[VTIME] = 10; // 1s
    options.c_cc[VMIN] = 0; 

	/* 清空正读的数据，且不会读出 */
	tcflush(fd,TCIFLUSH); 
	
	/*采用原始模式通讯*/
	options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
	options.c_oflag &= ~OPOST;
	

	/* Update the options and do it NOW */
	if (tcsetattr(fd, TCSANOW, &options) != 0)
  	{
  		perror("SetupSerial 0");
		return -1;
	}

	return 0;
}

int main(int argc, char **argv)
{
	int fd;
	int ret = -1;
	const char *dev = NULL;
	const char *test_string = NULL;
	char *p_buffer = NULL;
	int nread = 0;
	int nwrite = 0;
	
	/* 1、检测传参 */
	if (argc < 2 || argc > 3 ) {
		printf("Usage:%s dev_name [self_loop_test_string]\n", argv[0]);
		exit(1);
	}
	dev = argv[1];
	if (NULL != argv[2]) {
		if (strlen(argv[2]) <= BUF_SIZE) {
			test_string = argv[2];
		} else {
			printf("self_loop_test_string must be smaller than %d.\n", BUF_SIZE);
			return 0;
		}
	}
	
	/* 2、打开串口 */
	fd = open(dev, O_RDWR | O_NOCTTY | O_NONBLOCK);
	if (-1 == fd) {
		printf("Cannot open %s:%s\n", dev, strerror(errno));
		exit(1);
	}
	printf("==== open %s success ====\n", dev);
	
#if 1
	/* 3、初始化设备 */
	if (-1 == set_speed(fd, DEF_BAUD)) {
		printf("Cannot set baudrate to 115200\n");
		close(fd);
		exit(1);
	}
	
  	if (-1 == set_parity(fd, 8, 1, 'N')) {
    	printf("Set Parity Error\n");
		close(fd);
    	exit(1);
  	}
#endif

	if (NULL != test_string) {
		/*开始自发自收测试*/
		/* 写串口 */
		do {
			nwrite = write(fd, test_string, strlen(test_string));
		} while(nwrite <= 0);
		printf("send %d bytes data.\n", nwrite);

		/* 清空buffer */
		memset(buffer, 0, BUF_SIZE);
		p_buffer = buffer;
		nread = 0;

		/* 读串口 */
		do {
			ret = read(fd, p_buffer, 64);

			if (ret > 0) {
				printf("read %d bytes data:%s\n", ret, p_buffer);
				p_buffer += ret;
				nread += ret;
			}
		} while(nread < nwrite);
		printf("all read %d bytes data:%s\n", nread, buffer);
		printf("====      test %s      ====\n", (0 == strcmp(buffer, test_string)) ? "success." : "error!!!");

		close(fd);
		return 0;
	}

	/*开始测试*/
	/*循环读取并回写串口内容*/
	printf("start read and pass back\n");
	while(1) {
		/* 清空buffer */
		memset(buffer, 0, BUF_SIZE);
		p_buffer = buffer;
		time_t ts = timeStamp();
		/* 读串口 */
		nread = read(fd, buffer, 64);
		if(nread > 0) {
			printf("read %d bytes,data:%s,time:%ld.\n", nread,p_buffer,ts);
			do {
				ret = write(fd, buffer, nread);
			} while(ret <= 0);

			printf("write %d bytes,data:%s,time:%ld.\n", ret,p_buffer,ts);
		}
		sleep(1);
	}
	
	close(fd);
	
	return 0;
}

测试

第一步：将uart测试程序放到开发板上，执行chmod +x uart，赋予测试程序可执行权限。

第二步：关闭串口，使用网络登录，在telnet中执行： ./uart /dev/ttyS0

第三步：在PC端打开串口调式工具，打开对应串口，自动发送数据

测试效果如下所示：
在这里插入图片描述

改进版

代码

支持测试波特率、数据位（5、6、7、8）、停止位（1、2）、校验位（None、odd、Even、Mark、Space）不同参数

#include <stdio.h>      /*标准输入输出定义*/
#include <stdlib.h>     /*标准函数库定义*/
#include <fcntl.h>      /*文件控制定义*/
#include <termios.h>    /*PPSIX终端控制定义*/
#include <unistd.h>     /*Unix标准函数定义*/
#include <string.h>
#include <sys/time.h>
#include <stdint.h>
#include <sys/select.h>

#define BUF_SIZE	100

char buffer[BUF_SIZE];

time_t timeStamp()
{
	time_t time_now = time(NULL);
	return time_now;
}


int set_parity(int fd, int baudrate,int databits, int stopbits, char parity)
{
   struct termios options;

     // 获取串口参数
    if (tcgetattr(fd, &options) != 0) {
        perror("tcgetattr error");
        return -1;
    }
	
    /*设置输入输出波特率，两者保持一致*/
    switch(baudrate)
    {
      
        case 9600:
            cfsetispeed(&options,B9600);
            cfsetospeed(&options,B9600);
            break;
        case 19200:
            cfsetispeed(&options,B19200);
            cfsetospeed(&options,B19200);
            break;
        case 38400:
            cfsetispeed(&options,B38400);
            cfsetospeed(&options,B38400);
            break;
        case 57600:
            cfsetispeed(&options,B57600);
            cfsetospeed(&options,B57600);
            break;
        case 115200: 
            cfsetispeed(&options,B115200);
            cfsetospeed(&options,B115200);
            break;
        default:
            fprintf(stderr,"Unkown baude!\n");
            return -1;
    }


	switch (databits) /*设置数据位数*/
	{
		case 5:
            options.c_cflag &= ~CSIZE;
            options.c_cflag |= CS5;
            break;
        case 6:
            options.c_cflag &= ~CSIZE;
            options.c_cflag |= CS6;
            break;
        case 7:
            options.c_cflag &= ~CSIZE;
			options.c_cflag |= CS7;
			break;
		case 8:
            options.c_cflag &= ~CSIZE;
			options.c_cflag |= CS8;
			break;
		default:
			fprintf(stderr, "Unsupported data size\n");
    	    return -1;
	}
	
	switch (parity)/*设置校验位*/
  	{
		/*无奇偶校验位*/
        case 'n':
		case 'N':
			options.c_cflag &= ~PARENB;   /* Clear parity enable */
			options.c_iflag &= ~INPCK;     /* Enable parity checking */
			options.c_iflag &= ~(ICRNL|IGNCR);
			options.c_lflag &= ~(ICANON );
			break;
        /*设置奇校验*/
		case 'o':
		case 'O':
			options.c_cflag |= (PARODD | PARENB);  /* 设置为奇效验*/ 
			options.c_iflag |= INPCK;             /* Disnable parity checking */
			break;
        /*设置偶校验*/
		case 'e':
		case 'E':
			options.c_cflag |= PARENB;     /* Enable parity */
			options.c_cflag &= ~PARODD;   /* 转换为偶效验*/  
			options.c_iflag |= INPCK;       /* Disnable parity checking */
			break;
        /*设为空格，即停止位为两位*/
		case 'S':
		case 's':  /*as no parity*/
			options.c_cflag &= ~PARENB;
			options.c_cflag &= ~CSTOPB;
			break;
		default:
			fprintf(stderr, "Unsupported parity\n");
			return -1;
	}

	/* 设置停止位*/   
	switch (stopbits)
  	{
		case 1:
			options.c_cflag &= ~CSTOPB;
			break;
		case 2:
			options.c_cflag |= CSTOPB;
			break;
		default:
			fprintf(stderr,"Unsupported stop bits\n");
			return -1;
	}

	/* Set input parity option */
	if ((parity != 'n') || (parity != 'N'))
  		options.c_iflag |= INPCK;

	/* 若以O_NONBLOCK 方式open，这两个设置没有作用，等同于都为0 */
	/* 若非O_NONBLOCK 方式open，具体作用可参考其他博客，关键词linux VTIME */
    options.c_cc[VTIME] = 10; // 1s
    options.c_cc[VMIN] = 0; 

	/* 清空正读的数据，且不会读出 */
	tcflush(fd,TCIFLUSH); 
	
	/*设置本地为原始模式通讯*/
	options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
	options.c_oflag &= ~OPOST;
	

	/* Update the options and do it NOW */
	if (tcsetattr(fd, TCSANOW, &options) != 0)
  	{
  		perror("tcsetattr failed");
		return -1;
	}

	return 0;
}

int main(int argc, char *argv[]) {
    int fd;
    int opt;
    int baudrate,databits,stopbits,flow;
    char parity;
    char *devname = NULL;
    char *p_buffer = NULL;
    int nread = 0;
	int nwrite = 0;
    int ret = -1;
    fd_set read_fds, write_fds;  // 读写文件描述符集合
    int max_fd;                  // 最大文件描述符
   

    //检测传参
   if (argc < 2 || argc > 12 ) {
		printf("Usage:%s  dev_name [-b baudrate] [-d databits] [-s stopbits] [-p parity] \n", argv[0]);
		exit(1);
	} 

     devname = argv[1];
     /* printf("dev_name is : %s\n",argv[1]);
     printf("argc count is %d\n",argc); */

     while ((opt = getopt(argc, argv, "b:d:s:p:")) != -1) {
                switch (opt) {
                case 'b':
                    baudrate =  atoi(optarg); 
                break;
                case 'd':
                    databits  = atoi(optarg);   
                break;
                case 's':
                    stopbits  = atoi(optarg);
                break;
                case 'p':
                    strcpy(&parity, optarg);
                break;
                default: 
                        printf("Usage: %s  dev_name [-b baudrate] [-d databits] [-s stopbits] [-p parity]\n", argv[0]);
                        return -1;
                }
        }
    printf("baudrate is :%d,databits is :%d,stopbits is :%d,parity is :%c\n",baudrate,databits,stopbits,parity);

    // 打开串口设备
    fd = open(devname, O_RDWR | O_NOCTTY | O_NONBLOCK);
    if (fd < 0) {
        perror("open device error");
        return -1;
    }
    printf("==== open %s success ====\n", devname);

#if 1
	/* 初始化设备 */
  	if (-1 == set_parity(fd,baudrate,databits,stopbits,parity)) {
    	printf("Set Parity Error\n");
		close(fd);
    	exit(1);
  	}
#endif
    
    // 初始化文件描述符集合
    FD_ZERO(&read_fds);
    FD_ZERO(&write_fds);
    FD_SET(fd, &read_fds);
    max_fd = fd;

   /*开始测试*/
	/*循环读取并回写串口内容*/
	printf("start read and pass back\n");
	while(1) {

         // 使用select监控串口设备描述符
        int ret = select(max_fd + 1, &read_fds, &write_fds, NULL, NULL);
        if (ret < 0) {
            perror("select error");
            exit(1);
        }
        
        // 如果串口设备可读，则读取数据并打印
        if (FD_ISSET(fd, &read_fds)) {
            /* 清空buffer */
		    memset(buffer, 0, BUF_SIZE);
            p_buffer = buffer;
		    time_t ts = timeStamp();
		    /* 读串口 */
		    nread = read(fd, buffer, 64);
		    if(nread > 0) {
			printf("read %d bytes,data:%s,time:%ld.\n", nread,p_buffer,ts);
			do {
				ret = write(fd, buffer, nread);
			} while(ret <= 0);

			printf("write %d bytes,data:%s,time:%ld.\n", ret,p_buffer,ts);
		    }
            
        }
		
		
	}

    // 关闭串口设备
    close(fd);

    return 0;
}
用法：
Usage:./uart2  dev_name [-b baudrate] [-d databits] [-s stopbits] [-p parity]

exmple: ./uart2 /dev/ttyS1 -b 115200 -d 8 -s 1 -p n

参数说明：
    dev_name: 要测试的设备节点，这里以k510 uart1为例，设备节点为/dev/ttyS1 

    -b baudrate: 波特率，参数支持9600、19200、38400、57600、115200

    -d databits: 数据位数，参数支持5、6、7、8

    -s stopbits: 停止位，参数支持1、2

    -p parity : 校验位，参数支持 n/N(None)、o/O(Odd)、e/E(Even)、s/S(space)
MHai
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Linux驱动：UART串口程序（亲测好用！）
m0_51756449的博客
04-26 254
本篇代码是配置串口的一些基本配置：波特率、校验位、数据位等。前提是内核中有对应的设备节点，可以在各自的开发板开发手册中找到串口所对应的设备节点。也是找了很多篇博主的文章参照，不过一开始配置的时候有问题打不开，最终还是一个一个配出来了。
linux设备模型之uart驱动架构分析
weixin_34247155的博客
01-09 261
一:前言 接着前面的终端控制台分析,接下来分析serial的驱动.在linux中,serial也对应着终端,通常被称为串口终端.在shell上,我们看到的/dev/ttyS*就是串口终端所对应的设备节点. 在分析具体的serial驱动之前.有必要先分析uart驱动架构.uart是Universal Asynchronous Receiver and Transmitt...
linux下的UART试验
南城故梦的专栏
05-30 2132
一、试验概述 　　     (1)试验目的:掌握通过文件系统操作UART设备的方法. 　　(2)在linux中，所有设备都是以文件的形式被打开并进行读/写操作的，本试验中使用POSIX兼容的文件操作接口函数对底层设备进行操作.其中，POSIX是Portable Operating System Interface for UNIX的首字母缩写，是一套IEEE和ISO标准. 二、UART常用
Linux下串口参数VTIME和VMIN的用法
renyinmin 的博客
07-23 2322
VTIME指定了等待的时间,VMIN指定了读取字符的最小数量。 它们不同组合地取值会得到不同的结果，分别如下： 1．当VTIME>0，VMIN>0时。read调用将保持阻塞直到读取到第一个字符，读到了第一个字符之后开始计时，此后若时间到了VTIME或者时间未到但已读够了VMIN个字符则会返回；若在时间未到之前又读到了一个字符(但此时读到的总数仍不够VMIN)则计时重新开始。 2. 当VTIME>0，VMIN=0时。read调用读到数据...
linux uart测试程序
weixin_44402611的博客
08-24 395
驱动是在内核里面，但是不集中，很分散，测试程序很重要，要设置好各种cflag，顺序也要对，才能够正确的读取出来数据。
linux读取串口数据 c6,UART口程序调试小结
weixin_35757191的博客
05-11 318
1、设置TxD为推挽式输出，一定要配置和TxD和RxD引脚。在不同的MCU环境下，配置的过程可能不同，但有一点是确定的，就是TxD一定要配置成输出模式，RxD配置成输入模式，并允许卡拉电阻。在78F0376D中的配置代码如下：TxD6_PM=0; //output mode for TxD6TxD6=1; //set TxD6 output to hi...
UART串口数据收发应用程序
03-19
uart串口收发linux用户态程序
linux c uart 串口通信 应用层代码
03-01
linux c uart 串口通信 应用层代码
Linux上串口应用
02-27
Linux上串口应用, 类似Windows超级终端，很容易移植到嵌入式LINUX平台。
linux_uart
02-17
本程序为linux下串口采集程序；本例中连接的设备是一款电力谐波设备，采集串口发出的数据，写到一个文件中，供相关页面访问、显示和...本例可以作为linux下串口驱动或者串口应用程序的入门学习程序，与各位初学者共勉之
linux下串口程序，实现收发功能，测试串口
06-05
linux下的串口测试程序，可以实现收发功能，检测串口是否正常
在linux下测试串口的简单方法
xunil_ko的专栏
10-07 8860
习惯了在windows下的调试助手，刚跑去linux下还不怎么习惯，相信会越来越好的需要2,3脚端接在一终端(1窗口)中输入cat /dev/ttyS0在另外一终端(2窗口)中输入echo hello>/dev/ttyS0然后在1窗口中就能看见 hello 了 这样就说明串口好使了，呵呵！
Linux UART接口调试技巧
Happiness is a form of courage。
03-03 1万+
在嵌入式项目中，UART接口的使用频率很高，多种模块(2G通信模组、蓝牙模块，等等)都会通过UART接口与主控MCU相连。本文将梳理UART接口调试流程，为调试工作提供参考，解决调试过程中可能遇到的问题，快速完成UART接口调试，实现模块功能。配置驱动选项首先查看原理图确认串口号，比如UART1，同时查看该串口引脚是否有复用功能，比如用作SD卡接口。如果有复用，需要在内核配置中取消复用功能的选项。然
linux串口测试工具方式
weixin_45073610的博客
03-14 3385
关于linux串口测试工具方式总结（陆续更新。。。） 方式一：stty工具下面具体介绍如何查看波特率和设置还有查看 查看波特率：stty -F /dev/ttyS2 -a 设置波特率： stty -F /dev/ttyS2 ispeed 115200 ospeed 115200 cs8 查看数据：cat /dev/ttyS2 方式二：microcom工具 直接查看microcom -t 1500 -s115200 /dev/ttyS2 -t: 代表写入超时时间 -s;代表传输速度 就是我们所说的设置波特率
Linux下查看串口是否可用的笨方法
热门推荐
人人都懂物联网
01-12 1万+
最近尝试将一个网关程序从 VxWorks 平台移植到 Linux 平台。在串口方面遇到了一些问题，这里记录一下。 　　首先在 VxWorks 下，用 devs 命令查看设备：-> devs drv name 0 /null 1 /tyCo/0 1 /tyCo/1 2 /pcConsole/0 2 /pcConsole/1 9 host: 4 /ram 11 /vio
uart 使用软流控
jack_bro的博客
03-10 985
Software flow control is enabled using theIXON,IXOFF, andIXANYconstants: options.c_iflag |= (IXON | IXOFF | IXANY); To disable software flow control simply mask those bits: options.c_iflag ...
linux uart dma模式
最新发布
07-14
UART (通用异步收发传输器)是一种常见的串口通信接口，广泛应用于嵌入式系统中。DMA (直接内存访问)是一种数据传输方式，可以将数据直接从外设(如UART)传输到内存，或从内存传输到外设，而无需CPU介入。Linux操作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值