FPGA学习verilog实现b码解码

最新推荐文章于 2024-01-26 17:49:48 发布
最新推荐文章于 2024-01-26 17:49:48 发布
阅读量2k 收藏 24
点赞数 9
文章标签： fpga开发 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51152795/article/details/131264771
版权

verilog实现b码解码

时序图和状态转换图

在这里插入图片描述状态转换

代码

b_decoder.v

module b_decoder (
    input wire clk,
    input wire rst_n,
    input wire irig_b,
    output wire [6:0]second_out,
    output wire [6:0]minute_out,
    output wire [6:0]hour_out,
    output wire [9:0]day_out,
    output wire [7:0]year_out
);

parameter MAX_8MS = 999_999;
parameter MAX_5MS = 624_999;
parameter MAX_2MS = 249_999;
parameter MAX_1S = 99;
parameter IDLE = 4'b0000;
parameter P = 4'b0001;
parameter SEC = 4'b0011;
parameter MIN = 4'b0010;
parameter HOUR = 4'b0110;
parameter DAY1 = 4'b0111;
parameter DAY2 = 4'b0101;
parameter YEAR = 4'b0100;
parameter S0 = 4'b1100;
parameter S1 = 4'b1101;
parameter S2 = 4'b1111;
parameter S3 = 4'b1110;

reg irig_b_r1;
reg [19:0]cnt_pos;
reg [1:0]decode;
reg [3:0]state;
reg [6:0]cnt_1s;

reg [6:0]second;
reg [6:0]minute;
reg [5:0]hour;
reg [9:0]day;
reg [7:0]year;

//下降沿和上升沿判断
//延迟一拍的输入波形
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        irig_b_r1 <= 1'b0;
    end
    else begin
        irig_b_r1 <= irig_b;
    end
end


assign edge_pos = irig_b & ~irig_b_r1;//上升沿
assign edge_neg = ~irig_b & irig_b_r1;//下降沿

//b码高电平计数
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        cnt_pos <= 20'd0;
    end
    else if (edge_pos) begin
        cnt_pos <= 20'd1;
    end
    else if (irig_b) begin
        cnt_pos <= cnt_pos +20'b1;
    end
    else begin
        cnt_pos <= cnt_pos;
    end
end

//下降沿判断，波形编码
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        decode <= 2'b00;
    end
    else if (cnt_pos == MAX_8MS + 1 && edge_neg) begin
        decode <= 2'b11;
    end
    else if (cnt_pos == MAX_5MS + 1 && edge_neg) begin
        decode <= 2'b01;
    end
    else if (cnt_pos == MAX_2MS + 1 && edge_neg) begin
        decode <= 2'b00;
    end
end

