Chinaunix首页 | 论坛 | 博客

帮我Q下的ChinaUnix博客

首页　| 　博文目录　| 　关于我

帮我Q下

  • 博客访问： 1743353
  • 博文数量： 143
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1462
  • 用 户 组： 普通用户
  • 注册时间： 2016-08-23 11:14
文章分类

全部博文（143）

文章存档

2022年（3）

2021年（13）

2020年（21）

2019年（8）

2018年（28）

2017年（7）

2016年（63）

我的朋友
最近访客
推荐博文
相关博文
uart 应用程序

分类： 嵌入式

2016-09-22 19:19:14

背景介绍：因项目需要在ICETEK OMAPL138开发板上实现：能通过uart脚本控制ICETEK OMAPL138的spi1口，来读写AD/DA器件的寄存器，类似于华为的qshell。很明显，首先需要在ICETEK OMAPL138上实现：接受串口字符串，以及解析字符串，发送字符串到串口等等功能的uart应用程序。
  而通常情况下，开发板自带的光盘中会有uart收发应用程序的例程，ICETEK OMAPL138开发板的uart收发应用程序路径：/usr/local/Omapl138kba/projects/examples/app/comtest/。但是，此例程和网上绝大部分例子一样代码看着不够清晰，所以本文想先从最最最简单的uart收发应用程序开始，介绍一下uart收发应用程序的实现步骤，再把网上常出现的优化后的代码也贴上来以供参考。
  参考代码选自作者bg2bkk的两篇文章：Linux串口编程 和 Linux系统串口接收数据编程 。
1. 最简单的uart收发程序

点击(此处)折叠或打开

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<fcntl.h>
  4. #include<unistd.h>
  5. #include<errno.h>
  6. #include<termios.h>
  7. #include<sys/types.h>
  8. #include<sys/stat.h>
  9. int main()
  10. {
  11.     printf("COM1 test program\n");
  12.     int fd;
  13.     fd = open("/dev/ttyS2",O_RDWR | O_NDELAY);
  14.     if(fd == -1)
  15.     {
  16.         perror("serialport error\n");
  17.     }
  18.     else{
  19.         printf("open %s succesfully\n", ttyname(fd));
  20.     }

  22.     struct termios Opt;
  23.     int status;
  24.     
  25.     tcgetattr(fd, &Opt);
  26.     //set speed
  27.     cfsetispeed(&Opt, B115200);
  28.     cfsetospeed(&Opt, B115200);
  29.     //set databits
  30.     Opt.c_cflag &= ~CSIZE;
  31.     Opt.c_cflag |= CS8;
  32.     //set parity
  33.     Opt.c_cflag &= ~PARENB;
  34.     Opt.c_iflag &= ~INPCK;
  35.     //set stopbits
  36.     Opt.c_cflag &= ~CSTOPB;
  37.     tcsetattr(fd, TCSANOW, &Opt);
  38.     status = tcsetattr(fd, TCSANOW, &Opt);
  39.     if(status != 0)
  40.     {
  41.         perror("tcsetattr fd1");
  42.         return;
  43.     }

  45.     //write
  46.     char wrbuff[] = {'h', 'e', 'l', 'l', 'o', '5', 'a', '\n', 'a', 'a', '5', '5', '\0', 'w', 'o', 'r', 'l', 'd', '!'};
  47.     write(fd, wrbuff, sizeof(wrbuff));//the intervening '\0' will not be printed to UART.

  49.     //read
  50.     char rdbuff[512];
  51.     int rdlen;
  52.     while(1)
  53.     {
  54.         if((rdlen = read(fd, rdbuff, sizeof(rdbuff)))>0)//'\n' will also be received as 0x0a.
  55.         {
  56.             rdbuff[rdlen] = '\0';
  57.             printf("receive len:%d receice data:%s", rdlen, rdbuff);
  58.         }
  59.     }

  61.     close(fd);
  62.     return 0;
  63. }
  很明显，要对串口进行收发要经过以下几个步骤：
1.1 打开串口
  在Linux下，与其他的关于设备编程的方法一样，串口编程也是通过操作其设备文件进行的。串口的设备文件是/dev/ttyS0或/dev/ttyS1等。因此要读写串口，我们首先要打开串口。
  需要注意的是，open设备文件时的参数：
