Linux系统串口接收数据编程

最新推荐文章于 2024-03-08 06:00:00 发布
最新推荐文章于 2024-03-08 06:00:00 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 编程技术 ARM-Linux

之前基于IBM deveplopworks社区的代码，做了串口初始化和发送的程序，今天在此基础上添加了读取串口数据的程序。首先是最简单的循环读取程序，第二个是通过软中断方式，使用信号signal机制读取串口，这里需要注意的是硬件中断是设备驱动层级的，而读写串口是用户级行为，只能通过信号机制模拟中断，信号机制的发生和处理其实于硬件中断无异，第三个是通过select系统调用，在没有数据时阻塞进程，串口有数据需要读时唤醒进程。第二个和第三个例子都能用来后台读取数据，值得学习。

代码一：循环读取数据

[cpp]  view plain copy
  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>  
  9.   
  10. #define FALSE -1  
  11. #define TRUE 0  
  12.   
  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. }  
  34.   
  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. }  
  106.   
  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);  
  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.     }  
  123.   
  124.     set_speed(fd,115200);  
  125.     if (set_Parity(fd,8,1,'N') == FALSE)  {  
  126.         printf("Set Parity Error\n");  
  127.         exit (0);  
  128.     }  
  129.     char buf[] = "fe55aa07bc010203040506073d";  
  130.     write(fd,&buf,26);  
  131.     char buff[512];   
  132.     int nread;    
  133.     while(1)  
  134.     {  
  135.         if((nread = read(fd, buff, 512))>0)  
  136.         {  
  137.             printf("\nLen: %d\n",nread);  
  138.             buff[nread+1] = '\0';  
  139.             printf("%s",buff);  
  140.         }  
  141.     }  
  142.     close(fd);  
  143.     return 0;  
  144. }  

代码清单二：通过signal机制读取数据

[cpp]  view plain copy
  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>  
  10.   
  11. #define FALSE -1  
  12. #define TRUE 0  
  13. #define flag 1  
  14. #define noflag 0  
  15.   
  16. int wait_flag = noflag;  
  17. int STOP = 0;  
  18. int res;  
  19.   
  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. }  
  50.   
  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.     }  
  100.   
  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. }  
  126.   
  127. void  
  128. signal_handler_IO (int status)  
  129. {  
  130.   printf ("received SIGIO signale.\n");  
  131.   wait_flag = noflag;  
  132. }  
  133.   
  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.     }  
  152.   
  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);  
  158.   
  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);  
  163.   
  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.     }  
  170.   
  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.     }  
  186.   
  187.   
  188.   close (fd);  
  189.   return 0;  
  190. }  


代码三：通过select系统调用进行io多路切换，实现异步读取串口数据

[python]  view plain copy
  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>  
  10.   
  11. #define FALSE -1  
  12. #define TRUE 0  
  13. #define flag 1  
  14. #define noflag 0  
  15.   
  16. int wait_flag = noflag;  
  17. int STOP = 0;  
  18. int res;  
  19.   
  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. }  
  50.   
  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.     }  
  100.   
  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. }  
  126.   
  127. void  
  128. signal_handler_IO (int status)  
  129. {  
  130.   printf ("received SIGIO signale.\n");  
  131.   wait_flag = noflag;  
  132. }  
  133.   
  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.     }  
  151.   
  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.     }  
  158.   
  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. }  

