Linux下读写UART串口的代码

Linux下读写UART串口的代码

 

转载至：http://blog.csdn.net/yao_guet/article/details/24768967

2014-04-30 09:35 15672人阅读 评论(2) 收藏 举报

 分类：

Linux（35）  Android（37） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

Linux下读写UART串口的代码，从IBM Developer network上拿来的东西，操作比较的复杂，就直接跳过了，好在代码能用，记录一下～

两个有用的函数～

 

[cpp] view plain copy

1.   
2. /** 
3. *@brief  设置串口通信速率 
4. *@param  fd     类型 int  打开串口的文件句柄 
5. *@param  speed  类型 int  串口速度 
6. *@return  void 
7. */  
8. int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,  
9.                    B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300, };  
10. int name_arr[] = {115200, 38400, 19200, 9600, 4800, 2400, 1200,  300,   
11.                   115200, 38400, 19200, 9600, 4800, 2400, 1200,  300, };  
12. void set_speed(int fd, int speed){  
13.   int   i;   
14.   int   status;   
15.   struct termios   Opt;  
16.   tcgetattr(fd, &Opt);   
17.   for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) {   
18.     if  (speed == name_arr[i]) {       
19.       tcflush(fd, TCIOFLUSH);       
20.       cfsetispeed(&Opt, speed_arr[i]);    
21.       cfsetospeed(&Opt, speed_arr[i]);     
22.       status = tcsetattr(fd, TCSANOW, &Opt);    
23.       if  (status != 0) {          
24.         perror("tcsetattr fd1");    
25.         return;       
26.       }      
27.       tcflush(fd,TCIOFLUSH);     
28.     }    
29.   }  
30. }  

[cpp] view plain copy

1.   
2. /** 
3. *@brief   设置串口数据位，停止位和效验位 
4. *@param  fd     类型  int  打开的串口文件句柄 
5. *@param  databits 类型  int 数据位   取值 为 7 或者8 
6. *@param  stopbits 类型  int 停止位   取值为 1 或者2 
7. *@param  parity  类型  int  效验类型 取值为N,E,O,,S 
8. */  
9. int set_Parity(int fd,int databits,int stopbits,int parity)  
10. {   
11.     struct termios options;   
12.     if  ( tcgetattr( fd,&options)  !=  0) {   
13.         perror("SetupSerial 1");       
14.         return(FALSE);    
15.     }  
16.     options.c_cflag &= ~CSIZE;   
17.     switch (databits) /*设置数据位数*/  
18.     {     
19.     case 7:       
20.         options.c_cflag |= CS7;   
21.         break;  
22.     case 8:       
23.         options.c_cflag |= CS8;  
24.         break;     
25.     default:      
26.         fprintf(stderr,"Unsupported data size\n"); return (FALSE);    
27.     }  
28.     switch (parity)   
29.     {     
30.         case 'n':  
31.         case 'N':      
32.             options.c_cflag &= ~PARENB;   /* Clear parity enable */  
33.             options.c_iflag &= ~INPCK;     /* Enable parity checking */   
34.             break;    
35.         case 'o':     
36.         case 'O':       
37.             options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/    
38.             options.c_iflag |= INPCK;             /* Disnable parity checking */   
39.             break;    
40.         case 'e':    
41.         case 'E':     
42.             options.c_cflag |= PARENB;     /* Enable parity */      
43.             options.c_cflag &= ~PARODD;   /* 转换为偶效验*/       
44.             options.c_iflag |= INPCK;       /* Disnable parity checking */  
45.             break;  
46.         case 'S':   
47.         case 's':  /*as no parity*/     
48.             options.c_cflag &= ~PARENB;  
49.             options.c_cflag &= ~CSTOPB;break;    
50.         default:     
51.             fprintf(stderr,"Unsupported parity\n");      
52.             return (FALSE);    
53.         }    
54.     /* 设置停止位*/    
55.     switch (stopbits)  
56.     {     
57.         case 1:      
58.             options.c_cflag &= ~CSTOPB;    
59.             break;    
60.         case 2:      
61.             options.c_cflag |= CSTOPB;    
62.            break;  
63.         default:      
64.              fprintf(stderr,"Unsupported stop bits\n");    
65.              return (FALSE);   
66.     }   
67.     /* Set input parity option */   
68.     if (parity != 'n')     
69.         options.c_iflag |= INPCK;   
70.     tcflush(fd,TCIFLUSH);  
71.     options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/     
72.     options.c_cc[VMIN] = 0; /* Update the options and do it NOW */  
73.     if (tcsetattr(fd,TCSANOW,&options) != 0)     
74.     {   
75.         perror("SetupSerial 3");     
76.         return (FALSE);    
77.     }   
78.     options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/  
79.     options.c_oflag  &= ~OPOST;   /*Output*/  
80.     return (TRUE);    
81. }  

