linux串口通信（三）：串口通信的实例（有错）

---

一、封装串口文件

#ifndef  _USART_H
	#define  _USART_H
	


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



	/***** 声明函数 *****/
	
	/** @brief 打开串口并返回串口设备文件描述
	
	@param fd 文件描述符
	@param port 串口号(ttyS0,ttyS1,ttyS2)
	@return 正确返回为1，错误返回为-1
	 */ 
	int UART0_Open(int fd, char* port);


	/** @brief 关闭串口并返回串口设备文件描述
	
	@param fd 文件描述符
	 */ 
	void UART0_Close(int fd);


	/** @brief 设置串口数据位，停止位和效验位
	
	@param fd 文件描述符
	@param speed 串口速度
	@param flow_ctrl 数据流控制
	@param databits 数据位，取值为7或者8
	@param stopbits 停止位，取值为1或者2  
	@param parity 效验类型，取值为N,E,O,S
	@return 正确返回为1，错误返回为-1
	 */ 
	int UART0_Set(int fd, int speed, int flow_ctrl, int databits, int stopbits, int parity);
	
	
	/** @brief 串口初始化

	@param fd 文件描述符
	@param speed 串口速度
	@param flow_ctrl 数据流控制
	@param databits 数据位，取值为7或者8
	@param stopbits 停止位，取值为1或者2  
	@param parity 效验类型，取值为N,E,O,S
	@return 正确返回为1，错误返回为-1
	 */ 
	int UART0_Init(int fd, int speed, int flow_ctrl, int databits, int stopbits, int parity);


	/** @brief 发送数据
	
	@param fd 文件描述符
	@param send_buf 存放串口发送数据
	@param data_len 一帧数据的个数
	@return 正确返回为1，错误返回为-1
	 */ 
	int UART0_Send(int fd, char* send_buf, int data_len);


	/** @brief 接收串口数据
	
	@param fd 文件描述符
	@param rcv_buf 接收串口中数据存入rcv_buf缓冲区中
	@param data_len 一帧数据的长度
	@return 正确返回为1，错误返回为-1
	 */ 
	int UART0_Recv(int fd, char* rcv_buf, int data_len);	 
#endif

int UART0_Open(int fd, char* port)
{
    fd = open(port, O_RDWR | O_NOCTTY | O_NDELAY);    
    if (fd < 0)    
    {    
        printf("Can't Open Serial Port\n");    
        return -1;
    }    
    //恢复串口为阻塞状态                                   
    if(fcntl(fd, F_SETFL, 0) < 0)    
    {    
        printf("fcntl failed!\n");    
        return -1;    
    }         
    else    
    {    
        printf("Open Serial Port Succeed!");
    }
    return 1;    
}   

void UART0_Close(int fd)    
{
	close(fd);
}

