Linux下串口通信详解（上）打开串口和串口初始化详解

青旅半醒 2022-09-29 14:56 1207阅读 0赞

[Linux][]下串口通信主要有下面几个步骤

![Linux串口通信流程][Linux 1]

串口通信流程图

下面我会一一介绍这几个步骤。

# 1.打开串口 #

代码（串口为ttyUSB0）

**\[java\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  //打开串口  
2.  int open\_port(void)  
3.  \{  
4.      int fd;  
5.            
6.      fd=open(”/dev/ttyUSB0”,O\_RDWR | O\_NOCTTY | O\_NONBLOCK);//O\_NONBLOCK设置为非阻塞模式，在read时不会阻塞住，在读的时候将read放在while循环中，下一节篇文档将详细讲解阻塞和非阻塞  
7.  //  printf(“fd=%d\\n”,fd);  
8.        
9.      if(fd==-1)  
10.     \{  
11.         perror(”Can’t Open SerialPort”);  
12.     \}  
13.       
14.     return fd;  
15. \}

![save_snippets.png][]

//打开串口
    int open_port(void)
    {
        int fd;
    
        fd=open("/dev/ttyUSB0",O_RDWR | O_NOCTTY | O_NONBLOCK);//O_NONBLOCK设置为非阻塞模式，在read时不会阻塞住，在读的时候将read放在while循环中，下一节篇文档将详细讲解阻塞和非阻塞
    //  printf("fd=%d\n",fd);
    
        if(fd==-1)
        {
            perror("Can't Open SerialPort");
        }
    
        return fd;
    }

打开串口时也可以多加一些内容，比如判断串口为阻塞状态、测试是否为终端设备等，这些是必要的，所以较上面的基本的打开串口的代码，更加完整健壮一些的代码流程如下所示：

![Center][]

打开串口较完整流程图

代码：

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\*\* 
2.   \* open port 
3.   \* @param  fd 
4.   \* @param  comport 想要打开的串口号 
5.   \* @return  返回-1为打开失败 
6.   \*/  
7.  int open\_port(int fd,int comport)   
8.  \{   
9.      char \*dev\[\]=\{ “/dev/ttyUSB0”,“/dev/ttyS1”,“/dev/ttyS2”\};  
10.   
11.     if (comport==1)//串口1   
12.     \{  
13.         fd = open( ”/dev/ttyUSB0”, O\_RDWR|O\_NOCTTY|O\_NDELAY);   
14.         if (-1 == fd)  
15.         \{   
16.             perror(”Can’t Open Serial Port”);   
17.             return(-1);   
18.         \}   
19.      \}   
20.      else if(comport==2)//串口2   
21.      \{       
22.         fd = open( ”/dev/ttyS1”, O\_RDWR|O\_NOCTTY|O\_NDELAY); //没有设置<span style=”font-family: Arial, Helvetica, sans-serif;”>O\_NONBLOCK非阻塞模式，也可以设置为非阻塞模式，两个模式在下一篇博客中具体说明</span>  
23.   
24.         if (-1 == fd)  
25.         \{   
26.             perror(”Can’t Open Serial Port”);   
27.             return(-1);   
28.         \}   
29.      \}   
30.      else if (comport==3)//串口3   
31.      \{   
32.         fd = open( ”/dev/ttyS2”, O\_RDWR|O\_NOCTTY|O\_NDELAY);   
33.         if (-1 == fd)  
34.         \{   
35.             perror(”Can’t Open Serial Port”);   
36.             return(-1);   
37.         \}   
38.      \}   
39.      /\*恢复串口为阻塞状态\*/   
40.      if(fcntl(fd, F\_SETFL, 0)<0)   
41.             printf(”fcntl failed!\\n”);   
42.      else   
43.         printf(”fcntl=%d\\n”,fcntl(fd, F\_SETFL,0));   
44.      /\*测试是否为终端设备\*/   
45.      if(isatty(STDIN\_FILENO)==0)   
46.         printf(”standard input is not a terminal device\\n”);   
47.      else   
48.         printf(”isatty success!\\n”);   
49.      printf(”fd-open=%d\\n”,fd);   
50.      return fd;   
51. \}

![save_snippets.png][]

/**
     * open port
     * @param  fd
     * @param  comport 想要打开的串口号
     * @return  返回-1为打开失败
     */
    int open_port(int fd,int comport) 
    { 
        char *dev[]={"/dev/ttyUSB0","/dev/ttyS1","/dev/ttyS2"};
    
        if (comport==1)//串口1 
        {
            fd = open( "/dev/ttyUSB0", O_RDWR|O_NOCTTY|O_NDELAY); 
            if (-1 == fd)
            { 
                perror("Can't Open Serial Port"); 
                return(-1); 
            } 
         } 
         else if(comport==2)//串口2 
         {     
            fd = open( "/dev/ttyS1", O_RDWR|O_NOCTTY|O_NDELAY); //没有设置<span style="font-family: Arial, Helvetica, sans-serif;">O_NONBLOCK非阻塞模式，也可以设置为非阻塞模式，两个模式在下一篇博客中具体说明</span>
    
            if (-1 == fd)
            { 
                perror("Can't Open Serial Port"); 
                return(-1); 
            } 
         } 
         else if (comport==3)//串口3 
         { 
            fd = open( "/dev/ttyS2", O_RDWR|O_NOCTTY|O_NDELAY); 
            if (-1 == fd)
            { 
                perror("Can't Open Serial Port"); 
                return(-1); 
            } 
         } 
         /*恢复串口为阻塞状态*/ 
         if(fcntl(fd, F_SETFL, 0)<0) 
                printf("fcntl failed!\n"); 
         else 
            printf("fcntl=%d\n",fcntl(fd, F_SETFL,0)); 
         /*测试是否为终端设备*/ 
         if(isatty(STDIN_FILENO)==0) 
            printf("standard input is not a terminal device\n"); 
         else 
            printf("isatty success!\n"); 
         printf("fd-open=%d\n",fd); 
         return fd; 
    }

关键函数解释：

**open**

功能描述：用于打开或创建文件，成功则返回文件描述符，否则返回-1，open返回的文件描述符一定是最小的未被使用的描述符

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<fcntl.h>  
2.  int open(const char \*pathname, int oflag, … );

![save_snippets.png][]

#include<fcntl.h>
    int open(const char *pathname, int oflag, ... );

参数解释：

pathname：文件路径名，串口在Linux中被看做是一个文件

oflag：一些文件模式选择，有如下几个参数可以设置

*  O\_RDONLY只读模式  
    
 *  O\_WRONLY只写模式
 *  O\_RDWR读写模式

**上面三个参数在设置的时候必须选择其中一个！！！**下面的是可选的

*  O\_APPEND每次写操作都写入文件的末尾
 *  O\_CREAT如果指定文件不存在，则创建这个文件
 *  O\_EXCL如果要创建的文件已存在，则返回 -1，并且修改 errno 的值
 *  O\_TRUNC如果文件存在，并且以只写/读写方式打开，则清空文件全部内容
 *  O\_NOCTTY如果路径名指向终端设备，不要把这个设备用作控制终端。
 *  O\_NONBLOCK如果路径名指向 FIFO/块文件/字符文件，则把文件的打开和后继 I/O设置为非阻塞模式（nonblocking mode）

下面三个常量同样是选用的，他们用于同步输入输出

*  O\_DSYNC等待物理 I/O 结束后再 write。在不影响读取新写入的数据的前提下，不等待文件属性更新。
 *  O\_RSYNC读(read)等待所有写入同一区域的写操作完成后再进行
 *  O\_SYNC等待物理 I/O 结束后再 write，包括更新文件属性的 I/O

对于串口的打开操作，必须使用O\_NOCTTY参数，它表示打开的是一个终端设备，程序不会成为该端口的控制终端。如果不使用此标志，任务的一个输入(比如键盘终止信号等)都会影响进程。

O\_NDELAY表示不关心DCD信号所处的状态（端口的另一端是否激活或者停止）。

**fcntl**

功能描述：根据文件描述词来操作文件的特性，返回-1代表出错

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<unistd.h>  
2.  \#include<fcntl.h>  
3.  int fcntl(int fd,int cmd);  
4.  int fcntl(int fd,int cmd,long arg);  
5.  int fcntl(int fd,int cmd,struct flock \*lock);

![save_snippets.png][]

#include<unistd.h>

\#include<fcntl.h> int fcntl(int fd,int cmd); int fcntl(int fd,int cmd,long arg); int fcntl(int fd,int cmd,struct flock \*lock);参数说明：

*  fd：文件描述符
 *  cmd：命令参数

fcntl函数有5种功能：   
1. 复制一个现有的描述符(cmd=F\_DUPFD).   
2. 获得／设置文件描述符标记(cmd=F\_GETFD或F\_SETFD).   
3. 获得／设置文件状态标记(cmd=F\_GETFL或F\_SETFL).   
4. 获得／设置异步I/O所有权(cmd=F\_GETOWN或F\_SETOWN).   
5. 获得／设置记录锁(cmd=F\_GETLK , F\_SETLK或F\_SETLKW).

具体使用见 [http://www.cnblogs.com/lonelycatcher/archive/2011/12/22/2297349.html][http_www.cnblogs.com_lonelycatcher_archive_2011_12_22_2297349.html]

**isatty**

函数功能，实现只使用了一个终端专用的函数tcgetattr(如果成功之星，它不改变任何东西)，并取其返回值。若为终端设备返回1，否则返回0。详情见 [http://blog.csdn.net/wangjingyu00711/article/details/41693155][http_blog.csdn.net_wangjingyu00711_article_details_41693155]

# 2.串口的初始化 #

串口初始化工作需要做以下工作：

1.  设置波特率
2.  设置数据流控制
3.  设置帧的格式(即数据位个数，停止位，校验位)

![串口初始化][Center 1]

串口初始化

代码：

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  int set\_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop)   
2.  \{   
3.       struct termios newtio,oldtio;   
4.  /\*保存测试现有串口参数设置，在这里如果串口号等出错，会有相关的出错信息\*/   
5.       if  ( tcgetattr( fd,&oldtio)  !=  0) \{    
6.        perror(”SetupSerial 1”);  
7.      printf(”tcgetattr( fd,&oldtio) -> %d\\n”,tcgetattr( fd,&oldtio));   
8.        return -1;   
9.       \}   
10.      bzero( &newtio, sizeof( newtio ) );   
11. /\*步骤一，设置字符大小\*/   
12.      newtio.c\_cflag  |=  CLOCAL | CREAD;    
13.      newtio.c\_cflag &= ~CSIZE;    
14. /\*设置停止位\*/   
15.      switch( nBits )   
16.      \{   
17.      case 7:   
18.       newtio.c\_cflag |= CS7;   
19.       break;   
20.      case 8:   
21.       newtio.c\_cflag |= CS8;   
22.       break;   
23.      \}   
24. /\*设置奇偶校验位\*/   
25.      switch( nEvent )   
26.      \{   
27.      case ‘o’:  
28.      case ‘O’: //奇数   
29.       newtio.c\_cflag |= PARENB;   
30.       newtio.c\_cflag |= PARODD;   
31.       newtio.c\_iflag |= (INPCK | ISTRIP);   
32.       break;   
33.      case ‘e’:  
34.      case ‘E’: //偶数   
35.       newtio.c\_iflag |= (INPCK | ISTRIP);   
36.       newtio.c\_cflag |= PARENB;   
37.       newtio.c\_cflag &= ~PARODD;   
38.       break;  
39.      case ‘n’:  
40.      case ‘N’:  //无奇偶校验位   
41.       newtio.c\_cflag &= ~PARENB;   
42.       break;  
43.      default:  
44.       break;  
45.      \}   
46.      /\*设置波特率\*/   
47. switch( nSpeed )   
48.      \{   
49.      case 2400:   
50.       cfsetispeed(&newtio, B2400);   
51.       cfsetospeed(&newtio, B2400);   
52.       break;   
53.      case 4800:   
54.       cfsetispeed(&newtio, B4800);   
55.       cfsetospeed(&newtio, B4800);   
56.       break;   
57.      case 9600:   
58.       cfsetispeed(&newtio, B9600);   
59.       cfsetospeed(&newtio, B9600);   
60.       break;   
61.      case 115200:   
62.       cfsetispeed(&newtio, B115200);   
63.       cfsetospeed(&newtio, B115200);   
64.       break;   
65.      case 460800:   
66.       cfsetispeed(&newtio, B460800);   
67.       cfsetospeed(&newtio, B460800);   
68.       break;   
69.      default:   
70.       cfsetispeed(&newtio, B9600);   
71.       cfsetospeed(&newtio, B9600);   
72.      break;   
73.      \}   
74. /\*设置停止位\*/   
75.      if( nStop == 1 )   
76.       newtio.c\_cflag &=  ~CSTOPB;   
77.      else if ( nStop == 2 )   
78.       newtio.c\_cflag |=  CSTOPB;   
79. /\*设置等待时间和最小接收字符\*/   
80.      newtio.c\_cc\[VTIME\]  = 0;   
81.      newtio.c\_cc\[VMIN\] = 0;   
82. /\*处理未接收字符\*/   
83.      tcflush(fd,TCIFLUSH);   
84. /\*激活新配置\*/   
85. if((tcsetattr(fd,TCSANOW,&newtio))!=0)   
86.      \{   
87.       perror(”com set error”);   
88.       return -1;   
89.      \}   
90.      printf(”set done!\\n”);   
91.      return 0;   
92. \}

![save_snippets.png][]

int set_opt(int fd,int nSpeed, int nBits, char nEvent, int nStop) 
    { 
         struct termios newtio,oldtio; 
    /*保存测试现有串口参数设置，在这里如果串口号等出错，会有相关的出错信息*/ 
         if  ( tcgetattr( fd,&oldtio)  !=  0) {  
          perror("SetupSerial 1");
        printf("tcgetattr( fd,&oldtio) -> %d\n",tcgetattr( fd,&oldtio)); 
          return -1; 
         } 
         bzero( &newtio, sizeof( newtio ) ); 
    /*步骤一，设置字符大小*/ 
         newtio.c_cflag  |=  CLOCAL | CREAD;  
         newtio.c_cflag &= ~CSIZE;  
    /*设置停止位*/ 
         switch( nBits ) 
         { 
         case 7: 
          newtio.c_cflag |= CS7; 
          break; 
         case 8: 
          newtio.c_cflag |= CS8; 
          break; 
         } 
    /*设置奇偶校验位*/ 
         switch( nEvent ) 
         { 
         case 'o':
         case 'O': //奇数 
          newtio.c_cflag |= PARENB; 
          newtio.c_cflag |= PARODD; 
          newtio.c_iflag |= (INPCK | ISTRIP); 
          break; 
         case 'e':
         case 'E': //偶数 
          newtio.c_iflag |= (INPCK | ISTRIP); 
          newtio.c_cflag |= PARENB; 
          newtio.c_cflag &= ~PARODD; 
          break;
         case 'n':
         case 'N':  //无奇偶校验位 
          newtio.c_cflag &= ~PARENB; 
          break;
         default:
          break;
         } 
         /*设置波特率*/ 
    switch( nSpeed ) 
         { 
         case 2400: 
          cfsetispeed(&newtio, B2400); 
          cfsetospeed(&newtio, B2400); 
          break; 
         case 4800: 
          cfsetispeed(&newtio, B4800); 
          cfsetospeed(&newtio, B4800); 
          break; 
         case 9600: 
          cfsetispeed(&newtio, B9600); 
          cfsetospeed(&newtio, B9600); 
          break; 
         case 115200: 
          cfsetispeed(&newtio, B115200); 
          cfsetospeed(&newtio, B115200); 
          break; 
         case 460800: 
          cfsetispeed(&newtio, B460800); 
          cfsetospeed(&newtio, B460800); 
          break; 
         default: 
          cfsetispeed(&newtio, B9600); 
          cfsetospeed(&newtio, B9600); 
         break; 
         } 
    /*设置停止位*/ 
         if( nStop == 1 ) 
          newtio.c_cflag &=  ~CSTOPB; 
         else if ( nStop == 2 ) 
          newtio.c_cflag |=  CSTOPB; 
    /*设置等待时间和最小接收字符*/ 
         newtio.c_cc[VTIME]  = 0; 
         newtio.c_cc[VMIN] = 0; 
    /*处理未接收字符*/ 
         tcflush(fd,TCIFLUSH); 
    /*激活新配置*/ 
    if((tcsetattr(fd,TCSANOW,&newtio))!=0) 
         { 
          perror("com set error"); 
          return -1; 
         } 
         printf("set done!\n"); 
         return 0; 
    }

讲解这片代码之前，我们要先研究一下termios的数据结构。最小的termios结构的典型定义如下：

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  struct termios  
2.  \{  
3.             tcflag\_t c\_iflag;  
4.             tcflag\_t c\_oflag;  
5.             tcflag\_t c\_cflag;  
6.             tcflag\_t c\_lflag;  
7.             cc\_t           c\_cc\[NCCS\];  
8.  \};

![save_snippets.png][]

struct termios
    {
               tcflag_t c_iflag;
               tcflag_t c_oflag;
               tcflag_t c_cflag;
               tcflag_t c_lflag;
               cc_t           c_cc[NCCS];
    };

上面五个结构成员名称分别代表：

*  c\_iflag：输入模式
 *  c\_oflag：输出模式
 *  c\_cflag：控制模式
 *  c\_lflag：本地模式
 *  c\_cc\[NCCS\]：特殊控制模式

五种模式的参数说明见博客 [http://blog.csdn.net/querdaizhi/article/details/7436722][http_blog.csdn.net_querdaizhi_article_details_7436722]  
**tcgetattr**可以初始化一个终端对应的termios结构，tcgetattr函数原型如下：

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<termios.h>    
2.  int tcgetattr(int fd, struct termios \*termios\_p);

![save_snippets.png][]

#include<termios.h>  
    int tcgetattr(int fd, struct termios *termios_p);

这个函数调用把低昂前终端接口变量的值写入termios\_p参数指向的结构。如果这些值其后被修改了，可以通过调用函数tcsetattr来重新配置。

**tcsetattr**函数原型如下：

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  \#include<termios.h>    
2.  int tcsetattr(int fd , int actions , const struct termios \*termios\_h);

![save_snippets.png][]

#include<termios.h>  
    int tcsetattr(int fd , int actions , const struct termios *termios_h);

参数actions控制修改方式，共有三种修改方式，如下所示：

1.  TCSANOW：立刻对值进行修改
2.  TCSADRAIN：等当前的输出完成后再对值进行修改
3.  TCSAFLUSH：等当前的输出完成之后，再对值进行修改，但丢弃还未从read调用返回的当前的可用的任何输入。

在我们的代码中，我们设置为NOW立即对值进行修改。

**tcflush**用于清空中端为完成的输入/输出请求及数据，它的函数原型如下：

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  int tcflush(int fd, int queue\_selector);

![save_snippets.png][]

int tcflush(int fd, int queue_selector);

其中queue\_selector时控制tcflush的操作，取值可以为如下参数中的一个：TCIFLUSH清楚正收到的数据，且不会读出来；TCOFLUSH清楚正写入的数据，且不会发送至终端；TCIOFLUSH清除所有正在发送的I/O数据。

再看我们的代码，我们修改字符大小的代码为

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  newtio.c\_cflag  |=  CLOCAL | CREAD;    
2.  newtio.c\_cflag &= ~CSIZE;

![save_snippets.png][]

newtio.c_cflag  |=  CLOCAL | CREAD;  
    newtio.c_cflag &= ~CSIZE;

c\_cflag代表控制模式

*  CLOCAL含义为忽略所有调制解调器的状态行，这个目的是为了保证程序不会占用串口。
 *  CREAD代表启用字符接收器，目的是是的能够从串口中读取输入的数据。
 *  CS5/6/7/8表示发送或接收字符时使用5/6/7/8比特。
 *  CSTOPB表示每个字符使用两位停止位。
 *  HUPCL表示关闭时挂断调制解调器。
 *  PARENB：启用奇偶校验码的生成和检测功能。
 *  PARODD：只使用奇校验而不使用偶校验。

c\_iflag代表输入模式

*  BRKINT：当在输入行中检测到一个终止状态时，产生一个中断。
 *  TGNBRK：忽略输入行中的终止状态。
 *  TCRNL：将接受到的回车符转换为新行符。
 *  TGNCR：忽略接受到的新行符。
 *  INLCR：将接受到的新行符转换为回车符。
 *  IGNPAR：忽略奇偶校检错误的字符。
 *  **INPCK：对接收到的字符执行奇偶校检。**
 *  PARMRK：对奇偶校检错误作出标记。
 *  **ISTRIP：将所有接收的字符裁减为7比特。**
 *  IXOFF：对输入启用软件流控。
 *  IXON：对输出启用软件流控。

c\_cc特殊的控制字符

标准模式和非标准模式下,c\_cc数组的下标有不同的值:

标准模式：

*  VEOF:EOF字符
 *  VEOL:EOF字符
 *  VERASE:ERASE字符
 *  VINTR:INTR字符
 *  VKILL:KILL字符
 *  VQUIT:QUIT字符
 *  VSTART:START字符 
 *  VSTOP:STOP字符

非标准模式:

*  VINTR:INTR字符
 *  VMIN:MIN值
 *  VQUIT:QUIT字符
 *  VSUSP:SUSP字符
 *  VTIME:TIME值
 *  VSTART:START字符 
 *  VSTOP:STOP字符

**cfsetispeed和** **cfsetospeed**用来设置输入输出的波特率，函数模型如下：

**\[cpp\]** view plain copy

print ? [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  int cfsetispeed(struct termios \*termptr, speed\_t speed);  
2.  int cfsetospeed(struct termios \*termptr, speed\_t speed);

![save_snippets.png][]

int cfsetispeed(struct termios *termptr, speed_t speed);
    int cfsetospeed(struct termios *termptr, speed_t speed);

参数说明：

*  struct termios \*termptr：指向termios结构的指针
 *  speed\_t speed：需要设置的波特率
 *  返回值：成功返回0，否则返回-1

这样，所有的初始化操作我们就完成了。

下一篇文章我会记录串口的读写及关闭操作的详细步骤。并且会把源代码链接给出供大家参考！

[Linux]: http://lib.csdn.net/base/linux
[Linux 1]: /images/20220708/fcf1b82af322406ea49453a3124697c6.png
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/1583977
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/1583977/fork
[save_snippets.png]: /images/20220708/6a69af73142d4cd49aef2a65c782a427.png
[Center]: /images/20220708/b08541f14138406d8e3af3c9580ddb90.png
[http_www.cnblogs.com_lonelycatcher_archive_2011_12_22_2297349.html]: http://www.cnblogs.com/lonelycatcher/archive/2011/12/22/2297349.html
[http_blog.csdn.net_wangjingyu00711_article_details_41693155]: http://blog.csdn.net/wangjingyu00711/article/details/41693155
[Center 1]: /images/20220708/71ffa303b55c484a8dbb397e23a8a1d0.png
[http_blog.csdn.net_querdaizhi_article_details_7436722]: http://blog.csdn.net/querdaizhi/article/details/7436722