调用的方法比较的简单，如下，fd是打开的tty设备的文件句柄

 

 

[cpp] view plain copy

1.    set_speed(fd,115200);  
2.    if (set_Parity(fd,8,1,'N') == FALSE)  {  
3. printf("Set Parity Error\n");  
4.    }  

总的测试代码如下。

 

 

[cpp] view plain copy

1. #include   
2.   
3. #include   
4. #include   
5. #include   
6. #include   
7. #define BAUDRATE        B115200  
8. #define UART_DEVICE     "/dev/ttyS3"  
9.   
10. #define FALSE  -1  
11. #define TRUE   0  
12.   
13. /** 
14. *@brief  设置串口通信速率 
15. *@param  fd     类型 int  打开串口的文件句柄 
16. *@param  speed  类型 int  串口速度 
17. *@return  void 
18. */  
19. int speed_arr[] = {B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300,  
20.                    B115200, B38400, B19200, B9600, B4800, B2400, B1200, B300, };  
21. int name_arr[] = {115200, 38400, 19200, 9600, 4800, 2400, 1200,  300,   
22.                   115200, 38400, 19200, 9600, 4800, 2400, 1200,  300, };  
23. void set_speed(int fd, int speed){  
24.   int   i;   
25.   int   status;   
26.   struct termios   Opt;  
27.   tcgetattr(fd, &Opt);   
28.   for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) {   
29.     if  (speed == name_arr[i]) {       
30.       tcflush(fd, TCIOFLUSH);       
31.       cfsetispeed(&Opt, speed_arr[i]);    
32.       cfsetospeed(&Opt, speed_arr[i]);     
33.       status = tcsetattr(fd, TCSANOW, &Opt);    
34.       if  (status != 0) {          
35.         perror("tcsetattr fd1");    
36.         return;       
37.       }      
38.       tcflush(fd,TCIOFLUSH);     
39.     }    
40.   }  
41. }  
42.   
43. /** 
44. *@brief   设置串口数据位，停止位和效验位 
45. *@param  fd     类型  int  打开的串口文件句柄 
46. *@param  databits 类型  int 数据位   取值 为 7 或者8 
47. *@param  stopbits 类型  int 停止位   取值为 1 或者2 
48. *@param  parity  类型  int  效验类型 取值为N,E,O,,S 
49. */  
50. int set_Parity(int fd,int databits,int stopbits,int parity)  
51. {   
52.     struct termios options;   
53.     if  ( tcgetattr( fd,&options)  !=  0) {   
54.         perror("SetupSerial 1");       
55.         return(FALSE);    
56.     }  
57.     options.c_cflag &= ~CSIZE;   
58.     switch (databits) /*设置数据位数*/  
59.     {     
60.     case 7:       
61.         options.c_cflag |= CS7;   
62.         break;  
63.     case 8:       
64.         options.c_cflag |= CS8;  
65.         break;     
66.     default:      
67.         fprintf(stderr,"Unsupported data size\n"); return (FALSE);    
68.     }  
69.     switch (parity)   
70.     {     
71.         case 'n':  
72.         case 'N':      
73.             options.c_cflag &= ~PARENB;   /* Clear parity enable */  
74.             options.c_iflag &= ~INPCK;     /* Enable parity checking */   
75.             break;    
76.         case 'o':     
77.         case 'O':       
78.             options.c_cflag |= (PARODD | PARENB); /* 设置为奇效验*/    
79.             options.c_iflag |= INPCK;             /* Disnable parity checking */   
80.             break;    
81.         case 'e':    
82.         case 'E':     
83.             options.c_cflag |= PARENB;     /* Enable parity */      
84.             options.c_cflag &= ~PARODD;   /* 转换为偶效验*/       
85.             options.c_iflag |= INPCK;       /* Disnable parity checking */  
86.             break;  
87.         case 'S':   
88.         case 's':  /*as no parity*/     
89.             options.c_cflag &= ~PARENB;  
90.             options.c_cflag &= ~CSTOPB;break;    
91.         default:     
92.             fprintf(stderr,"Unsupported parity\n");      
93.             return (FALSE);    
94.         }    
95.     /* 设置停止位*/    
96.     switch (stopbits)  
97.     {     
98.         case 1:      
99.             options.c_cflag &= ~CSTOPB;    
100.             break;    
101.         case 2:      
102.             options.c_cflag |= CSTOPB;    
103.            break;  
104.         default:      
105.              fprintf(stderr,"Unsupported stop bits\n");    
106.              return (FALSE);   
107.     }   
108.     /* Set input parity option */   
109.     if (parity != 'n')     
110.         options.c_iflag |= INPCK;   
111.     tcflush(fd,TCIFLUSH);  
112.     options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/     
113.     options.c_cc[VMIN] = 0; /* Update the options and do it NOW */  
114.     if (tcsetattr(fd,TCSANOW,&options) != 0)     
115.     {   
116.         perror("SetupSerial 3");     
117.         return (FALSE);    
118.     }   
119.     options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/  
120.     options.c_oflag  &= ~OPOST;   /*Output*/  
121.     return (TRUE);    
122. }  
123.   
124. int main(int argc, char *argv[])  
125. {  
126.   
127.     int    fd, c=0, res;  
128.   
129.     char  buf[256];  
130.   
131.     printf("Start...\n");  
132.     fd = open(UART_DEVICE, O_RDWR);  
133.   
134.     if (fd < 0) {  
135.         perror(UART_DEVICE);  
136.         exit(1);  
137.     }  
138.   
139.     printf("Open...\n");  
140.     set_speed(fd,115200);  
141.     if (set_Parity(fd,8,1,'N') == FALSE)  {  
142.         printf("Set Parity Error\n");  
143.         exit (0);  
144.     }  
145.   
146.     printf("Reading...\n");  
147.     while(1) {  
148.         res = read(fd, buf, 255);  
149.   
150.         if(res==0)  
151.             continue;  
152.         buf[res]=0;  
153.   
154.         printf("%s", buf);  
155.           
156.         if (buf[0] == 0x0d)  
157.             printf("\n");  
158.           
159.         if (buf[0] == '@') break;  
160.     }  
161.   
162.     printf("Close...\n");  
163.     close(fd);  
164.   
165.     return 0;  
166. }  

 

 