O_RDWR：读写打开
O_NOCTTY：如果pathname指的是终端设备(tty)，则不将此设备分配作为此进程的控制终端
O_NONELAY：如果pathname指的是一个FIFO、一个块特殊文件或一个字符特殊文件，则此选择项为此文件的本次打开操作和后续的I/O操作设置为非阻塞方式
  其中，O_NONELAY一定要使用，否则串口因一直被shell占用而不能被此应用程序使用。
1.2 使用tcgetattr函数与tcsetattr函数控制终端
  为了便于通过程序来获得和修改终端参数，Linux还提供了tcgetattr函数和tcsetattr函数。tcgetattr用于获取终端的相关参数，而tcsetattr函数用于设置终端参数。
1.3 设置串口通信参数
  串口通信参数指的是波特率、数据位、奇偶校验位和停止位，这些参数保存在结构体termios中。
1.3.1 设置波特率
  先用tcgetattr获得termios中的相关参数，再用cfsetispeed和cfsetospeed设置termios中存储的输入/输出波特率，最后用tcsetattr将termios中的参数重新设置下去。一般情况下，输入和输出波特率是相等的。
1.3.2 设置数据位、奇偶校验位和停止位
  先用tcgetattr获得termios中的相关参数，再通过修改termios中c_cflag成员来实现设置数据位、奇偶校验位和停止位，最后用tcsetattr将termios中的参数重新设置下去。
1.4 串口收发
  通过以上设置了串口的基本信息后，就可以用read和write读写串口数据，实现串口的收发功能。
2. 常见常用的uart收发程序
  然而，我们常见的且也经常用的串口收发程序，是对设置串口通信参数做了函数封装，然后再循环调用read和write读写串口数据。
  另外，如果我们把这种循环read的方式称为循环读取数据，但这种方式会一直占用当前串口而不能在后台运行，所以我们另外再介绍两种方式：通过signal机制读取数据、通过select系统调用进行io多路切换实现异步读取串口数据，此两种方式都能用来后台读取数据，值得学习。后两种方式博主并未亲自验证，有兴趣的同学可以试试。
2.1 循环读取数据

