上位机软件设计--串口与曲线图实时显示

最新推荐文章于 2024-04-30 11:46:45 发布
最新推荐文章于 2024-04-30 11:46:45 发布
阅读量2.5k 收藏 14
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23144435/article/details/80402000
版权
 static double THRESHOLD_PARAM = 8;
        static double FILTER_PARAMETER = 16;
        static int SAMPLE_RATE = 250;
        public static String Road ="";
        public static String result = "";
        public static String result1 = "";
        public static String result2 = "";
        public static HttpWebRequest httpReq = null;
        public static List<int> HeartData = new List<int>();
        public static List<int> HeartDataHandleS1 = new List<int>();
        public static List<int> HeartDataHandleS2 = new List<int>();
        private SerialPort comm = new SerialPort();
        private SerialPort comm_1 = new SerialPort();
        private SerialPort comm_2 = new SerialPort();
        private SerialPort comm_4 = new SerialPort();

        private StringBuilder builder = new StringBuilder();//避免在事件处理方法中反复的创建，定义到外面。
        private long received_count = 0;//接收计数
        private long send_count = 0;//发送计数
        private bool Listening = false;//是否没有执行完invoke相关操作 
        private bool Closing = false;
        string[] Str = new string[1024];
        List<byte> buffer = new List<byte>(6);
        public static String Roadpicture = "";
        public static String WSS;
        public static String WSZ;
        public static String H;
        public static String BO;
        public static String Temp;
       
      FileInfo finfo = null;
        private Random r;
        StreamWriter sw;
        System.Windows.Forms.Timer chartTimer = new System.Windows.Forms.Timer();
 private void Form1_Load(object sender, EventArgs e)
        {
            comm_2.PortName = "COM17";   //血压
            comm_2.BaudRate = 115200;
            comm_2.Open();
            comm_2.NewLine = "\r\n";
            comm_2.RtsEnable = true;//根据实际情况吧。
            comm_2.DataReceived += comm_DataReceived_3;



            //comm_1.PortName = "COM7";    //心电波
            //comm_1.BaudRate = 115200;
            //comm_1.Open();
            //comm_1.NewLine = "\r\n";
            //comm_1.RtsEnable = true;//根据实际情况吧。
            //comm_1.DataReceived += comm_DataReceived_1;

            comm.PortName = "COM18";     
            comm.BaudRate = 115200;
            comm.Open();

            //初始化SerialPort对象
            comm.NewLine = "\r\n";
            comm.RtsEnable = true;//根据实际情况吧。
        

            添加事件注册
            comm.DataReceived += comm_DataReceived_2; //血氧 FF C7 03 A3 A0

            comm_4.PortName = "COM19";
            comm_4.BaudRate = 115200;
            comm_4.Open();

            //初始化SerialPort对象
            comm_4.NewLine = "\r\n";
            comm_4.RtsEnable = true;//根据实际情况吧。


            添加事件注册
            comm_4.DataReceived += comm_DataReceived_4; //体温 FF C9 03 A3 A0

        }
