devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux 串口编程_options.c_cflag

作者：小丑西瓜9 | 2024-03-01 11:35:26

赞

踩

options.c_cflag

 

串行接口

串行接口 (Serial Interface) 是指数据一位一位地顺序传送，其特点是通信线路简单，只要一对传输线就可以实现双向通信，从而大大降低了成本，特别适用于远距离通信，但传送速度较慢。一条信息的各位数据被逐位按顺序传送的通讯方式称为串行通讯。

串行通讯的特点是：数据位的传送，按位顺序进行，最少只需一根传输线即可完成；成本低但传送速度慢。串行通讯的距离可以从几米到几千米；根据信息的传送方向，串行通讯可以进一步分为单工、半双工和全双工三种。

同步串行接口（SynchronousSerialInterface，SSI）是一种常用的工业用通信接口。。

异步串行是指UART（Universal Asynchronous Receiver/Transmitter），通用异步接收/发送。UART是一个并行输入成为串行输出的芯片，通常集成在主板上。UART包含TTL电平的串口和RS232电平的串口。

串口除了RS232，还有RS422，RS485，今天主要说的是RS232，其实USB（Universal Serial Bus）也是串口的一种，它的协议更加复杂，还有采用D+和D-差分信号，抗干扰能力更强，速率更快。

图片都是之前从网上找到

接下来开始讲代码了，主要分成两个部分，一就是串口配置，二是串口读写

  1. int open_uart(char* port)
  2. {
  3. 	int fd = open(port,O_RDWR|O_NOCTTY);
  4. 	if (fd < 0){
  5. 		printf("Open serial %s fail\n",port);
  6. 		return -1;
  7. 	}
  8. 	else{
  9. 		//printf("Open serial %s successful\n",port);
  10. 	}
  11. 	//set bolck mode
  12. 	if (fcntl(fd,F_SETFL,0)<0){
  13. 		printf("set %s block failed\n",port);
  14. 	}
  15. 	if(0 == isatty(STDIN_FILENO)){
  16. 		printf("standard input is not a terminal device\n");
  17. 	}
  18. 	//else{
  19. 	//	printf("isatty success\n");
  20. 	//}
  21. 	return fd;
  22. }

配置串口

  1. int set_uart_config(int fd,uart_cfg_t* s_cfg)    
  2. {    
  3.   int   ret;
  4.   unsigned int i;    
  5.   int   speed_arr[] = { B115200, B9600};
  6.   int   name_arr[] = {115200, 9600};
  7.   struct termios options;    
  8.  
  9.   ret = tcgetattr( fd,&options);    
  10.   if( ret !=  0){    
  11.     printf("ERROR: Get Serial Failed\n");        
  12.     return ret;     
  13.   }    
  14.  
  15.   for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++){    
  16.     if(s_cfg->speed == name_arr[i]){                 
  17.       cfsetispeed(&options, speed_arr[i]);
  18.       cfsetospeed(&options, speed_arr[i]);
  19.     }    
  20.   }         
  21.  
  22.   options.c_cflag |= CLOCAL;
  23.   options.c_cflag |= CREAD;
  24.  
  25.   switch(s_cfg->flow_ctrl)
  26.   {
  27.     case 0 :    
  28.       options.c_cflag &= ~CRTSCTS;    
  29.       break;       
  30.     case 1 :   
  31.       options.c_cflag |= CRTSCTS;    
  32.       break;    
  33.     case 2 :   
  34.       options.c_cflag |= IXON | IXOFF | IXANY;    
  35.       break; 
  36.     default:
  37.       options.c_cflag |= IXON | IXOFF | IXANY;    
  38.       break;  
  39.   }    
  40.  
  41.   options.c_cflag &= ~CSIZE;    
  42.   switch (s_cfg->data_bits){      
  43.     case 5 :    
  44.       options.c_cflag |= CS5;    
  45.       break;    
  46.     case 6 :    
  47.       options.c_cflag |= CS6;    
  48.       break;    
  49.     case 7 :        
  50.       options.c_cflag |= CS7;    
  51.       break;    
  52.     case 8:        
  53.       options.c_cflag |= CS8;    
  54.       break;      
  55.     default:       
  56.       options.c_cflag |= CS8;
  57.       break;    
  58.   }    
  59.  
  60.   switch (s_cfg->parity[0]){      
  61.     case 'n':    
  62.     case 'N': 
  63.       options.c_cflag &= ~PARENB;     
  64.       options.c_iflag &= ~INPCK;        
  65.       break;     
  66.     case 'o':      
  67.     case 'O':        
  68.       options.c_cflag |= (PARODD | PARENB);     
  69.       options.c_iflag |= INPCK;                 
  70.       break;     
  71.     case 'e':     
  72.     case 'E':      
  73.       options.c_cflag |= PARENB;           
  74.       options.c_cflag &= ~PARODD;           
  75.       options.c_iflag |= INPCK;          
  76.       break;    
  77.     case 's':    
  78.     case 'S':     
  79.       options.c_cflag &= ~PARENB;    
  80.       options.c_cflag &= ~CSTOPB;    
  81.       break;     
  82.     default:      
  83.       options.c_cflag &= ~PARENB;    
  84.       options.c_cflag &= ~CSTOPB;    
  85.       break;     
  86.   }     
  87.  
  88. 	switch (s_cfg->stop_bits){
  89. 		case 1:
  90. 			options.c_cflag &= ~CSTOPB;
  91. 			break;
  92. 		case 2:
  93. 			options.c_cflag |= CSTOPB;
  94. 			break;
  95. 		default:
  96. 			options.c_cflag |= CSTOPB;
  97. 			break;
  98. 	}    
  99.  
  100. 	options.c_oflag &= ~OPOST;    
  101. 	options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);    
  102. 	options.c_cc[VTIME] = 20;      
  103. 	options.c_cc[VMIN] = 255;     
  104. 	tcflush(fd,TCIFLUSH);    
  105. 	ret=tcsetattr(fd,TCSANOW,&options);    
  106. 	if (ret != 0){    
  107. 		printf("ERROR: com set error!\n");      
  108. 		return ret;     
  109. 	}    
  110. 	return ret;     
  111. }