点击(此处)折叠或打开

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<unistd.h>
  4. #include<sys/types.h>
  5. #include<sys/stat.h>
  6. #include<fcntl.h>
  7. #include<termios.h>
  8. #include<errno.h>

  10. #define FALSE -1
  11. #define TRUE 0

  13. int speed_arr[] = { B38400, B19200, B9600, B4800, B2400, B1200, B300,B38400, B19200, B9600, B4800, B2400, B1200, B300, };
  14. int name_arr[] = {38400, 19200, 9600, 4800, 2400, 1200, 300, 38400, 19200, 9600, 4800, 2400, 1200, 300, };
  15. void set_speed(int fd, int speed){
  16.   int i;
  17.   int status;
  18.   struct termios Opt;
  19.   tcgetattr(fd, &Opt);
  20.   for ( i= 0; i < sizeof(speed_arr) / sizeof(int); i++) {
  21.     if (speed == name_arr[i]) {
  22.       tcflush(fd, TCIOFLUSH);
  23.       cfsetispeed(&Opt, speed_arr[i]);
  24.       cfsetospeed(&Opt, speed_arr[i]);
  25.       status = tcsetattr(fd, TCSANOW, &Opt);
  26.       if (status != 0) {
  27.         perror("tcsetattr fd1");
  28.         return;
  29.       }
  30.       tcflush(fd,TCIOFLUSH);
  31.     }
  32.   }
  33. }

  35. int set_Parity(int fd,int databits,int stopbits,int parity)
  36. {
  37.     struct termios options;
  38.     if ( tcgetattr( fd,&options) != 0) {
  39.         perror("SetupSerial 1");
  40.         return(FALSE);
  41.     }
  42.     options.c_cflag &= ~CSIZE;
  43.     switch (databits)
  44.     {
  45.     case 7:        
  46.         options.c_cflag |= CS7;
  47.         break;
  48.     case 8:
  49.         options.c_cflag |= CS8;
  50.         break;
  51.     default:
  52.         fprintf(stderr,"Unsupported data size\n"); return (FALSE);
  53.     }
  54.     switch (parity)
  55.     {
  56.         case 'n':
  57.         case 'N':
  58.             options.c_cflag &= ~PARENB; /* Clear parity enable */
  59.             options.c_iflag &= ~INPCK; /* Enable parity checking */
  60.             break;
  61.         case 'o':
  62.         case 'O':
  63.             options.c_cflag |= (PARODD | PARENB);
  64.             options.c_iflag |= INPCK; /* Disnable parity checking */
  65.             break;
  66.         case 'e':
  67.         case 'E':
  68.             options.c_cflag |= PARENB; /* Enable parity */
  69.             options.c_cflag &= ~PARODD;
  70.             options.c_iflag |= INPCK; /* Disnable parity checking */
  71.             break;
  72.         case 'S':
  73.         case 's': /*as no parity*/
  74.          options.c_cflag &= ~PARENB;
  75.             options.c_cflag &= ~CSTOPB;break;
  76.         default:
  77.             fprintf(stderr,"Unsupported parity\n");
  78.             return (FALSE);
  79.         }
  80.     
  81.     switch (stopbits)
  82.     {
  83.         case 1:
  84.             options.c_cflag &= ~CSTOPB;
  85.             break;
  86.         case 2:
  87.             options.c_cflag |= CSTOPB;
  88.          break;
  89.         default:
  90.              fprintf(stderr,"Unsupported stop bits\n");
  91.              return (FALSE);
  92.     }
  93.     /* Set input parity option */
  94.     if (parity != 'n')
  95.         options.c_iflag |= INPCK;
  96.     tcflush(fd,TCIFLUSH);
  97.     options.c_cc[VTIME] = 150;
  98.     options.c_cc[VMIN] = 0; /* Update the options and do it NOW */
  99.     if (tcsetattr(fd,TCSANOW,&options) != 0)
  100.     {
  101.         perror("SetupSerial 3");
  102.         return (FALSE);
  103.     }
  104.     return (TRUE);
  105. }

  107. int main()
  108. {
  109.     printf("This program updates last time at %s %s\n",__TIME__,__DATE__);
  110.     printf("STDIO COM1\n");
  111.     int fd;
  112.     fd = open("/dev/ttyS0",O_RDWR | O_NDELAY);
  113.     if(fd == -1)
  114.     {
  115.         perror("serialport error\n");
  116.     }
  117.     else
  118.     {
  119.         printf("open ");
  120.         printf("%s",ttyname(fd));
  121.         printf(" succesfully\n");
  122.     }

  124.     set_speed(fd,115200);
  125.     if (set_Parity(fd,8,1,'N') == FALSE) {
  126.         printf("Set Parity Error\n");
  127.         exit (0);
  128.     }

  130.     //write
  131.     char wrbuff[] = {'h', 'e', 'l', 'l', 'o', '5', 'a', '\n', 'a', 'a', '5', '5', '\0', 'w', 'o', 'r', 'l', 'd', '!'};
  132.     write(fd, wrbuff, sizeof(wrbuff));//the intervening '\0' will not be printed to UART.

  134.     //read
  135.     char rdbuff[512];
  136.     int rdlen;
  137.     while(1)
  138.     {
  139.         if((rdlen = read(fd, rdbuff, sizeof(rdbuff)))>0)//'\n' will also be received as 0x0a.
  140.         {
  141.             rdbuff[rdlen] = '\0';
  142.             printf("receive len:%d receice data:%s", rdlen, rdbuff);
  143.         }
  144.     }
  145.     
  146.     close(fd);
  147.     return 0;
  148. }
2.2 通过signal机制读取数据---未验证
  此方式是在用户层通过用信号signal机制模拟软中断，来读取串口数据。