//状态机
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        state <= IDLE;
    end
    else case (state)
        IDLE : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= P;
            end
            else begin
                state <= state;
            end
        end
        P : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= SEC;
            end
            else if ((decode == 2'b00 && edge_pos)||(decode == 2'b00 && edge_pos)) begin
                state <= IDLE;
            end
            else begin
                state <= state;
            end
        end
        SEC : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= MIN;
            end
            else begin
                state <= state;
            end
        end
        MIN : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= HOUR;
            end
            else begin
                state <= state;
            end
        end
        HOUR : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= DAY1;
            end
            else begin
                state <= state;
            end
        end
        DAY1 : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= DAY2;
            end
            else begin
                state <= state;
            end
        end
        DAY2 : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= YEAR;
            end
            else begin
                state <= state;
            end
        end
        YEAR : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= S0;
            end
            else begin
                state <= state;
            end
        end
        S0 : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= S1;
            end
            else begin
                state <= state;
            end
        end
        S1 : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= S2;
            end
            else begin
                state <= state;
            end
        end
        S2 : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= S3;
            end
            else begin
                state <= state;
            end
        end
        S3 : begin
            if (decode == 2'b11 && edge_pos) begin
                state <= P;
            end
            else begin
                state <= state;
            end
        end
        default: state <= state;
    endcase
end
    
    
// 根据状态机控制cnt_1s计数
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        cnt_1s <= 7'd0;
    end
    else if (cnt_1s == MAX_1S && edge_pos) begin
        cnt_1s <= 7'd0;
    end
    else if (state == P && edge_pos) begin
        cnt_1s <= 7'd1;
    end
    else if (edge_pos) begin
        cnt_1s <= cnt_1s + 7'd1;
    end
    else begin
        cnt_1s <= cnt_1s;
    end
end

//赋值
always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        second <= 7'b0;
    end
    else if (cnt_1s == 8'd1) begin
        second[0] <= decode[0];
    end
    else if (cnt_1s == 8'd2) begin
        second[1] <= decode[0];
    end
    else if (cnt_1s == 8'd3) begin
        second[2] <= decode[0];
    end
    else if (cnt_1s == 8'd4) begin
        second[3] <= decode[0];
    end
    else if (cnt_1s == 8'd6) begin
        second[4] <= decode[0];
    end
    else if (cnt_1s == 8'd7) begin
        second[5] <= decode[0];
    end
    else if (cnt_1s == 8'd8) begin
        second[6] <= decode[0];
    end
    else begin
        second <= second;
    end
end

always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        minute <= 7'b0;
    end
    else if (cnt_1s == 8'd10) begin
        minute[0] <= decode[0];
    end
    else if (cnt_1s == 8'd111) begin
        minute[1] <= decode[0];
    end
    else if (cnt_1s == 8'd12) begin
        minute[2] <=decode[0];
    end
    else if (cnt_1s == 8'd13) begin
        minute[3] <= decode[0];
    end
    else if (cnt_1s == 8'd15) begin
        minute[4] <= decode[0];
    end
    else if (cnt_1s == 8'd16) begin
        minute[5] <= decode[0];
    end
    else if (cnt_1s == 8'd17) begin
        minute[6] <= decode[0];
    end
    else begin
        minute <= minute;
    end
end

always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        hour <= 6'b0;
    end
    else if (cnt_1s == 8'd20) begin
        hour[0] <= decode[0];
    end
    else if (cnt_1s == 8'd21) begin
        hour[1] <= decode[0];
    end
    else if (cnt_1s == 8'd22) begin
        hour[2] <= decode[0];
    end
    else if (cnt_1s == 8'd23) begin
        hour[3] <= decode[0];
    end
    else if (cnt_1s == 8'd25) begin
        hour[4] <= decode[0];
    end
    else if (cnt_1s == 8'd26) begin
        hour[5] <= decode[0];
    end
    else begin
        hour <= hour;
    end
end

always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        day <= 10'b0;
    end
    else if (cnt_1s == 8'd30) begin
        day[0] <= decode[0];
    end
    else if (cnt_1s == 8'd31) begin
        day[1] <= decode[0];
    end
    else if (cnt_1s == 8'd32) begin
        day[2] <= decode[0];
    end
    else if (cnt_1s == 8'd33) begin
        day[3] <= decode[0];
    end
    else if (cnt_1s == 8'd35) begin
        day[4] <= decode[0];
    end
    else if (cnt_1s == 8'd36) begin
        day[5] <= decode[0];
    end
    else if (cnt_1s == 8'd37) begin
        day[6] <= decode[0];
    end
    else if (cnt_1s == 8'd38) begin
        day[7] <= decode[0];
    end
    else if (cnt_1s == 8'd40) begin
        day[8] <= decode[0];
    end
    else if (cnt_1s == 8'd41) begin
        day[9] <= decode[0];
    end
    else begin
        day <= day;
    end
end

always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        year <= 6'b0;
    end
    else if (cnt_1s == 8'd50) begin
        year[0] <= decode[0];
    end
    else if (cnt_1s == 8'd51) begin
        year[1] <= decode[0];
    end
    else if (cnt_1s == 8'd52) begin
        year[2] <= decode[0];
    end
    else if (cnt_1s == 8'd53) begin
        year[3] <= decode[0];
    end
    else if (cnt_1s == 8'd55) begin
        year[4] <= decode[0];
    end
    else if (cnt_1s == 8'd56) begin
        year[5] <= decode[0];
    end
    else if (cnt_1s == 8'd57) begin
        year[6] <= decode[0];
    end
    else if (cnt_1s == 8'd58) begin
        year[7] <= decode[0];
    end
    else begin
        year <= year;
    end
end


assign second_out = second[6:4]*10 + second[3:0];
assign minute_out = minute[6:4]*10 + minute[3:0];
assign hour_out = hour[5:4]*10 + hour[3:0];
assign day_out = day[9:8]*100 + day[7:4]*10 + day[3:0];
assign year_out = year[7:4]*10 + year[3:0];

endmodule

tb文件

`timescale 1ns/1ps

module b_decoder_tb ();
    

reg clk;
reg rst_n;
reg irig_b;
wire  [6:0]second_out;
wire  [6:0]minute_out;
wire  [6:0]hour_out;
wire  [9:0]day_out;
wire  [7:0]year_out;

initial begin
    rst_n = 1'b0;
    clk = 1'b0;
    #2
    rst_n = 1'b1;
end

always #4 clk = ~clk;

wire [7:0]mem[1:100];

assign mem[1] = 8'h70; P
assign mem[2] = 8'h30; 0
assign mem[3] = 8'h30; 0
assign mem[4] = 8'h30; 0
assign mem[5] = 8'h31; 1
assign mem[6] = 8'h30; 0
assign mem[7] = 8'h30; 0
assign mem[8] = 8'h30; 0
assign mem[9] = 8'h30; 0

assign mem[10] = 8'h70; P
assign mem[11] = 8'h30; 0
assign mem[12] = 8'h30; 0
assign mem[13] = 8'h30; 0
assign mem[14] = 8'h31; 1
assign mem[15] = 8'h30; 0
assign mem[16] = 8'h30; 0
assign mem[17] = 8'h30; 0
assign mem[18] = 8'h31; 1
assign mem[19] = 8'h30; 0

assign mem[20] = 8'h70; P
assign mem[21] = 8'h31; 1
assign mem[22] = 8'h30; 0
assign mem[23] = 8'h30; 0
assign mem[24] = 8'h30; 0
assign mem[25] = 8'h30; 0
assign mem[26] = 8'h30; 0
assign mem[27] = 8'h30; 0
assign mem[28] = 8'h30; 0
assign mem[29] = 8'h30; 0

assign mem[30] = 8'h70; P
assign mem[31] = 8'h31; 1
assign mem[32] = 8'h30; 0
assign mem[33] = 8'h30; 0
assign mem[34] = 8'h30; 0
assign mem[35] = 8'h30; 0
assign mem[36] = 8'h31; 1
assign mem[37] = 8'h30; 0
assign mem[38] = 8'h31; 1
assign mem[39] = 8'h30; 0

assign mem[40] = 8'h70; P
assign mem[41] = 8'h30; 0
assign mem[42] = 8'h31; 1
assign mem[43] = 8'h30; 0
assign mem[44] = 8'h30; 0
assign mem[45] = 8'h30; 0
assign mem[46] = 8'h30; 0
assign mem[47] = 8'h30; 0
assign mem[48] = 8'h30; 0
assign mem[49] = 8'h30; 0

assign mem[50] = 8'h70; P
assign mem[51] = 8'h31; 1
assign mem[52] = 8'h30; 0
assign mem[53] = 8'h30; 0
assign mem[54] = 8'h30; 0
assign mem[55] = 8'h30; 0
assign mem[56] = 8'h30; 0
assign mem[57] = 8'h31; 1
assign mem[58] = 8'h30; 0
assign mem[59] = 8'h30; 0

assign mem[60] = 8'h70; P
assign mem[61] = 8'h30; 0
assign mem[62] = 8'h30; 0
assign mem[63] = 8'h30; 0
assign mem[64] = 8'h30; 0
assign mem[65] = 8'h30; 0
assign mem[66] = 8'h30; 0
assign mem[67] = 8'h30; 0
assign mem[68] = 8'h30; 0
assign mem[69] = 8'h30; 0

assign mem[70] = 8'h70; P
assign mem[71] = 8'h30; 0
assign mem[72] = 8'h30; 0
assign mem[73] = 8'h30; 0
assign mem[74] = 8'h30; 0
assign mem[75] = 8'h30; 0
assign mem[76] = 8'h31; 1
assign mem[77] = 8'h30; 0
assign mem[78] = 8'h30; 0
assign mem[79] = 8'h30; 0

assign mem[80] = 8'h70; P
assign mem[81] = 8'h30; 0
assign mem[82] = 8'h30; 0
assign mem[83] = 8'h30; 0
assign mem[84] = 8'h31; 1
assign mem[85] = 8'h31; 1
assign mem[86] = 8'h30; 0
assign mem[87] = 8'h31; 1
assign mem[88] = 8'h30; 0
assign mem[89] = 8'h31; 1

assign mem[90] = 8'h70; P
assign mem[91] = 8'h30; 0
assign mem[92] = 8'h30; 0
assign mem[93] = 8'h31; 1
assign mem[94] = 8'h31; 1
assign mem[95] = 8'h30; 0
assign mem[96] = 8'h30; 0
assign mem[97] = 8'h30; 0
assign mem[98] = 8'h30; 0
assign mem[99] = 8'h30; 0

assign mem[100] = 8'h70; P

reg [6:0]cnt_1s;
reg [20:0]cnt_10ms;
reg [2:0]state;
parameter IDLE = 3'd0;
parameter S0 = 3'd1;
parameter S1 = 3'd2;
parameter S2 = 3'd3;
parameter S3 = 3'd4;
parameter MAX_10MS = 1249999;
parameter MAX_8MS = 999_999;
parameter MAX_5MS = 624_999;
parameter MAX_2MS = 249_999;

always @(posedge clk or negedge rst_n) begin
    if (~rst_n) begin
        state <= IDLE;
        cnt_10ms <= 21'd0;
        cnt_1s <= 7'd1;
    end
    else case (state)
        IDLE : begin
            if (mem[cnt_1s] == 8'h70) begin
                state <= S0;
                cnt_10ms <= 21'd0;
            end
            else if (mem[cnt_1s] == 8'h31) begin
                state <= S1;
                cnt_10ms <= 21'd0;
            end
            else if (mem[cnt_1s] == 8'h30) begin
                state <= S2;
                cnt_10ms <= 21'd0;
            end
        end
        S0: begin
            if (cnt_10ms == MAX_10MS - 2) begin
                state <= S3;
                cnt_10ms <= 21'd0;
            end
            else  begin
                cnt_10ms <= cnt_10ms + 21'd1;
            end

            if(cnt_10ms <= MAX_8MS)begin
                irig_b <= 1'b1;
            end
            else begin
                irig_b <= 1'b0;
            end
        end
        S1: begin
            if (cnt_10ms == MAX_10MS - 2) begin
                state <= S3;
                cnt_10ms <= 21'd0;
            end
            else  begin
                cnt_10ms <= cnt_10ms + 21'd1;
            end

            if(cnt_10ms <= MAX_5MS)begin
                irig_b <= 1'b1;
            end
            else begin
                irig_b <= 1'b0;
            end
        end
        S2: begin
            if (cnt_10ms == MAX_10MS - 2) begin
                state <= S3;
                cnt_10ms <= 21'd0;
            end
            else  begin
                cnt_10ms <= cnt_10ms + 21'd1;
            end

            if(cnt_10ms <= MAX_2MS)begin
                irig_b <= 1'b1;
            end
            else begin
                irig_b <= 1'b0;
            end
        end
        S3 : begin
            state <= IDLE;
            if (cnt_1s == 7'd100) begin
                cnt_1s <= 7'd1;       
            end
            else  begin
                cnt_1s <= cnt_1s + 7'd1;
            end
        end
    endcase
end

b_decoder b_decoder_1 (
    .clk(clk),
    .rst_n(rst_n),
    .irig_b(irig_b),
    .second_out(second_out),
    .minute_out(minute_out),
    .hour_out(hour_out),
    .day_out(day_out),
    .year_out(year_out)
);

endmodule

这个tb文件本质上是一个编码器。

仿真

连续两个p开始计数
在这里插入图片描述cnt_1s为68时，年的数据识别完成。
在这里插入图片描述

与雨渔遇鱼
关注
  • 9
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
B码解码的verilog代
04-03
B码解码的verilog代码，1M时钟
IRIG-B码Verilog实现思想
long258258的博客
03-10 2818
该图是B码完整图 由图可知B码是由100个单独码组成，我们可以将这100个码元分开传输； 1.8ms表示1个P ，5ms表示1 ，2ms表示0 2.可将一个码元表示为10ms，将码元按顺序发出； 3.发1000个码元也就是1s 4.将年、天、时、分、秒分别组成一个整码，移位发送； ...
FPGA实现IRIG-B（DC）码解码设计
最新发布
Xionq的博客
01-26 626
IRIG-B码是时间系统中常用的串行时间码，帧周期为1秒，包含100个码元。采用脉宽调制的方式，用不同宽度的脉冲来表示不同的码元，共有三种码元，分别为P码元、0码元、1码元，每个码元10ms。P码元对应脉冲宽度为8ms，0码元对应脉冲宽度为2ms，1码元对应脉冲宽度为5ms。连续两个P码元为整秒的开始，第二个P码元的上升沿为准时参考点，定义为Pr码元。对100个码元进行编号，分别定义为第0-99码元。
FPGA实现IRIG-B(DC)码编码和解码的设计
小跑
10-29 1万+
  [导读]为达到IRIG-B码与时间信号输入、输出的精确同步，采用现代化靶场的IRIG-B码编码和解码的原理，从工程的角度出发，提出了使用现场可编程门阵列(FPGA)来实现IRIG-B码编码和解码的设计方案和体系结构，设计中会涉及到几个不同的时钟频率，FPGA对时钟的同步性具有灵活性、效率高、且功耗低。抗干扰性好的特点。结果表明，FPGA能够确保为从设备提供同源的时钟基准，使时钟与信号的延迟控...
IRIG-B编码---GPS授时
chunlovenan的专栏
03-09 1万+
一、IRIG串行时间码格式简介简介： IRIG-B是每秒一帧的串行时间码，每个码元总宽度为10ms，一个时帧周期包括100个码元，为脉宽编码。每个码元又有3种码型：二进制0、1和位置标识符。分成3字段编码：第1字段为年时间（年、天、时、分、秒），第2字段为控制功能函数字段，第3字段为直接用二进制秒符号表示的一天中的时间信息，每24小时循环1次。码元的"准时"参考点是其脉冲前沿，时帧的参考
B码（直流）
qq_50534651的博客
07-18 1万+
B码
IRIG-B码对时
热门推荐
赛博朋客
09-08 1万+
前言：最近在学习IRIG-B码对时时一直对这个对时转换存在一些疑问，几乎在网上搜遍了资料也没有一个清晰的解答，最终直接使用一台时钟服务器、一台精准时间测试仪，进行IRIG-B测试，查看编码译码内容才对IRIG-B对时解析有了进一步地了解；接下来我针对我学习和动手操作后的理解，详细地讲一下IRIG-B码的解析过程。（若有不对的地方，欢迎指出，共同进步） 前奏： 首先了解下B码对时的定义：IRIG-B格式,简称B码，是将时间同步信号和秒、分、时、天等时间码信息加...
FPGA解析B码----连载8（完结篇）
weixin_45426095的博客
08-18 2294
FPGA解析B码的最后篇：UTC时间解析
FPGA解析B码----连载7（完结篇）
weixin_45426095的博客
08-17 2367
B码的FPGA的1PPS完整解析
FPGA解析B码----连载3
weixin_45426095的博客
08-03 1064
FPGA的B码解析
基于FPGA的MP3解码VERILOG源码
08-08
基于FPGA的MP3解码VERILOG源码
FPGA中Verilog 实现PAL视频
09-11
FPGA用Verilog 程序实现VGA视频转换为PAL制式视频输出
基于FPGA的HDB3编译码verilog实现+仿真操作录像
10-14
1.版本：vivado2019.2，我录制了仿真操作录像，可以跟着操作出仿真结果 2.领域：HDB3编译码 3.内容：纯verilog开发(可移植到ISE或者QII)，包括testbench，仿真得到编码和译码输出。 4.适合人群：本，硕等教研学习使用
基于FPGA的8b10b编解码verilog实现
07-12
本设计是采用EDA技术设计的一种8B /10B 编解码电路,实现了在高速的串行数据传输中的直流平衡。利用verilog HDL 逻辑设计语言，经过modelsim、quartus II的仿真和下载验证，实现其编码和解码的功能。 该编解码电路设计大体上可以由五个模块构成，分别是默认编码模块、差异度计算模块、编码校正模块、并串转换模块、显示模块。 采用Verilog HDL 描述、modelsim 10.2a 进行功能仿真、Quartus II 13.1 进行FPGA逻辑综合和适配下载，最后在Alter 公司的Cyclone IV E 的芯片EP4CE6F17C8 上实现并完成测试。 资源包中附有quartusII 的项目文件和代码,直接打开即可使用。
VHDL分频器
03-07
使用VHDL编写的分频器。主频率为50MHZ，进行分频后得到1HZ的时钟。
verilog实现B码（直流码）解码
09-06
verilog实现B码（直流码）解码，输出年、日、时、分、秒、毫秒，输出时间格式为BCD码，输出同步秒脉冲，同时根据秒脉冲生成毫秒。已在实际工程中应用。可直接拿来使用！
FPGA设计曼彻斯特编解码Verilog源代码修改版
04-21
FPGA设计曼彻斯特编解码Verilog源代码 module md (rst,clk16x,mdi,rdn,dout,data_ready) ; // input rst ; input clk16x ; input mdi ; input rdn ; output [7:0] dout ; output data_ready ; reg clk1x_enable ; ...
FPGA实现IRIG-B（DC）码编码和解码的设计
04-16
为达到IRIG-B码与时间信号输入、输出的精确同步，采用现代化靶场的IRIG-B码编码和解码的原理，从工程的角度出发，提出了使用现场可编程门阵列（FPGA）来实现IRIG-B码编码和解码的设计方案和体系结构，设计中会涉及到...
基于FPGA的8B10B编解码程序设计Verilog 开发
weixin_46018688的博客
06-01 1078
部分参考代码 (末尾附文件) module code8_10( input clk, input rst_n, input [7:0] i_data, input i_is_k, output reg [9:0] o_data ); reg dp_out; always@(posedge clk,negedge rst_n) begin if(~rst_n) {dp_out, o_data} <= 0; else {dp_out, o_data} <= dp_data_10
直流IRIG-B码解码
06-09
IRIG-B 是一种用于时间同步的常用格式之一，它采用二进制编码，可以用来传输时间信息。直流IRIG-B码是指在直流电路中传输IRIG-B编码的方式。 要解码直流IRIG-B码，需要使用一个解码器。解码器通常由一个电路和一些软件组成。电路用于接收直流IRIG-B码并将其转换为数字信号，而软件则用于解码数字信号并将其转换为可读的时间格式。 具体而言，解码器首先需要将接收到的直流IRIG-B码进行解调，以得到数字信号。然后，它需要对数字信号进行解码，以得到时间信息。解码过程中需要注意编码格式和时区等因素的影响。 总体而言，直流IRIG-B码解码需要一定的电子技术和计算机技术知识，需要掌握相关的硬件和软件技术。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值