FPGA——spi代码篇

最新推荐文章于 2024-08-30 09:25:30 发布
最新推荐文章于 2024-08-30 09:25:30 发布
阅读量1.4k 收藏 15
点赞数 30
文章标签： fpga开发 信息与通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66634995/article/details/135021167
版权

一、FPGA 开发SPI基础

        为了避免每次SPI驱动重写，直接参数化，尽量一劳永逸。SPI master有啥用呢，你发现各种外围芯片的配置一般都是通过SPI配置的，只不过有三线和四线。SPI slave有什么用呢，当外部主机（cpu）要读取FPGA内部寄存器值，那就很有用了，FPGA寄存器就相当于RAM，cpu通过SPI寻址读写数据。代码仅供参考，勿做商业用途。

二、SPI三线，四线区别

        三线制指的是CS，CLK，MOMI，是半双工方式；四线制指的是 CS，CLK，MOSI和MISO，是全双工方式。

三、SPI代码构思      

      1. SPI salve

                1.支持三线SPI或者四线SPI。通过define切换。                                 

                2.支持指令长度、帧长自定义。                               

                3.工作时钟可自定义，大于SPI clk的2倍。

        用户只需修改：（1）几线SPI。（2）单帧长度。（3）指令长度。（4）寄存器开辟。

        注意：指令最高bit表示读写，低写高读，其余bit表示地址。指令接着为数据端，两者位宽之和即为SPI单帧长。

//`define SPI_LINE  //是否是三线SPI
`define SPI_FRAME_WIDTH 16 //SPI一帧长度为16
`define SPI_INS_WIDTH 8    //SPI指令长
`timescale 1ns/1ps

module spi_slave 
(
    input     i_clk               , //work clk
    input     i_rst_n             ,  
  
    input     i_spi_clk           , //SPI clk
    input     i_spi_cs            , //SPI cs

    `ifdef SPI_LINE                 //条件编译
    inout     io_spi_sdio          
    `else
    input     i_spi_mosi          , //SPI mosi
    output    o_spi_miso            //SPI miso
    `endif          
);
//位宽计算函数
function integer clogb2 (input integer depth);
begin
    for (clogb2=0; depth>0; clogb2=clogb2+1) 
        depth = depth >>1;                          
end
endfunction
reg r_cs = 1'b1; //打一拍
always @(posedge i_clk)
begin
    r_cs <= i_spi_cs;
end
reg [1:0] r_spi_clk_edge = 2'b00; //SPI clk边沿检测
always @(posedge i_clk)
begin
    r_spi_clk_edge <= {r_spi_clk_edge[0],i_spi_clk};