ZHCX2011
关注
专栏目录
Linux串口应用编程源码
11-22
在Linux系统中，串口设备以文件的形式存在，通常位于/dev目录下，如ttyS0、ttyUSB0等。这些设备文件可以用于读取和写入数据。要使用串口设备，需要打开相应的设备文件。在打开串口时，可以使用O_RDWR选项标志进行...
信号（signal）介绍
nicholasmaxwell的专栏
06-29 3270
信号是Linux编程中非常重要的部分，本文将详细介绍信号机制的基本概念、Linux对信号机制的大致实现方法、如何使用信号，以及有关信号的几个系统调用。 信号机制是进程之间相互传递消息的一种方法，信号全称为软中断信号，也有人称作软中断。从它的命名可以看出，它的实质和使用很象中断。所以，信号可以说是进程控制的一部分。 一、信号的基本概念 本节先介绍信号的一些基本概念，然后给出一些基本的信号类型和信号对
Linux环境下使用interrupt方式操作UART
最新发布
mftang的博客
03-08 2753
本文介绍Linux环境下使用interrupt方式操作UART的方法，实现了串口打开，关闭，发送数据，接收数据功能，还编写测试代码，验证该功能。
linux 中串口操作之中断 读取
m0_59824404的博客
07-14 990
1.windows端使用虚拟串口，通过串口工具发送消息。工具：vspd ，eclipse，串口调试助手。2.linux端，使用此代码读取。
Linux c++多线程串口编程demo
01-26
在Linux系统中，C++是一种常用的编程语言，用于开发高效且复杂的软件，特别是在涉及系统级编程和硬件交互时。本示例"Linux c++多线程串口编程demo"聚焦于利用多线程技术实现串口通信，这是一种常见的硬件接口，用于...
基于Linux平台的串口数据接收程序
01-17
知识点1: Linux串口编程 Linux操作系统提供了对串口的支持，允许用户通过编程来控制串口的行为。在本程序中，我们使用了Linux提供的系统调用来打开、设置和关闭串口。 知识点2: 串口打开函数UART_Open UART_Open...
Linux串口编程详解
03-25
Linux串口编程详解 串口编程是计算机科学中的一种重要技术，它允许计算机与外部设备进行通信。编程语言中串口编程的实现方式有多种，包括使用C语言、Java语言等。 Linux串口编程详解中，串口是计算机上的串行通讯...
linux串口驱动和中断共享
01-03
详细讲解了linux串口驱动和中断共享，并举例说明，对配置串口驱动的新手是很不错的资料
串口循环读取队列
11-03
串口循环读取队列，并在队列进行字符检测
linux下的串口通信程序详解
03-29
linux下的串口通信程序详解，里面 有详细的步骤，而且还有代码例子！
Linux串口编程
m0_49476241的博客
06-19 4073
本篇文章将讲解如何在Linux下使用串口。在Linux系统中，tty（Teletypewriter）是指一种终端设备，它提供了用户与操作系统之间的交互界面。在较早的计算机系统中，tty是以打字机作为输入输出设备的终端系统，而现代的Linux系统中，tty则对应着虚拟终端。Linux下的tty体系是由多个虚拟终端组成的，每个虚拟终端都对应着一个tty设备文件。在Linux系统中，tty设备文件位于/dev目录下，以tty开头，后面跟随一个数字，如tty1、tty2等。
linux 串口 循环读取数据库,Linux串口编程一次读取全部输入的数据（输入数据不定长）...
weixin_28926205的博客
05-02 931
编程背景：板子是linux 2.6.39系统，人机交互接口是板子上的一个串口。输入命令时，当长度大于8时，发现read读取到的数据是分多次得到的(串口用非阻塞模式读取数据)，比如输入的字符长度为25(循环读取，下面贴代码)：第一次读取8个，并发生串口中断(发生中断后中间会有一小会读不到数据，实测)，然后又读取8个、8个、1个(‘\0’不占位)，查了下原因，好多网友也遇到了这个问题，看了几个帖子都没...
Linux-循环读取UART串口数据编程
lysine_的博客
09-09 877
Linux的UART串口通信编程。
Linux下串口程序开发
轻舞飞扬
07-23 1014
原文链接：http://blog.csdn.net/tianmo2010/article/details/6278992 2.1      读串口 读取串口数据使用文件操作read函数读取，如果设置为原始模式(Raw Mode)传输数据，那么read函数返回的字符数是实际串口收到的字符数。 char  buff[1024]; int    Len; int  readByte =
Linux串口驱动程序(5)-串口接收分析
上善若水
07-03 1599
1、tty数据接收流程分析 在用户调用read函数来读取设备的文件的数据时，首先得到响应的是tty_read，这个函数又是由n_tty_read来实现的 /** * n_tty_read - read function for tty * @tty: tty device * @file: file object * @buf: userspace buffer point...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值