int UART0_Set(int fd, int speed, int flow_ctrl, int databits, int stopbits, int parity)  
{
    int   i;    
    int   status;    
    int   speed_arr[] = { B115200, B19200, B9600, B4800, B2400, B1200, B300}; 
    int   name_arr[] = {115200,  19200,  9600,  4800,  2400,  1200,  300};    
             
    struct termios options;    
       
    /*  tcgetattr(fd,&options)得到与fd指向对象的相关参数，并将它们保存于options,该函数还可以测试配置是否正确，
        该串口是否可用等。若调用成功，函数返回值为0，若调用失败，函数返回值为1.  */    
    if( tcgetattr(fd, &options) != 0)    
    {    
        printf("SetupSerial 1\n");
        return -1;     
    }    
      
    //设置串口输入波特率和输出波特率    
    for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++)    
    {    
        if  (speed == name_arr[i])    
        {                 
            cfsetispeed(&options, speed_arr[i]);     
            cfsetospeed(&options, speed_arr[i]);      
        }    
    } 

	//修改控制模式，保证程序不会占用串口    
    options.c_cflag |= CLOCAL;    
    
    //修改控制模式，使得能够从串口中读取输入数据    
    options.c_cflag |= CREAD;    
      
    //设置数据流控制    
    switch(flow_ctrl)    
    {    
        case 0 ://不使用流控制
        {
              options.c_cflag &= ~CRTSCTS;    
              break;       
        }  
        case 1 ://使用硬件流控制
        {
              options.c_cflag |= CRTSCTS;    
              break;
        }
        case 2 ://使用软件流控制
        {
              options.c_cflag |= IXON | IXOFF | IXANY;    
              break;    
        }
    }
    
    //设置数据位    
    //屏蔽其他标志位    
    options.c_cflag &= ~CSIZE;    
    switch (databits)    
    {      
        case 5    :
        {
                     options.c_cflag |= CS5;    
                     break;    
        }
        case 6    :    
        {
                     options.c_cflag |= CS6;    
                     break;    
        }
        case 7    :        
        {
                 options.c_cflag |= CS7;    
                 break;    
        }
        case 8:        
        {
                 options.c_cflag |= CS8;    
                 break;      
        }
        default:       
        {
                 printf("Unsupported data size\n");    
                 return -1;
        }
    }    
    //设置校验位    
    switch (parity)    
    {      
        case 'n':    
        case 'N': //无奇偶校验位
                 options.c_cflag &= ~PARENB;     
                 options.c_iflag &= ~INPCK;        
                 break;     
        case 'o':      
        case 'O'://设置为奇校验        
                 options.c_cflag |= (PARODD | PARENB);     
                 options.c_iflag |= INPCK;                 
                 break;     
        case 'e':     
        case 'E'://设置为偶校验      
                 options.c_cflag |= PARENB;           
                 options.c_cflag &= ~PARODD;           
                 options.c_iflag |= INPCK;          
                 break;    
        case 's':    
        case 'S': //设置为空格     
                 options.c_cflag &= ~PARENB;    
                 options.c_cflag &= ~CSTOPB;    
                 break;     
        default:      
                 printf("Unsupported parity\n");        
                 return -1;     
    }     

    // 设置停止位     
    switch (stopbits)    
    {      
        case 1:       
			options.c_cflag &= ~CSTOPB;
			break;     
        case 2:       
			options.c_cflag |= CSTOPB;
			break;
        default:       
			printf("Unsupported stop bits\n");     
			return -1; 
    }    
       
    //修改输出模式，原始数据输出    
    options.c_oflag &= ~OPOST;    
      
    options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);    
    //options.c_lflag &= ~(ISIG | ICANON);    
       
    //设置等待时间和最小接收字符    
    options.c_cc[VTIME] = 1; /* 读取一个字符等待1*(1/10)s */      
    options.c_cc[VMIN] = 1; /* 读取字符的最少个数为1 */    
       
    //如果发生数据溢出，接收数据，但是不再读取 刷新收到的数据但是不读    
    tcflush(fd, TCIFLUSH);    
       
    //激活配置 (将修改后的termios数据设置到串口中）    
    if (tcsetattr(fd,TCSANOW,&options) != 0)      
    {    
        printf("com set error!\n");      
        return -1;     
    }    
    return 1;     
}    

// fd, 115200, 0, 8, 1, 'N'
int UART0_Init(int fd, int speed, int flow_ctrl, int databits, int stopbits, int parity)
{    
    int err;    
    //设置串口数据帧格式
    if (UART0_Set(fd, speed, flow_ctrl, databits, stopbits, parity) == -1)
    {                                                             
        return -1;    
    }    
    else    
    {    
        return 1;    
    }    
}

int UART0_Send(int fd, char* send_buf, int data_len)
{    
    int len = 0;   
    len = write(fd, send_buf, data_len);    
    if (len == data_len)    
    {    
        printf("Data sent is %s\n", send_buf);  
        return 1;    
    }         
    else       
    {           
        tcflush(fd,TCOFLUSH);    
        return -1;    
    }          
}

int UART0_Recv(int fd, char* rcv_buf, int data_len)
{    
    int len,fs_sel;    
    fd_set fs_read;    
       
    struct timeval time;    
       
    FD_ZERO(&fs_read);    
    FD_SET(fd, &fs_read);    
       
    time.tv_sec = 10;    
    time.tv_usec = 0;    
       
    //使用select实现串口的多路通信    
    fs_sel = select(fd + 1, &fs_read, NULL, NULL, &time);    
    printf("fs_sel = %d\n",fs_sel);    
    if(fs_sel)    
    {    
        len = read(fd, rcv_buf, data_len);    
        return len;    
    }    
    else    
    {    
        return -1;    
    }         
}

二、main文件

#include <iostream>
#include "serial.h"

using namespace std;

int main(){
	int fd = 0;
    char port_name[] = "/dev/ttyUSB0";

    if(UART0_Open(fd, port_name) == -1)
    {
        return -1;
    }

	if(UART0_Init(fd, 115200, 0, 8, 1, 'N') == -1){
		return -1;
	}

	char buff_send[5] = {'a','b','c','d'};

	if(UART0_Send(fd, buff_send, 5) == -1){
		return - 1;
	}

	char buff_receive[100] = "";
	int len = UART0_Recv(fd, buff_receive, 5);
	printf("收到[%d]个字符\n", len);

	return 0 ;
}