end //always
reg [clogb2(`SPI_FRAME_WIDTH-1)-1:0] r_spi_cnt = 'd0;
always @(posedge i_clk)
begin
    if (r_cs) //cs为高则归零
        r_spi_cnt <= 'd0;
    else if (r_spi_clk_edge == 2'b10) //下降沿才计数
        r_spi_cnt <= r_spi_cnt + 'd1;
end
指令锁存
reg [`SPI_INS_WIDTH-1:0] r_ins = 'd0;
always @(posedge i_clk)
begin
    if ((~r_cs) && (r_spi_clk_edge == 2'b01)) //上升沿锁存数据
    begin
        if ((r_spi_cnt >= 0) && (r_spi_cnt <= `SPI_INS_WIDTH-1))
        `ifdef SPI_LINE                 //条件编译
            r_ins <= {r_ins[`SPI_INS_WIDTH-2:0],io_spi_sdio};  
        `else
            r_ins <= {r_ins[`SPI_INS_WIDTH-2:0],i_spi_mosi};  
        `endif 
    end 
end
数值写入
reg [`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1:0] r_data_rx = 'd0;
always @(posedge i_clk)
begin
    if ((~r_cs) && (r_spi_clk_edge == 2'b01)) //上升沿锁存数据
    begin
        if (r_spi_cnt >= `SPI_INS_WIDTH)
        `ifdef SPI_LINE
            r_data_rx <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],io_spi_sdio};
        `else
            r_data_rx <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],i_spi_mosi};   
        `endif
    end
end
用户寄存器定义
reg [`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1:0] r_reg0 = 'd0;
reg [`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1:0] r_reg1 = 'd0;
reg [`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1:0] r_reg2 = 'd0;
reg [`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1:0] r_reg3 = 'd0;

always @(posedge i_clk,negedge i_rst_n)
begin
    if (~i_rst_n)
    begin
        r_reg0 <= 'd0;
        r_reg1 <= 'd0;
        r_reg2 <= 'd0;
        r_reg3 <= 'd0;



    end
    else if ((~r_ins[`SPI_INS_WIDTH-1]) && (r_spi_cnt == (`SPI_FRAME_WIDTH-1)) && (~r_cs) && (r_spi_clk_edge == 2'b01))
    begin
    `ifdef SPI_LINE
        case (r_ins[`SPI_INS_WIDTH-2:0])
            'd0:begin r_reg0 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],io_spi_sdio}; end
            'd1:begin r_reg1 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],io_spi_sdio}; end
            'd2:begin r_reg2 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],io_spi_sdio}; end
            'd3:begin r_reg3 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],io_spi_sdio}; end




        endcase 
    `else
        case (r_ins[`SPI_INS_WIDTH-2:0])
            'd0:begin r_reg0 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],i_spi_mosi}; end
            'd1:begin r_reg1 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],i_spi_mosi}; end
            'd2:begin r_reg2 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],i_spi_mosi}; end
            'd3:begin r_reg3 <= {r_data_rx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],i_spi_mosi}; end




        endcase 
    `endif 
    end

end
寄存器值读出
reg [`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1:0] r_data_tx = 'd0;
always @(posedge i_clk)
begin
    if (r_ins[`SPI_INS_WIDTH-1] && (~r_cs) && (r_spi_clk_edge == 2'b10))
    begin 
        if (r_spi_cnt == (`SPI_INS_WIDTH-1))
        begin
            case (r_ins[`SPI_INS_WIDTH-2:0])
                'd0:begin r_data_tx <= r_reg0; end 
                'd1:begin r_data_tx <= r_reg1; end 
                'd2:begin r_data_tx <= r_reg2; end 
                'd3:begin r_data_tx <= r_reg3; end 
    
            endcase 
        end
        else 
            r_data_tx <= {r_data_tx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-2:0],1'b0};
    end 
end

读取输出
`ifdef SPI_LINE
assign io_spi_sdio = (r_ins[`SPI_INS_WIDTH-1]) ? (((r_spi_cnt>=`SPI_INS_WIDTH) && (r_spi_cnt<`SPI_FRAME_WIDTH)) ? r_data_tx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1] : 1'bz) : 1'bz;
`else 
assign o_spi_miso = ((r_spi_cnt>=`SPI_INS_WIDTH) && (r_spi_cnt<`SPI_FRAME_WIDTH)) ? r_data_tx[`SPI_FRAME_WIDTH-`SPI_INS_WIDTH-1] : 1'b0;
`endif

endmodule // end the spi_slave model

     2.SPI master

        spi master内部仅仅封装SPI驱动，写入值读出控制由上层控制，这部分逻辑很simple，不赘述。用户只需给入SPI帧及控制使能即可。

        用户只需修改parameter参数：（1）单帧长；（2）指令长；（3）数据长；（4）工作时钟；（5）SPI clk。

        实现不使用状态机，采用线性序列计数法。

//`define SPI_LINE  //是否是三线SPI
`timescale 1ns/1ps
module spi_master 
#(parameter p_spi_frame_width = 16, //SPI单帧长度
  parameter p_spi_ins_width = 8   , //指令长度
  parameter p_spi_data_width = 8    //读出数据长度
 )
(
    input                                i_clk             , //系统时钟
    input                                i_rst_n           ,
    input                                i_flag            , //检测到flag的上升沿则启动一次传输,一个时钟周期即可
   
    input     [p_spi_frame_width-1:0]    i_spi_data        ,
    output                               o_spi_cs          ,
    output                               o_spi_clk         ,

    `ifdef SPI_LINE                 //条件编译
    inout                                io_spi_sdio       ,          
    `else
    input                                i_spi_miso        , //SPI miso
    output                               o_spi_mosi        , //SPI mosi
    `endif 
    
    output                               o_transfer_done   , //单次传输完成
    output    [p_spi_data_width-1:0]     o_spi_data          //读取数据           
);
parameter p_clk_fre = 200; //XXM时钟频率
parameter p_spi_clk_fre = 0.5*1000; //SPI 时钟速率,表示1M
parameter p_clk_div = p_clk_fre * 1000/p_spi_clk_fre/2-1;
parameter p_spi_cnt_max = p_spi_frame_width*2-1;
parameter p_spi_ins_max = p_spi_ins_width*2-1;
//位宽计算函数
function integer clogb2 (input integer depth);
begin
    for (clogb2=0; depth>0; clogb2=clogb2+1) 
        depth = depth >>1;                          
end
endfunction
//把最大值赋值给线型，直接用p_clk_div仿真有问题，但实际上板是可以的
wire [clogb2(p_clk_div)-1:0] w_clk_div;
assign w_clk_div = p_clk_div;
时钟分频
reg [clogb2(p_clk_div)-1:0] r_cnt_div = 'd0;
always @(posedge i_clk)
begin
    if (r_cnt_div == w_clk_div)
        r_cnt_div <= 'd0;
    else 
        r_cnt_div <= r_cnt_div + 'd1;
end //always
wire w_clk_en; //分频时钟使能
assign w_clk_en = (r_cnt_div == w_clk_div) ? 1'b1 : 1'b0;
reg [1:0] r_flag_edge = 2'b00;
reg [clogb2(p_spi_cnt_max)-1:0] r_spi_cnt = 'd0;
always @(posedge i_clk) //flag边沿检测
begin
    r_flag_edge <= {r_flag_edge[0],i_flag};
end
//flag信号展宽到低速时钟域
reg r_flag_enlarge = 1'b0;
always @(posedge i_clk)
begin
    if (r_flag_edge == 2'b01) //上升沿拉高
        r_flag_enlarge <= 1'b1;
    else if (r_spi_cnt == p_spi_ins_max) //足够长的高电平才拉低
        r_flag_enlarge <= 1'b0;
end
reg [1:0] r_flag_enlarge_edge = 2'b00;
always @(posedge i_clk)
begin
    if (w_clk_en)
        r_flag_enlarge_edge <= {r_flag_enlarge_edge[0],r_flag_enlarge};
end
reg r_cs = 1'b1;
always @(posedge i_clk)
begin
    if (w_clk_en)
    begin
        if (r_flag_enlarge_edge == 2'b01) //检测到需要进行SPI操作
            r_cs <= 1'b0;
        else if (r_spi_cnt == p_spi_cnt_max) //计数到最大值表示一次SPI完成
            r_cs <= 1'b1;
    end
end
always @(posedge i_clk)
begin
    if (w_clk_en)
    begin
        if(~r_cs) //在操作区间计数
            r_spi_cnt <= r_spi_cnt + 'd1;
        else 
            r_spi_cnt <= 'd0;
    end    
end
数据传输段
reg [p_spi_frame_width-1:0] r_data = 'd0;
always @(posedge i_clk)
begin
    if (w_clk_en)
    begin
        if (r_flag_enlarge_edge == 2'b01) //上升沿刷入
            r_data <= i_spi_data;
        else if (r_spi_cnt[0] == 1'b1) //数据移动
            r_data <= {r_data[p_spi_frame_width-2:0],1'b1};
    end
end
数据读取段
reg [p_spi_data_width-1:0] r_data_read = 'd0;
always @(posedge i_clk)
begin
    if (w_clk_en)
    begin
        if (i_spi_data[p_spi_frame_width-1] && (r_spi_cnt > p_spi_ins_max) && (r_spi_cnt[0] == 1'b0)) //是读
        `ifdef SPI_LINE
            r_data_read <= {r_data_read[p_spi_data_width-2:0],io_spi_sdio};
        `else
            r_data_read <= {r_data_read[p_spi_data_width-2:0],i_spi_miso};
        `endif 
    end    
end
SPI输出段
assign o_spi_cs = r_cs;
assign o_spi_clk = r_cs ? 1'b0 : r_spi_cnt[0];
SPI SDIO的输入输出切换
`ifdef SPI_LINE
assign io_spi_sdio = (i_spi_data[p_spi_frame_width-1]) ? (((r_spi_cnt >= 'd0) && (r_spi_cnt <= p_spi_ins_max)) ? r_data[p_spi_frame_width-1] : 1'bz ) : r_data[p_spi_frame_width-1];
`else 
assign o_spi_mosi = r_data[p_spi_frame_width-1];
`endif 
assign o_transfer_done = ((~r_cs) && (r_spi_cnt == p_spi_cnt_max)) ? 1'b1:1'b0;
assign o_spi_data = r_data_read;

endmodule // end the spi_master model

        3.前仿真代码

 


`define DATA 8'ha5
//`define SPI_LINE
timeunit 1ns;
timeprecision 1ps;
module top;
parameter p_sim_end_time = 1000000; //ns
logic l_clk = 1'b0;
always #2.5 l_clk = ~l_clk;
复位
logic l_rst_n  = 1'b0;
initial begin
    #100 l_rst_n = 1'b1;
end


wire io_sdio;
wire o_spi_cs;
wire o_spi_clk;
wire o_transfer_done;
wire [7:0] o_spi_data;
多个数据操作模式
reg r_flag = 1'b0;
reg [1:0] r_first_cnt = 2'b00;
always @(posedge l_clk,negedge l_rst_n)
begin
    if (~l_rst_n)
        r_first_cnt <= 2'b00;
    else if (r_first_cnt == 2'd3)
        r_first_cnt <= r_first_cnt;
    else 
        r_first_cnt <= r_first_cnt + 2'd1;
end
reg [1:0] r_transfer_done_edge = 2'b00;
always @(posedge l_clk)
begin
    r_transfer_done_edge <= {r_transfer_done_edge[0],o_transfer_done};
end
reg [3:0] r_transfer_cnt = 4'd0;
always @(posedge l_clk)
begin
    if ((r_first_cnt == 2'd2) && (r_transfer_cnt < `TRANSFER_NUMBER))
        r_flag <= 1'b1;
    else if ((r_transfer_done_edge == 2'b10) && (r_transfer_cnt < `TRANSFER_NUMBER-1))
        r_flag <= 1'b1;
    else 
        r_flag <= 1'b0;        
end
always @(posedge l_clk)
begin
    if (r_transfer_done_edge == 2'b10)
        r_transfer_cnt <= r_transfer_cnt + 'd1;
end
reg [15:0] r_in_data  = 16'd0;
always @(*)
begin
    if (~l_rst_n) //仿真不执行此段仿真会有问题
        r_in_data  = 16'h0000;
    else 
    begin 
    case(r_transfer_cnt)
        4'd0:begin  r_in_data  = {8'h00,8'h43}; end 
        4'd1:begin  r_in_data  = 16'h0132; end 
        4'd2:begin  r_in_data  = 16'h0245; end 
        4'd3:begin  r_in_data  = 16'h0367; end 
        4'd4:begin  r_in_data  = 16'h8000; end 
        4'd5:begin  r_in_data  = 16'h8100; end 
        4'd6:begin  r_in_data  = 16'h8200; end 
        4'd7:begin  r_in_data  = 16'h8300; end 

        default:begin  r_in_data  = 16'h0000; end
    endcase
    end 
end

wire w_spi_miso;
wire w_spi_mosi;

spi_master inst_spi_master (
    .i_clk             (l_clk),
    .i_rst_n           (),
    .i_flag            (r_flag),
    .i_spi_data        (r_in_data),
    .o_spi_cs          (o_spi_cs),
    .o_spi_clk         (o_spi_clk),
    `ifdef SPI_LINE
    .io_spi_sdio       (io_sdio),
    `else
    .i_spi_miso        (w_spi_miso),
    .o_spi_mosi        (w_spi_mosi),
    `endif
    .o_transfer_done   (o_transfer_done),
    .o_spi_data        (o_spi_data)
    
);

spi_slave  inst_spi_slave (
    .i_clk                            (l_clk),
    .i_rst_n                          (l_rst_n),

    .i_spi_clk                        (o_spi_clk),
    .i_spi_cs                         (o_spi_cs),
    `ifdef SPI_LINE
    .io_spi_sdio                      (io_sdio)
    `else
    .i_spi_mosi                      (w_spi_mosi),
    .o_spi_miso                      (w_spi_miso)
    `endif

);

initial begin
    #p_sim_end_time $stop;
end

    
endmodule

SPI接口的FPGA实现（三）——Verilog代码实现SPI接口
mikusic的博客
12-24 7439
上一篇文章我们介绍了DAC81416的配置过程，这一篇我们就用Verilog代码具体实现这个过程，这一篇的代码具有普遍性，以后所有DA/AD的配置代码都可以在本文所展示的代码上进行简单的修改获得。文中我会分段详解代码，当然，先给出源代码链接。 ...
stm32——SPI入门学习
GS8FG的博客
08-05 574
SPI是串行外设接口（Serial Peripheral Interface）的缩写，是一种高速的，全双工同步的通信总 线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提 供方便，正是出于这种简单易用的特性，越来越多的芯片集成了这种通信协议，比如 AT91RM9200。
每天分享一个FPGA开源代码（1）- spi
最新发布
mengzaishenqiu的博客
08-30 869
SPI采用主从模式工作，有一个主设备（Master）控制一个或多个从设备（Slave），主设备负责生成时钟信号并发起数据传输。SCK空闲时为低电平，数据在SCK时钟的上升沿被采样，数据在SCK时钟的下降沿更新。SCK空闲时为高电平，数据在SCK时钟的下降沿被采样，数据在SCK时钟的上升沿更新。SCK空闲时为高电平，数据在SCK时钟的上升沿被采样，数据在SCK时钟的下降沿更新。SCK空闲时为低电平，数据在SCK时钟的下降沿被采样，数据在SCK时钟的上升沿切换。主设备数据输出线，数据由主设备发送给从设备。
【最通用版FPGA 实现 SPI 驱动】
weixin_44698673的博客
12-03 2157
最通用的SPI协议的FPGA实现
spi fpga verilog 代码
11-23
简单易懂的spi线，使用Verilog语言编写，里面代码分为spi_master.v ;spi_slave.v，并且有仿真环境及testbench代码，强调一点，只是作为快速理解spi总线的，若要用于工程项目的话，还需要添加其他代码，请自行添加。
FPGA SPI
小吕的博客
05-24 1213
module spi_ctrl( input wire sclk,//系统时钟 input wire rst_n, input wire work_en, output wire spi_clk, output wire spi_sdi, output wire spi_csn, input wire spi_sdo ); parameter IDLE = 5’b0_000...
SPI代码
weixin_43959743的博客
08-23 219
8/1上午的视频
FPGA实现SPI通信编写与实现（包含源代码和仿真）
热门推荐
icekoor的专栏
08-25 1万+
首先推荐大家直接去开源网站下载程序代码，直接搜索想要的代码，然后根据排名先后下载即可，程序一般都比较规范，标注也详细，学习起来不容易走弯路。测试代码选用nematoli/SPI-FPGA-VHDL，包含了主机程序、从机程序和激励文件（原有的不完整，后续了些内容），下面位程序的源代码，同时提供了modolsim仿真用的do文件。 ......
FPGA的SPI_master代码加上自己的理解.zip
07-18
FPGA的SPI的master模式的代码，很好使用，里面加上自己的理解。
FPGA ——TFT verilog代码
12-01
4. **接口适配**：根据TFT屏幕的具体接口（如SPI, RGB直连，LVDS等），Verilog代码需要实现相应的接口逻辑，以与屏幕进行通信。 5. **帧缓冲**：在FPGA内部可能需要一个帧缓冲区来存储待显示的图像数据。Verilog...
SPI接口的FPGA实现（一）——SPI接口的相关基础知识
mikusic的博客
12-10 4099
本文主要介绍SPI接口的一些基础知识，后续文章会用DAC芯片81416的配置为例来具体说明SPI接口的具体FPGA实现。 1.SPI基本结构 SPI的全称是Serial Peripheral 目录 1.SPI基本结构 Interface,直译过来就是串行外围接口。一般情况下，FPGA连接各种DAC和ADC，都是用的SPI接口。 这个接口是比较简单的接口。 ...
SPI 程序代码
12-05
LPC11C14 spi代码 LPC11C14 spi代码很详细
fpga实现spi接口
01-02
verilog实现的spi接口程序，功能仿真和时序仿真均通过。
SPI通信代码
12-10
把两个MCU的P1.2 P1.3 P1.4 P1.5分别同名端连接, 两个MCU分别连接两个PC串口A和B，就可以用串口助手测试了. 电脑串口A发给MCU-A, MCU-A把收到的数据通过SPI发给MCU-B, MCU-B从SPI接收到数据后,从串口发给电脑串口B.
SPI源码程序
10-29
此资源为SPI源码程序，适合初学者，配合我博客中的《SPI总线协议详解》，应该会很容易理解
SPI FPGA的实现
09-20
SPI FPGA.v的实现仿真,给初学人的一点参考，希望有所帮助
FPGA——UESTC.7z
05-09
《FPGA技术详解——以塞琳思7系列为例》 FPGA（Field-Programmable Gate Array），即现场可编程门阵列，是现代电子设计领域中的重要组件，广泛应用于通信、计算、图像处理等多个领域。本文将基于电子科技大学的教学...
智能垃圾桶fpga——可作为学期课设
12-07
智能垃圾桶项目基于FPGA的设计是一种将现代科技与环保理念相结合的创新实践，尤其适合作为学生们的学期课设。FPGA（Field-Programmable Gate Array）是可编程逻辑器件，能够灵活地实现各种数字电路设计，使得这个...
FPGA——SPI总线控制flash（2）（含代码）
居安士的博客
07-22 1761
用SPI总线控制flash读写，含代码，仿真解析
verilog三线spi
08-31
Verilog中的三线SPI是一种通过使用三个信号线进行通信的串行外设接口。与四线SPI相比，三线SPI的不同之处在于SDIO管脚需要进行三态控制。在Verilog中实现三线SPI，可以按照以下步骤进行： 1. 首先，需要根据具体芯片的时钟要求生成时钟信号。可以使用与上篇介绍的四线SPI相同的时钟产生方式。 2. 接下来，需要定义输入输出的信号线。与四线SPI相比，三线SPI中的SDI和SDO变成了内部逻辑信号，而SDIO则需要定义为inout类型，以实现三态控制。 3. 在Verilog代码中实现三线SPI的具体操作，可以参考上篇介绍的四线SPI的实现过程，并在此基础上添加三态转换控制。 通过以上步骤，就可以在Verilog中实现三线SPI的功能。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [5，ADC的SPI配置篇——Verilog实现3线SPI配置](https://blog.csdn.net/fpga_start/article/details/122418965)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我来挖坑啦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值