Linux 串口读写(一)   

串口简介

串行口是计算机一种常用的接口，具有连接线少，通讯简单，得到广泛的使用。常用的串口是 RS-232-C 接口（又称 EIA RS-232-C）它是在 1970 年由美国电子工业协会（EIA）联合贝尔系统、 调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。它的全名是"数据终端设备（DTE）和数据通讯设备（DCE）之间串行二进制数据交换接口技术标准"该标准规定采用一个 25 个脚的 DB25 连接器，对连接器的每个引脚的信号内容加以规定，还对各种信号的电平加以规定。传输距离在码元畸变小于4% 的情况下，传输电缆长度应为 50 英尺。

Linux 操作系统从一开始就对串行口提供了很好的支持

计算机串口的引脚说明

 

序号	信号名称	符号	流向	功能
2	发送数据	TXD	DTE→DCE	DTE发送串行数据
3	接收数据	RXD	DTE←DCE	DTE 接收串行数据
4	请求发送	RTS	DTE→DCE	DTE 请求 DCE 将线路切换到发送方式
5	允许发送	CTS	DTE←DCE	DCE 告诉 DTE 线路已接通可以发送数据
6	数据设备准备好	DSR	DTE←DCE	DCE 准备好
7	信号地			信号公共地
8	载波检测	DCD	DTE←DCE	表示 DCE 接收到远程载波
20	数据终端准备好	DTR	DTE→DCE	DTE 准备好
22	振铃指示	RI	DTE←DCE	表示 DCE 与线路接通，出现振铃

 

 