void comm_DataReceived_1(object sender, SerialDataReceivedEventArgs e)
        {
           //
            //  if (Closing) return;//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环 
            try
            {
               
                Listening = true;//设置标记，说明我已经开始处理数据，一会儿要使用系统UI的。 
                int n = comm_1.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致 
                byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据 
              //  received_count += n;//增加接收计数 
                comm_1.Read(buf, 0, n);//读取缓冲数据 
             //   builder.Clear();//清除字符串构造器的内容 
                //因为要访问ui资源，所以需要使用invoke方式同步ui。 
                this.BeginInvoke((EventHandler)(delegate
                {
                    //判断是否是显示为16进制 
                    if (n > 8)
                    {
                     
                   
                        System.Windows.Forms.DataVisualization.Charting.Series series0 = chart1.Series[0];
                        chart1.ChartAreas[0].AxisX.Interval = 20;
                        chart1.ChartAreas[0].AxisY.Interval = 20;
                        chart1.Series[0].Color = Color.Black;
                        for (int i = 8; i < n - 1; i++)
                        {
                            HeartData.Add(buf[i]);
                            series0.Points.AddY(buf[i]);
                                                  
                            if (HeartData.Count == 400)
                            {
                                int[] result = SoAndChan(HeartData.ToArray());
                                if(result.Length>0)
                                for(int l=0;l< result.Length;l++)
                                {
                                        // textBoxH.AppendText(Convert.ToString(result[l]+","));
                                        if (HeartDataHandleS1.Count < 6)
                                            HeartDataHandleS1.Add(HeartData[result[l]]);
                                        else
                                            HeartDataHandleS2.Add(HeartData[result[l]]);
                                }
                                HeartData.Clear();

                            }
                         
                        }
                        chart1.ChartAreas[0].AxisX.Maximum = 1300;
                        chart1.ChartAreas[0].AxisX.Minimum = 0;
                        if (chart1.Series[0].Points.Count > 100)
                        {
                            chart1.Series[0].Points.RemoveAt(0);
                            chart1.Series[0].Points.RemoveAt(1);
                            chart1.Series[0].Points.RemoveAt(2);
                            chart1.Series[0].Points.RemoveAt(3);
                            chart1.Series[0].Points.RemoveAt(4);
                            chart1.Series[0].Points.RemoveAt(5);
                            chart1.Series[0].Points.RemoveAt(6);
                            chart1.Series[0].Points.RemoveAt(7);
                            chart1.Series[0].Points.RemoveAt(8);
                            chart1.Series[0].Points.RemoveAt(9);
                            chart1.Series[0].Points.RemoveAt(10);
                            chart1.Series[0].Points.RemoveAt(11);
                            chart1.Series[0].Points.RemoveAt(12);
                            chart1.Series[0].Points.RemoveAt(13);
                            chart1.Series[0].Points.RemoveAt(14);
                            chart1.Series[0].Points.RemoveAt(15);
                            chart1.Series[0].Points.RemoveAt(16);
                            chart1.Series[0].Points.RemoveAt(17);
                            chart1.Series[0].Points.RemoveAt(18);
                            chart1.Series[0].Points.RemoveAt(19);
              
                           
                        }
                        if (HeartDataHandleS1.Count > 5&& HeartDataHandleS2.Count>5)
                        {
                            var data = new List<double[]>() {
                            new double[] {111,154,132.5},
                            new double[] {123,134,128.81},
                            new double[] {140,160,152.14},
                            new double[] {140,204,176},
                            new double[] {160,184,172},
                            new double[] {159,165,162},
                            };
                            var labels = new List<int>()
                            {
                                1,1,1,0,0,0
                             };
                            MachineLearning.Classification.KNN knn = new KNN(k: 3, labels: labels, features: data);
                           // knn.Display();
                            knn.Classify(new double[][] { new double[] { HeartDataHandleS1.Min(), HeartDataHandleS1.Max(), HeartDataHandleS1.Average() } });
                            result1 = knn.Display();
                            knn.Classify(new double[][] { new double[] { HeartDataHandleS2.Min(), HeartDataHandleS2.Max(), HeartDataHandleS2.Average() } });
                            result2 = knn.Display();
                            if (result1.Equals("1")&& result2.Equals("1"))
                                textBoxH.AppendText("心率没有异常！"+"\n");
                            else
                                textBoxH.AppendText("心率有异常！");
                            textBox2.Text = @"心率：" + H + "\n" + "血氧饱和度：" + BO + "\n" + "舒张压：" + WSZ + "\n" + "伸缩压: " + WSS + "\n"+"体温："+Temp+"\n";
                            HeartDataHandleS1.Clear();
                            HeartDataHandleS2.Clear();
                        }

                       
                        if (series0.Points.Count > 2000)
                        {
                            ExportChart("chart", chart1);
                            series0.Points.Clear();
                        }
                        //  mycon.Close();
                    }
                    //追加的形式添加到文本框末端，并滚动到最后。 
                    //this.txGet.AppendText(builder.ToString());

                    //修改接收计数 
                    //labelGetCount.Text = "Get:" + received_count.ToString();
                }));
            }
            finally
            {

                Listening = false;//我用完了，ui可以关闭串口了。 
            }
        }

        void comm_DataReceived_3(object sender, SerialDataReceivedEventArgs e)
        {
            //
            //  if (Closing) return;//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环 
            try
            {
                int n = comm_2.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致 
                byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据 
                                         //  received_count += n;//增加接收计数 
                comm_2.Read(buf, 0, n);
                this.BeginInvoke((EventHandler)(delegate
                {
                    //判断是否是显示为16进制 
                    //                    comm_2.WriteLine(new string(new char[] { FF C0 03 A3 A0 }));
                
                    if(n==10)
                    {
                        textBox4.AppendText("收缩压："+buf[6].ToString() + ",");
                        textBox4.AppendText("舒张压："+buf[8].ToString() + ",");
                        textBox4.AppendText("心率为:"+buf[9].ToString());
                        WSS = buf[6].ToString();
                        WSZ = buf[8].ToString();
                        H = buf[9].ToString();
                    }
                }));
            }
            finally
            {
              

            }
        }

        void comm_DataReceived_4(object sender, SerialDataReceivedEventArgs e)
        {
            //
            //  if (Closing) return;//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环 
            try
            {
                int n = comm_4.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致 
                byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据 
                                         //  received_count += n;//增加接收计数 
                comm_4.Read(buf, 0, n);
                this.BeginInvoke((EventHandler)(delegate
                {
                    //判断是否是显示为16进制 
                    //                    comm_2.WriteLine(new string(new char[] { FF C0 03 A3 A0 }));

                    if (n == 7)
                    {
                      //  textBox4.AppendText("体温：" + buf[5].ToString() + ",");
                        textBox4.AppendText("体温：" + (buf[6]-71) + ",");
                        Temp = (buf[6] - 71).ToString();
                    }
                }));
            }
            finally
            {

            }
        }







        void comm_DataReceived_2(object sender, SerialDataReceivedEventArgs e)
        {
            //
            //  if (Closing) return;//如果正在关闭，忽略操作，直接返回，尽快的完成串口监听线程的一次循环 
            try
            {
                 
                Listening = true;//设置标记，说明我已经开始处理数据，一会儿要使用系统UI的。 
                int n = comm.BytesToRead;//先记录下来，避免某种原因，人为的原因，操作几次之间时间长，缓存不一致 
                byte[] buf = new byte[n];//声明一个临时数组存储当前来的串口数据 
         //       received_count += n;//增加接收计数 
                comm.Read(buf, 0, n);//读取缓冲数据 
       //         builder.Clear();//清除字符串构造器的内容 
                //因为要访问ui资源，所以需要使用invoke方式同步ui。 
                this.BeginInvoke((EventHandler)(delegate
                {
                    //判断是否是显示为16进制 
                    if (n > 7)
                    {
                     
                        chart2.ChartAreas[0].AxisX.Interval = 8;
                        chart2.ChartAreas[0].AxisY.Interval = 10;
                        chart3.ChartAreas[0].AxisX.Interval = 8;
                        chart3.ChartAreas[0].AxisY.Interval = 10;
                        chart4.ChartAreas[0].AxisX.Interval = 8;
                        chart4.ChartAreas[0].AxisY.Interval = 10;
                      
                       

                        System.Windows.Forms.DataVisualization.Charting.Series series0 = chart2.Series[0];
                        System.Windows.Forms.DataVisualization.Charting.Series series1 = chart3.Series[0];
                        System.Windows.Forms.DataVisualization.Charting.Series series3 = chart4.Series[0];
                        chart2.Series[0].Color = Color.Black;
                        chart3.Series[0].Color = Color.Black;
                        chart4.Series[0].Color = Color.Black;

                        //   for (int i = 8; i < n - 1; i++)
                        //  {
                        series0.Points.AddY(buf[7]); //HEARTh
                        series1.Points.AddY(buf[5]);  //WAVE
                        series3.Points.AddY(buf[6]);  //bo
                        BO = buf[6].ToString();
                //        SendHeartData(buf[7].ToString()+","+buf[5].ToString()+","+buf[6].ToString());

                        chart2.ChartAreas[0].AxisX.Maximum = 200;
                        chart2.ChartAreas[0].AxisX.Minimum = 0;
                        if (chart2.Series[0].Points.Count > 200)
                        {
                            chart2.Series[0].Points.RemoveAt(0);
                            if (chart2.Series[0].Points.Count > 1000)
                            {
                                ExportChart("chart2", chart2);
                                ExportChart("chart4", chart4);
                                chart2.Series[0].Points.Clear();
                                //    series1.Points.Clear();
                               
                            }
                        }
                        chart3.ChartAreas[0].AxisX.Maximum = 200;
                        chart3.ChartAreas[0].AxisX.Minimum = 0;
                        if (chart3.Series[0].Points.Count > 190)
                        {
                            chart3.Series[0].Points.RemoveAt(0);
                            chart3.Series[0].Points.RemoveAt(1);
                      //      chart3.Series[0].Points.RemoveAt(2);
                     //       chart3.Series[0].Points.RemoveAt(3);
                     //       chart3.Series[0].Points.RemoveAt(4);
                     //       chart3.Series[0].Points.RemoveAt(5);
                           // chart3.Series[0].Points.RemoveAt(6);
                           // chart3.Series[0].Points.RemoveAt(7);
                            //chart3.Series[0].Points.RemoveAt(8);
                            //chart3.Series[0].Points.RemoveAt(9);
                        }
                        chart4.ChartAreas[0].AxisX.Maximum = 200;
                        chart4.ChartAreas[0].AxisX.Minimum = 0;
                        if (chart4.Series[0].Points.Count > 200)
                        {
                             chart4.Series[0].Points.RemoveAt(0);
                            if (chart4.Series[0].Points.Count > 1000)
                            {
                                ExportChart("chart2", chart2);
                                ExportChart("chart3", chart3);
                                ExportChart("chart4", chart4);
                                chart4.Series[0].Points.Clear();
                                chart3.Series[0].Points.Clear();
                            }
                         
                        }
                     
                        //  mycon.Close();
                    }
                    //追加的形式添加到文本框末端，并滚动到最后。 
                    //this.txGet.AppendText(builder.ToString());

                    //修改接收计数 
                    //labelGetCount.Text = "Get:" + received_count.ToString();
                }));
            }
            finally
            {
                Listening = false;//我用完了，ui可以关闭串口了。 
            }
        }

        private static void DataBind()
        {
            throw new NotImplementedException();
        }
        private void buttonOpenClose_Click(object sender, EventArgs e)
        {
            //根据当前串口对象，来判断操作 
            if (comm.IsOpen)
            {
                Closing = true;
                while (Listening) System.Windows.Forms.Application.DoEvents();
                //打开时点击，则关闭串口 
                comm.Close();
                Closing = false;
            }
            else
            {
                //关闭时点击，则设置好端口，波特率后打开 
                comm.PortName = comboPortName.Text;
            //    comm.BaudRate = int.Parse(comboBaudrate.Text);
                try
                {
                    comm.Open();
                }
                catch (Exception ex)
                {
                    //捕获到异常信息，创建一个新的comm对象，之前的不能用了。 
                    comm = new SerialPort();
                    //现实异常信息给客户。 
                    MessageBox.Show(ex.Message);
                }
            }
            //设置按钮的状态 
            //buttonOpenClose.Text = comm.IsOpen ? "Close" : "Open";
        }