点击(此处)折叠或打开

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<unistd.h>
  4. #include<sys/types.h>
  5. #include<sys/stat.h>
  6. #include<sys/signal.h>
  7. #include<fcntl.h>
  8. #include<termios.h>
  9. #include<errno.h>

  11. #define FALSE -1
  12. #define TRUE 0
  13. #define flag 1
  14. #define noflag 0

  16. int wait_flag = noflag;
  17. int STOP = 0;
  18. int res;

  20. int speed_arr[] =
  21.   { B38400, B19200, B9600, B4800, B2400, B1200, B300, B38400, B19200, B9600,
  22. B4800, B2400, B1200, B300, };
  23. int name_arr[] =
  24.   { 38400, 19200, 9600, 4800, 2400, 1200, 300, 38400, 19200, 9600, 4800, 2400,
  25. 1200, 300, };
  26. void
  27. set_speed (int fd, int speed)
  28. {
  29.   int i;
  30.   int status;
  31.   struct termios Opt;
  32.   tcgetattr (fd, &Opt);
  33.   for (i = 0; i < sizeof (speed_arr) / sizeof (int); i++)
  34.     {
  35.       if (speed == name_arr[i])
  36.     {
  37.      tcflush (fd, TCIOFLUSH);
  38.      cfsetispeed (&Opt, speed_arr[i]);
  39.      cfsetospeed (&Opt, speed_arr[i]);
  40.      status = tcsetattr (fd, TCSANOW, &Opt);
  41.      if (status != 0)
  42.      {
  43.      perror ("tcsetattr fd1");
  44.      return;
  45.      }
  46.      tcflush (fd, TCIOFLUSH);
  47.     }
  48.     }
  49. }

  51. int
  52. set_Parity (int fd, int databits, int stopbits, int parity)
  53. {
  54.   struct termios options;
  55.   if (tcgetattr (fd, &options) != 0)
  56.     {
  57.       perror ("SetupSerial 1");
  58.       return (FALSE);
  59.     }
  60.   options.c_cflag &= ~CSIZE;
  61.   switch (databits)
  62.     {
  63.     case 7:
  64.       options.c_cflag |= CS7;
  65.       break;
  66.     case 8:
  67.       options.c_cflag |= CS8;
  68.       break;
  69.     default:
  70.       fprintf (stderr, "Unsupported data size\n");
  71.       return (FALSE);
  72.     }
  73.   switch (parity)
  74.     {
  75.     case 'n':
  76.     case 'N':
  77.       options.c_cflag &= ~PARENB;    /* Clear parity enable */
  78.       options.c_iflag &= ~INPCK;    /* Enable parity checking */
  79.       break;
  80.     case 'o':
  81.     case 'O':
  82.       options.c_cflag |= (PARODD | PARENB);
  83.       options.c_iflag |= INPCK;    /* Disnable parity checking */
  84.       break;
  85.     case 'e':
  86.     case 'E':
  87.       options.c_cflag |= PARENB;    /* Enable parity */
  88.       options.c_cflag &= ~PARODD;
  89.       options.c_iflag |= INPCK;    /* Disnable parity checking */
  90.       break;
  91.     case 'S':
  92.     case 's':            /*as no parity */
  93.       options.c_cflag &= ~PARENB;
  94.       options.c_cflag &= ~CSTOPB;
  95.       break;
  96.     default:
  97.       fprintf (stderr, "Unsupported parity\n");
  98.       return (FALSE);
  99.     }

  101.   switch (stopbits)
  102.     {
  103.     case 1:
  104.       options.c_cflag &= ~CSTOPB;
  105.       break;
  106.     case 2:
  107.       options.c_cflag |= CSTOPB;
  108.       break;
  109.     default:
  110.       fprintf (stderr, "Unsupported stop bits\n");
  111.       return (FALSE);
  112.     }
  113.   /* Set input parity option */
  114.   if (parity != 'n')
  115.     options.c_iflag |= INPCK;
  116.   tcflush (fd, TCIFLUSH);
  117.   options.c_cc[VTIME] = 150;
  118.   options.c_cc[VMIN] = 0;    /* Update the options and do it NOW */
  119.   if (tcsetattr (fd, TCSANOW, &options) != 0)
  120.     {
  121.       perror ("SetupSerial 3");
  122.       return (FALSE);
  123.     }
  124.   return (TRUE);
  125. }

  127. void
  128. signal_handler_IO (int status)
  129. {
  130.   printf ("received SIGIO signale.\n");
  131.   wait_flag = noflag;
  132. }

  134. int
  135. main ()
  136. {
  137.   printf ("This program updates last time at %s %s\n", __TIME__, __DATE__);
  138.   printf ("STDIO COM1\n");
  139.   int fd;
  140.   struct sigaction saio;
  141.   fd = open ("/dev/ttyUSB0", O_RDWR);
  142.   if (fd == -1)
  143.     {
  144.       perror ("serialport error\n");
  145.     }
  146.   else
  147.     {
  148.       printf ("open ");
  149.       printf ("%s", ttyname (fd));
  150.       printf (" succesfully\n");
  151.     }

  153.   saio.sa_handler = signal_handler_IO;
  154.   sigemptyset (&saio.sa_mask);
  155.   saio.sa_flags = 0;
  156.   saio.sa_restorer = NULL;
  157.   sigaction (SIGIO, &saio, NULL);

  159.   //allow the process to receive SIGIO
  160.   fcntl (fd, F_SETOWN, getpid ());
  161.   //make the file descriptor asynchronous
  162.   fcntl (fd, F_SETFL, FASYNC);

  164.   set_speed (fd, 115200);
  165.   if (set_Parity (fd, 8, 1, 'N') == FALSE)
  166.     {
  167.       printf ("Set Parity Error\n");
  168.       exit (0);
  169.     }

  171.   char buf[255];
  172. while (STOP == 0)
  173.     {
  174.       usleep (100000);
  175.       /* after receving SIGIO ,wait_flag = FALSE,input is availabe and can be read */
  176.       if (wait_flag == 0)
  177.     {
  178.      memset (buf, 0, sizeof(buf));
  179.      res = read (fd, buf, 255);
  180.      printf ("nread=%d,%s\n", res, buf);
  181. //     if (res ==1)
  182. //     STOP = 1;        /*stop loop if only a CR was input */
  183.      wait_flag = flag;    /*wait for new input */
  184.     }
  185.     }


  188.   close (fd);
  189.   return 0;
  190. }