串口操作

串口操作需要的头文件

 

#include           /*标准输入输出定义*/ #include          /*标准函数库定义*/ #include          /*Unix 标准函数定义*/ #include       /*数据类型，比如一些XXX_t的那种*/ #include        /*定义了一些返回值的结构，没看明白*/ #include           /*文件控制定义*/ #include         /*PPSIX 终端控制定义*/ #include           /*错误号定义*/

 

 

打开串口

在 Linux 下串口文件是位于 /dev 下的

串口一 为 /dev/ttyS0

串口二 为 /dev/ttyS1

打开串口是通过使用标准的文件打开函数操作：

 

int fd; /*以读写方式打开串口*/ fd = open( "/dev/ttyS0", O_RDWR); if (-1 == fd){ /* 不能打开串口一*/ perror(" 提示错误！"); }

 

 

设置串口

最基本的设置串口包括波特率设置，效验位和停止位设置。

串口的设置主要是设置 struct termios 结构体的各成员值。

 

struct termio {   unsigned short  c_iflag; /* 输入模式标志 */      unsigned short  c_oflag;     /* 输出模式标志 */      unsigned short  c_cflag;     /* 控制模式标志*/       unsigned short  c_lflag;     /* local mode flags */       unsigned char    c_line;           /* line discipline */     unsigned char    c_cc[NCC];    /* control characters */ };

 

 

设置这个结构体很复杂，我这里就只说说常见的一些设置：

波特率设置

下面是修改波特率的代码：

 

struct  termios Opt; tcgetattr(fd, &Opt); /*获得当前设备模式，与终端相关的参数。fd=0标准输入*/ cfsetispeed(&Opt,B19200); /*设置结构termios输入波特率为19200Bps*/ cfsetospeed(&Opt,B19200);   /*fd应该是文件描述的意思*/ tcsetattr(fd,TCANOW,&Opt);/*设置终端参数，TCANOW修改立即发生*/

 

 

设置波特率的例子函数：

 