下面这些是我在写的时候，从网上查找并记录下来的一些笔记：

tcflag_t 是 unsigned short类型，cc_t 是 unsigned char类型

CRTCTS
使用硬件流控制。在高速（19200bps或更高）传输时，使用软件流控制会使效率降低，这个时候必须使用硬件流控制
~CRTCTS不控制
IXOFF
如果设置，为避免tty设备的输入缓冲区溢出，tty设备可以向终端发送停止符^S和开始符^Q，要求终端停止或重新开始
向计算机发送数据。通过停止符和开始符来控制数据流的方式叫软件流控制，软件流控制方式较少用，我们主要还是用
硬件流控制方式。硬件流控制在c_cflag标志中设置。
IXON
如果设置，接收到^S后会停止向这个tty设备输出，接收到^Q后会恢复输出。
IXANY
如果设置，则接到任何字符都会重新开始输出，而不仅仅是^Q字符。

options.c_cflag |= CS8;         //使用8位数据位
options.c_cflag |= CS7;         //使用7位数据位
options.c_cflag |= CS6;         //使用6位数据位
options.c_cflag |= CS5;         //使用5位数据位

CSIZE 先屏蔽其他标志位

options.c_cflag |= CSTOPB;            //2位停止位
options.c_cflag &= ~CSTOPB;       //1位停止位
PARODD               使用奇校验而不是偶校验
PARENB               校验使能位
INPCK                 奇偶校验使能
1. N（None [没有]）
2. O Odd 奇校验

3. E Even 偶校验

4. S Space 校验位固定为0

ISIG 当输入INTR、QUIT、SUSP或DSUSP时，产生相应的信号
ICANON  使用标准输入模式
XCASE 在ICANON和XCASE同时设置的情况下，终端只使用大写。
ECHO  显示输入字符
ECHOE  如果ICANON同时设置，ERASE将删除输入的字符
ECHOK 如果ICANON同时设置，KILL将删除当前行
OPOST 处理后输出
open未设置O_NONBLOCK或O_NDELAY的情况下
VTIME定义要求等待的时间量(取值不能大于cc_t)。
VMIN定义了要求等待的最小字节数。

options.c_cc[VTIME] = X; 　　//设置从获取到1个字节后开始计时的超时时间
options.c_cc[VMIN] = Y;　　 ? //设置要求等待的最小字节数
1、X=0，Y!=0。函数read()只有在读取了Y个字节的数据或者收到一个信号的时候才返回；
2、X!=0，Y=0。即使没有数据可以读取，read()函数等待X时间量后返回；
3、X!=0,Y!=0。第一个字节数据到时开始，最先满足收到Y个字节或达超时时间X任意一个条件，read()返回；
4、X=0,Y=0。即使读取不到任何数据，函数read也会立即返回

常用函数介绍。

1、读取当前参数函数：
int tcgetattr(int fd,struct termios *termios_p)
    fd：open操作后返回的文件句柄
    *termios_p：为前面介绍的结构体
    初始化开始前调用这个函数.