小然_ran
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
UIDemo_UI上位机框架_上位机界面_
09-30
上位机UI界面设计及与1200PLC通信数据的读写
Qt实时波形绘图（使用QCustomPlot）
weixin_47488212的博客
03-22 1万+
对于初学者而言，想要及时地做出一套上位机或实时波形显示界面，还是存在一定难度的，为了降低初学者的学习难度，亦方便其他研发人员的使用，我分享一套使用简单、功能强大的实时波形绘制控件，其基于Qt5与QCustomPlot实现。
Qt C++上位机实时曲线：串口通信、平滑曲线控件及外观设置
最新发布
ejxRnSDvQA的博客
04-30 1216
摘要：本文介绍了通过使用Qt和C++编程语言开发上位机应用，实现了串口数据的收发以及实时曲线的绘制和平滑处理。通过使用Qt和C++编程语言，本文实现了基于上位机的串口数据收发和实时曲线绘制，并介绍了曲线控件的外观设置和平滑处理方法。本文使用Qt提供的曲线控件，通过调用相关的API函数，可以实现曲线的添加、删除、颜色设置等操作。本文的主要目的是介绍如何通过编程实现上位机应用中的串口数据收发和实时曲线绘制，并介绍如何使用平滑算法对曲线进行处理，以提高曲线的美观度和可读性。4）编译器：msvc;
VS上位机开发——曲线显示
ShenZhen_zixian的博客
09-01 6427
刚刚接触上位机的开发，单纯是为了玩一下，浅度学习，关于曲线显示的实现方法，网上的资料太杂，也很零碎，经过自己的一些摸索，终于实现了我想要的效果，算是迈出了第一步。写博客记录一下学习的过程。
C#上位机系列——工控上位机示波器/ 绘图曲线控件（一）
qq_49552487的博客
05-12 5448
破大防，做实验时找不到一个满意的上位机实时显示波形，在网上寻找了许久都没有，不是要钱就是不开源，于是下定决定自己做一个，也方便以后做实验调试。由于此项目开发周期较长，做到那更到哪，点赞收藏不迷路。 1. 项目介绍 代码都是自己写的，不是专门的it程序员，所以专业性不强，仅供学习参考。 用的VS，做C#上位机的Winform应该多少会用吧，这里简单介绍一下，选.NET的 创建以后毛都没有： 然后右键，查看代码，该重命名的重命名。 添加画图的引用： 然后手撸示波器，代码放下面了，所有注
如何在匿名上位机中显示自定义数据波形
Anitawen的博客
12-30 2466
如何在匿名上位机中显示自定义数据波形
曲线图绘制、分析上位机软件平台-用于热释电传感器矩阵数据采集
09-04
使用C#.NET设计了上位机软件。为以上研究做了试验平台，适合在此基础上进行深度研究、结合AI算法实现定位、状态识别等。 开发平台： visual Stidio 2010 语言：C# 框架：winform应用程序 主要包括以下功能： 1）串行...
在线温度监控系统上位机软件设计-毕业设计论文.doc
07-11
在本项目中，使用C++Builder6.0开发了温度监控系统的用户界面，实现了温度数据的实时显示和曲线图的绘制。 C语言编程 C语言是一种高级编程语言，广泛应用于操作系统、嵌入式系统、数据库管理系统等领域。C语言具有...
c#上位机接收STM32的数据实时显示存表格并画曲线图
07-06
用c#编写的上位机软件实时接收串口数据，用dataGridView显示所读取的数据，并写入TXT， 用chart把数据绘制成波形，有放大缩小功能（功能有待完善），chart有两条游标。资源如有不足请留言指教。
[015]RTDemo-获取串口数据并画出曲线图的VC++源码.zip上位机开发VC串口学习资料源码下载
05-04
[015]RTDemo-获取串口数据并画出曲线图的VC++源码.zip上位机开发VC串口学习资料源码下载[015]RTDemo-获取串口数据并画出曲线图的VC++源码.zip上位机开发VC串口学习资料源码下载[015]RTDemo-获取串口数据并画出曲线图...
基于微软MFC框架的BOTDR上位机软件源码botdr-mfc-master.zip
01-29
开发者可能使用这些类来创建实时更新的曲线图，显示光纤的损耗分布。 5. **文件I/O**：软件可能需要保存和加载测试结果，这涉及到文件操作。MFC提供了CFile类进行文件读写，同时，为了方便数据存储，可能会使用XML...
VT1.1.zip_C# chart控件_C#显示串口chart_chart的控件_famousa2l_串口折线图
07-15
使用C#的winform读取串口，并用chart控件显示实时数据折线图
开源一款基于Qt的串口波形显示上位机 & 以“笔”会友
vaincury的博客
04-27 6006
开源一款基于Qt的串口波形显示上位机 & 以“笔”会友写在前面简要介绍基本界面功能简介开源地址最后的说明 写在前面 大家好！我是大学里一枚菜鸡在读本科生。这是我第一次在CSDN上发博客，我想开源一个我近几日编写的一个基于Qt的串口波形显示上位机 ，这个上位机参考了一些Qt官方的example代码，也在一些琐碎的地方结合了一些网上大神网友的新奇思路。之所以开源这个东西，是想以此为“敲门砖”，...
serialplot - 开源QT串口上位机 - 温度曲线显示
hxkrrzq的博客
04-16 1万+
介绍一个不错的开源项目serialplot，顺便再次安利Arduino，作为程序员，不管你有多专业，Arduino及其周边总有海量的资源等待你去探索，感谢Arduino这个NB的项目!！ 回归正题，serialplot。一个可视化的串口收发工具，QT源码开源，是不是每一个底层软件工程师都需要一个可以100%掌控的上位机呢？ 源码： https://bitbucket.org/hyOzd/s...
python——基于pyqtgraph和下位机串口通信并实现实时数据绘图
Irving.Gao的博客
01-24 3740
想在上位机端实时调下位机的pid，所以需要看一下波形，拒绝盲调。同时使用pyqtgragh可以轻松地将数据进行动态可视化。 文章目录环境准备串口通信基本连接串口动态参数可视化实时效果展示 环境准备 pyserial pip install pyserial pyqtgraph pip install pyqtgraph pip install PyQt5 串口通信基本连接 import serial ser = serial.Serial("COM3", 9600, timeout=1, .
Qt上位机2套串口实时曲线带平滑
m0_66543816的博客
01-20 315
Qt上位机2套串口实时曲线带平滑 1,设置串口. 2,串口收发数据。 3,数据模拟。 4,接收数据形成曲线。 5,曲线控件的各种外观设置。 6,可以设置平滑曲线。id=644167212367&
【STM32调试（一）】串口发送像素，上位机解析显示。
热门推荐
later的博客
03-20 1万+
图片上位机一、思路二、STM32采集数据发送2.1、OV7725模组2.2、串口发送三、上位机接收，解析，显示保存2.1、接收解析2.2、数据格式转换2.3、遇到问题四、小结&开源 一、思路 二、STM32采集数据发送 2.1、OV7725模组 2.2、串口发送 有两种发送方式：高低位单独发送；合并一起发送。 发送内容：黑白，二值，彩图 三、上位机接收，解析，显示保存 2.1、接收解析 2...
上位机UI界面设计项目
世界需要程序员，而我就是其中一员！
04-19 3652
本篇博客主要讲解上位机的UI界面的基本布局，思路如下： 业务逻辑： 1，有一个用户名输入框，可以输入任意字符； 2，有一个密码输入框，可以输入任意字符，但是需要以 *代替文本显示，避免密码泄露； 3，有一个登录按钮，当点击登录按钮时，到数据库检验用户名与密码的正确性，如果用户名密码验证正确，则跳转到程序主操作页面，否则提示用户检验用户名或密码是否正确。 在主控制台页面增加设备功能： 1，海康摄像头视频预览、下载功能； 2，日志解析功能； 3，设备感应器信号实时查看功能； 4，发送指令操作设备硬件的功能；
C#上位机后台数据更新与前端UI数据更新界面不卡滞
qqwertccc的博客
03-26 856
C#上位机常用功能
树莓派采集到的数据如何在qt上位机实时显示
07-05
4. 在Qt上位机中实时显示数据：使用Qt的界面设计工具，在界面中添加显示数据的控件（如文本框、图表等）。在接收到新的数据时，可以通过信号与槽机制将数据更新到界面上的相应控件中。 5. 运行程序并连接树莓派与Qt...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值