FPGA——spi代码篇

这篇具有很好参考价值的文章主要介绍了FPGA——spi代码篇。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

一、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.前仿真代码

 文章来源地址https://www.toymoban.com/news/detail-839679.html


`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

到了这里,关于FPGA——spi代码篇的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • FPGA主SPI与STM32从机通信

    目录 概述 FPGA的SPI主机代码 STM32从机 SPI模式配置 SPI参数设置  SPI的DMA传输配置 STM32从机SPI接收代码         不说一些SPI原理之类的废话,浪费空间。我使用的硬件环境为STM32F407VET6和DE0-nano,长什么样子如下图。  使用cubemx配置工程,FPGA使用Quartus软件,时序仿真图如下    

    2024年02月02日
    浏览(41)
  • FPGA——spi代码篇

            为了避免每次SPI驱动重写,直接参数化,尽量一劳永逸。SPI master有啥用呢,你发现各种外围芯片的配置一般都是通过SPI配置的,只不过有三线和四线。SPI slave有什么用呢,当外部主机(cpu)要读取FPGA内部寄存器值,那就很有用了,FPGA寄存器就相当于RAM,cpu通过

    2024年03月14日
    浏览(45)
  • 【LabVIEW FPGA入门】使用CompactRIO进行SPI和I2C通信

            NI提供了 SPI and I2C Driver API:下载SPI and I2C Driver API - NI         该API使用FPGA数字I / O线与SPI或I2C设备进行通信。         选择数字硬件时,要考虑三个选项: NI Single-Board RIO硬件可同时使用SPI和I2C驱动程序。 NI 9401 C系列模块与SPI驱动程序配合使用效果最佳。

    2024年02月02日
    浏览(59)
  • 基于SPI的FPGA-MCU通用通信界面设计与技术详解

    FPGA与MCU之间的通信想必是很多异构人极为头疼的难题。如果每次写一个工程都要大费周章重写通信逻辑、通信协议之类的东西,不仅耗费心神,而且浪费时间。本文基于安陆PH1A90SBG484,提出一个已经通过门级仿真验证的通用通信界面解决方案。详细代码见以下链接: Github代

    2024年02月04日
    浏览(50)
  • 【FPGA协议篇】UART通信及其verilog实现(代码采用传参实现模块通用性,适用于快速开发)

    ​ 即通用异步收发器(Universal Asynchronous Receiver/Transmitter),是一种 串行、异步、全双工 的通信协议。特点是通信线路简单,适用于远距离通信,但传输速度慢。 数据传输速率:波特率(单位:baud,波特) 常见波特率有:1200、2400、4800、19200、38400、57600等,最常用的是9600和11520

    2024年02月05日
    浏览(50)
  • 【FPGA开发】HDMI通信协议解析及FPGA实现

      笔者在这里使用的开发板是正点原子的达芬奇开发板,FPGA型号为XC7A35TFGG484-2。参考的课程是正点原子的课程手把手教你学达芬奇达芬奇Pro之FPGA开发篇。   HDMI,全称为High Definition Multimedia Interface,即高清多媒体接口。它不仅可以传输视频信号,还可以传输音频信号。上

    2024年02月21日
    浏览(48)
  • FPGA开发(2)——IIC通信

    IIC物理层框图如下图所示。 (1) 它是一个支持多设备的总线。“总线”指多个设备共用的信号线。在一个 I2C 通讯总线中,可连接多个 I2C 通讯设备,支持多个通讯主机及多个通讯从机。 (2) 一个 I2C 总线只使用两条总线线路,一条双向串行数据线(SDA) ,一条串行时钟线(SCL)。数

    2024年02月02日
    浏览(43)
  • FPGA双口RAM使用

    模块名称: dpram() IP Core 双口RAM,有俩组数据线和地址线,读写可以同时进行,FIFO读写可以同时进行,可以看作是双口。分为Simple two-dual RAM和true two-dual RAM。简单双口RAM,一个端口只读,另一个端口只写,且写入和读取的时钟可以不同,位宽比可以不是1:1;而双口RAM两个端口

    2024年02月16日
    浏览(42)
  • FPGA实现串口通信(RS232)含代码

    带有CH340的FPAG开发板 该模块的功能是接收通过 PC 机上的串口调试助手发送的固定波特率的数据,串口接收模块按照串口的协议准确接收串行数据,解析提取有用数据后需将其转化为并行数据;简单的说,接收模块的功能就是 解析+串转并 ; 具体实现步骤如下: 1、算出波特

    2024年02月02日
    浏览(56)
  • FPGA之分布RAM(1)

    SLICEM 资源可以实现分布式 RAM。可以实现的 RAM 类型: 单口 RAM 双端口 简单的双端口 四端口 下表给出了通过1SLICEM中的4个LUT可以实现的RAM类型         我们介绍过把 6 输入 LUT 当作 2 个 5输入 LUT 使用,在这里,就可以同一个 LUT 实现数据位宽的增加。对于32X2的4口RAM,如下图

    2024年01月20日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包