2、获取当前波特率函数：
int speed_t cfgetispeed(const struct termios *termios_p)
int speed_t cfgetospeed(const struct termios *termios_p)
    *termios_p：为前面介绍的结构体
    成功返回0，失败返回-1

3、波特率设置函数：
int cfsetispeed(struct termios *termios_p,speed_t speed)
int cfsetospeed(struct termios *termios_p,speed_t speed)
    *termios_p：为前面介绍的结构体
    speed：波特率，常用B2400，B4800，B9600，B115200，B460800
    成功返回0，失败返回-1

4、清空buffer数据函数：
int tcflush(int fd,int queue_selector)
    queue_selector:有三个常用宏定义
                    TCIFLUSH:清空正读的数据，且不会读出
                    TCOFLUSH:清空正写入的数据，且不会发送到终端
                    TCIOFLUSH:清空所有正在发生的I/O数据.

    成功返回0，失败返回-1

5、设置串口参数函数：
int tcsetattr(int fd,int optional_actions,cons struct termios *termios_p)
    optional_actions:有三个常用宏定义
                    TCSANOW:不等数据传输完毕，立即改变属性
                    TCSADRAIN:等所有数据传输完毕，再改变属性
                    TCSAFLUSH:清空输入输出缓冲区才改变属性

    成功返回0，失败返回-1 

第二部分：串口读写，在这里我使用的是经tx和rx连接起来，自环

  1. int single_uart_test(uart_cfg_t *s_cfg)
  2. {
  3. 	int len = 0,res = 0,len_tmp = 0,flag = 0;	
  4. 	char tmp[4096];
  5. 	bzero(tmp,sizeof(tmp));		
  6. 	int fd = open_uart(uart_map(s_cfg->dev_id));
  7. 	init_uart(fd,s_cfg);
  8.  
  9. 	if(signal(SIGTSTP,func_quit) == SIG_ERR){
  10. 		printf("signal error exit now!\n");
  11. 		return -1;
  12. 	}	
  13. 	if(signal(SIGINT,func_quit) == SIG_ERR){
  14. 		printf("signal error exit now!\n");
  15. 		return -1;
  16. 	}	
  17. 	printf("Welcome to com%d test mode:\n",s_cfg->dev_id);
  18. 	
  19. 	while(true){
  20. 		if (!flag) printf("Com%d says:",s_cfg->dev_id);
  21. 		flag++;
  22. 		fgets(big_buf,BUFFER_SIZE,stdin);
  23. 		len = strlen(big_buf);
  24. 		//printf("len:%d\n",len);
  25. 		write_uart(fd,big_buf,len,s_cfg->dev_id);
  26. 		read_uart(fd,s_cfg->dev_id,len,read_buf);	
  27. 				
  28. 		if( (0 == strncmp(read_buf,"quit",4)) || (0 == strncmp(read_buf,"exit",4))){
  29. 			printf("quit console %d test mode \n",s_cfg->dev_id);
  30. 			exit(0);
  31. 			}
  32. 		if ( 0 != strncmp(read_buf,big_buf,sizeof(read_buf))){
  33. 			res++;
  34. 		}
  35. 		//string -'\0'
  36. 		if(len == (BUFFER_SIZE-1)){
  37. 			memcpy(tmp+len_tmp,read_buf,len);
  38. 			len_tmp += len;
  39. 			//printf("tmp:%s\n",tmp);
  40. 		}else{
  41. 			memcpy(tmp+len_tmp,read_buf,len);
  42. 			if(res == 0){
  43. 				printf("Com%d recv:%s\n",s_cfg->dev_id,tmp);
  44. 				printf("Com%d ------->pass \n",s_cfg->dev_id);
  45. 				len_tmp = 0;
  46. 				bzero(tmp,sizeof(tmp));
  47. 			}else{
  48. 				printf("Com%d ------->fail \n",s_cfg->dev_id);
  49. 				//flushes both data received but not read, and data written but not transmitted.
  50. 				tcflush(fd,TCIOFLUSH);
  51. 			}
  52. 			flag = 0;
  53. 		}
  54. 		bzero(read_buf,sizeof(read_buf));
  55. 		bzero(big_buf,sizeof(big_buf));			
  56. 	}
  57. 	close_uart(fd,s_cfg->dev_id);
  58. 	return err_no;
  59. }

源码放在资源下载，源码是一个48ports串口服务器的串口测试代码，有删减。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/173620?site
推荐阅读
相关标签

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

  

闽ICP备14008679号