2.3 通过select系统调用进行io多路切换实现异步读取串口数据---未验证
  此方式是通过select系统调用，在没有数据时阻塞进程，串口有数据需要读时唤醒进程。

点击(此处)折叠或打开

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<unistd.h>
  4. #include<sys/types.h>
  5. #include<sys/stat.h>
  6. #include<sys/signal.h>
  7. #include<fcntl.h>
  8. #include<termios.h>
  9. #include<errno.h>

  11. #define FALSE -1
  12. #define TRUE 0
  13. #define flag 1
  14. #define noflag 0

  16. int wait_flag = noflag;
  17. int STOP = 0;
  18. int res;

  20. int speed_arr[] =
  21.   { B38400, B19200, B9600, B4800, B2400, B1200, B300, B38400, B19200, B9600,
  22. B4800, B2400, B1200, B300, };
  23. int name_arr[] =
  24.   { 38400, 19200, 9600, 4800, 2400, 1200, 300, 38400, 19200, 9600, 4800, 2400,
  25. 1200, 300, };
  26. void
  27. set_speed (int fd, int speed)
  28. {
  29.   int i;
  30.   int status;
  31.   struct termios Opt;
  32.   tcgetattr (fd, &Opt);
  33.   for (i = 0; i < sizeof (speed_arr) / sizeof (int); i++)
  34.     {
  35.       if (speed == name_arr[i])
  36.     {
  37.      tcflush (fd, TCIOFLUSH);
  38.      cfsetispeed (&Opt, speed_arr[i]);
  39.      cfsetospeed (&Opt, speed_arr[i]);
  40.      status = tcsetattr (fd, TCSANOW, &Opt);
  41.      if (status != 0)
  42.      {
  43.      perror ("tcsetattr fd1");
  44.      return;
  45.      }
  46.      tcflush (fd, TCIOFLUSH);
  47.     }
  48.     }
  49. }

  51. int
  52. set_Parity (int fd, int databits, int stopbits, int parity)
  53. {
  54.   struct termios options;
  55.   if (tcgetattr (fd, &options) != 0)
  56.     {
  57.       perror ("SetupSerial 1");
  58.       return (FALSE);
  59.     }
  60.   options.c_cflag &= ~CSIZE;
  61.   switch (databits)
  62.     {
  63.     case 7:
  64.       options.c_cflag |= CS7;
  65.       break;
  66.     case 8:
  67.       options.c_cflag |= CS8;
  68.       break;
  69.     default:
  70.       fprintf (stderr, "Unsupported data size\n");
  71.       return (FALSE);
  72.     }
  73.   switch (parity)
  74.     {
  75.     case 'n':
  76.     case 'N':
  77.       options.c_cflag &= ~PARENB;    /* Clear parity enable */
  78.       options.c_iflag &= ~INPCK;    /* Enable parity checking */
  79.       break;
  80.     case 'o':
  81.     case 'O':
  82.       options.c_cflag |= (PARODD | PARENB);
  83.       options.c_iflag |= INPCK;    /* Disnable parity checking */
  84.       break;
  85.     case 'e':
  86.     case 'E':
  87.       options.c_cflag |= PARENB;    /* Enable parity */
  88.       options.c_cflag &= ~PARODD;
  89.       options.c_iflag |= INPCK;    /* Disnable parity checking */
  90.       break;
  91.     case 'S':
  92.     case 's':            /*as no parity */
  93.       options.c_cflag &= ~PARENB;
  94.       options.c_cflag &= ~CSTOPB;
  95.       break;
  96.     default:
  97.       fprintf (stderr, "Unsupported parity\n");
  98.       return (FALSE);
  99.     }

  101.   switch (stopbits)
  102.     {
  103.     case 1:
  104.       options.c_cflag &= ~CSTOPB;
  105.       break;
  106.     case 2:
  107.       options.c_cflag |= CSTOPB;
  108.       break;
  109.     default:
  110.       fprintf (stderr, "Unsupported stop bits\n");
  111.       return (FALSE);
  112.     }
  113.   /* Set input parity option */
  114.   if (parity != 'n')
  115.     options.c_iflag |= INPCK;
  116.   tcflush (fd, TCIFLUSH);
  117.   options.c_cc[VTIME] = 150;
  118.   options.c_cc[VMIN] = 0;    /* Update the options and do it NOW */
  119.   if (tcsetattr (fd, TCSANOW, &options) != 0)
  120.     {
  121.       perror ("SetupSerial 3");
  122.       return (FALSE);
  123.     }
  124.   return (TRUE);
  125. }

  127. void
  128. signal_handler_IO (int status)
  129. {
  130.   printf ("received SIGIO signale.\n");
  131.   wait_flag = noflag;
  132. }

  134. int
  135. main ()
  136. {
  137.   printf ("This program updates last time at %s %s\n", __TIME__, __DATE__);
  138.   printf ("STDIO COM1\n");
  139.   int fd;
  140.   fd = open ("/dev/ttyUSB0", O_RDWR);
  141.   if (fd == -1)
  142.     {
  143.       perror ("serialport error\n");
  144.     }
  145.   else
  146.     {
  147.       printf ("open ");
  148.       printf ("%s", ttyname (fd));
  149.       printf (" succesfully\n");
  150.     }

  152.   set_speed (fd, 115200);
  153.   if (set_Parity (fd, 8, 1, 'N') == FALSE)
  154.     {
  155.       printf ("Set Parity Error\n");
  156.       exit (0);
  157.     }

  159.   char buf[255];
  160.   fd_set rd;
  161.   int nread = 0;
  162.   while(1)
  163.   {
  164.       FD_ZERO(&rd);
  165.     FD_SET(fd, &rd);
  166.     while(FD_ISSET(fd, &rd))
  167.     {
  168.         if(select(fd+1, &rd, NULL,NULL,NULL) < 0)
  169.         {
  170.             perror("select error\n");
  171.         }
  172.         else
  173.         {
  174.             while((nread = read(fd, buf, sizeof(buf))) > 0)
  175.             {
  176.                 printf("nread = %d,%s\n",nread, buf);
  177.                 printf("test\n");
  178.                 memset(buf, 0 , sizeof(buf));
  179.             }
  180.         }
  181.     }
  182.   }
  183.   close (fd);
  184.   return 0;
  185. }

阅读(3164) | 评论(0) | 转发(0) |
0

上一篇：uart uart工具

下一篇：虚拟机VMware中安装Ubuntu

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6