/** *@brief  设置串口通信速率 *@param  fd     类型 int  打开串口的文件句柄 *@param  speed  类型 int  串口速度 *@return  void */ int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,                   B38400, B19200, B9600, B4800, B2400, B1200, B300, }; int name_arr[] = {38400,  19200,  9600,  4800,  2400,  1200,  300, 38400,                    19200,  9600, 4800, 2400, 1200,  300, }; void set_speed(int fd, int speed){     int   i;     int   status;     struct termios   Opt;     tcgetattr(fd, &Opt);     for ( i= 0;  i < sizeof(speed_arr) / sizeof(int);  i++) {        if  (speed == name_arr[i]) { /**  * tcflush函数刷清(抛弃)输入缓存(终端驱动程序已接收到，但用户程序尚未读)或输出缓存(用户程序已经写，但尚未发送)。queue参数应是下列三个常数之一： * TCIFLUSH刷清输入队列。  * TCOFLUSH刷清输出队列。 * TCIOFLUSH刷清输入、输出队列。  */    tcflush(fd, TCIOFLUSH);//设置前flush        cfsetispeed(&Opt, speed_arr[i]);     cfsetospeed(&Opt, speed_arr[i]);      //通过tcsetattr函数把新的属性设置到串口上。    //tcsetattr(串口描述符，立即使用或者其他标示，指向termios的指针)    status = tcsetattr(fd, TCSANOW, &Opt);     if  (status != 0) {              perror("tcsetattr fd1");         return;         }        tcflush(fd,TCIOFLUSH);  //设置后flush   }  } }

 

 

效验位和停止位的设置：

 

无效验	8位	Option.c_cflag &= ~PARENB;  Option.c_cflag &= ~CSTOPB;  Option.c_cflag &= ~CSIZE;  Option.c_cflag |= ~CS8;
奇效验(Odd)	7位	Option.c_cflag |= ~PARENB;  Option.c_cflag &= ~PARODD;  Option.c_cflag &= ~CSTOPB;  Option.c_cflag &= ~CSIZE;  Option.c_cflag |= ~CS7;
偶效验(Even)	7位	Option.c_cflag &= ~PARENB;  Option.c_cflag |= ~PARODD;  Option.c_cflag &= ~CSTOPB;  Option.c_cflag &= ~CSIZE;  Option.c_cflag |= ~CS7;
Space效验	7位	Option.c_cflag &= ~PARENB;  Option.c_cflag &= ~CSTOPB;  Option.c_cflag &= &~CSIZE;  Option.c_cflag |= CS8;

 

设置效验的函数：

 

/**  *@brief   设置串口数据位，停止位和效验位  *@param  fd     类型  int  打开的串口文件句柄  *@param  databits 类型  int 数据位   取值 为 7 或者8  *@param  stopbits 类型  int 停止位   取值为 1 或者2  *@param  parity  类型  int  效验类型 取值为N,E,O,,S  */ int set_Parity(int fd, int databits, int stopbits, int parity) {     struct termios options;     if (tcgetattr(fd, &options) != 0)     {        perror("SetupSerial 1");        return (FALSE);     }     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 (FALSE);     }     switch (parity)     {     case 'n':     case 'N':        options.c_cflag &= ~PARENB; /* Clear parity enable */        options.c_iflag &= ~INPCK; /* Enable parity checking */        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 (FALSE);     }     /* 设置停止位*/     switch (stopbits)     {     case 1:        options.c_cflag &= ~CSTOPB;        break;     case 2:        options.c_cflag |= CSTOPB;        break;     default:        fprintf(stderr,"Unsupported stop bits\n");        return (FALSE);     }     /* Set input parity option */     if (parity != 'n')        options.c_iflag |= INPCK;     tcflush(fd, TCIFLUSH);     options.c_cc[VTIME] = 150; /* 设置超时15 seconds*/     options.c_cc[VMIN] = 0; /* Update the options and do it NOW */     if (tcsetattr(fd, TCSANOW, &options) != 0)     {        perror("SetupSerial 3");        return (FALSE);     }     return (TRUE); }

 

 

需要注意的是:

如果不是开发终端之类的，只是串口传输数据，而不需要串口来处理，那么使用原始模式(Raw Mode)方式来通讯，设置方式如下：

 

options.c_lflag  &= ~(ICANON | ECHO | ECHOE | ISIG);  /*Input*/ options.c_oflag  &= ~OPOST;   /*Output*/

 

 

读写串口

设置好串口之后，读写串口就很容易了，把串口当作文件读写就是。

• 发送数据

 

char  buffer[1024]; int    Length; int    nByte; nByte = write(fd, buffer ,Length)

 

 

• 读取串口数据

使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。

可以使用操作文件的函数来实现异步读取，如fcntl，或者select等来操作。

 

char  buff[1024]; int    Len; int  readByte = read(fd,buff,Len);

 

 

关闭串口

关闭串口就是关闭文件。

 

close(fd);