【FPGA】FPGA实现SPI协议读写FLASH（三）----- SPI读写控制模块设计

原创 已于 2024-11-01 11:12:35 修改 · 4.4k 阅读 · 43 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#fpga开发 #SPI #通信协议

于 2023-02-06 20:34:20 首次发布

SPI读写控制模块设计


写在前面：
FPGA实现通过SPI协议读写FLASH系列相关文章：
SPI通信协议
【FPGA】FPGA实现SPI协议读写FLASH（一）----- M25P16操作概述
【FPGA】FPGA实现SPI协议读写FLASH（二）----- SPI接口驱动模块设计
上篇文章介绍了SPI接口驱动模块的实现，本文将对SPI读写控制模块设计进行详细介绍；本项目中所使用的开发板型号：Cyclone IV E (EP4CE6F17C8)，FLASH型号：M25P16。

一、功能分析

本项目中SPI读写控制模块（flash_control）包含两个模块：flash写操作模块（flash_write)和flash读操作模块（flash_read)，主要实现如下功能：

  1. 接收PC端通过串口传输的数据，用FIFO缓存。
  2. 接收从SPI接口驱动模块读会的数据，用FIFO缓存，并通过串口发送至PC端显示。
  3. 控制SPI接口驱动模块进行读写操作以及数据传输顺序。
  4. 实现8字节数据页编程操作。

二、模块划分

SPI读写控制模块（flash_control）包含flash写操作模块（flash_write)和flash读操作模块（flash_read)，模块划分如下：
在这里插入图片描述

三、状态机设计

由于写操作过程有点复杂，如果用一个状态机实现，不利于代码阅读以及维护，因此写操作采用主从状态机方式实现。

1.flash_write模块

主状态机状态转移图：
在这里插入图片描述
主状态机状态说明：
IDLE：空闲状态，等待写请求。
WREN：写使能状态，发送写使能指令。
SE：擦除状态，发送擦除指令及地址。
RDSR：读状态寄存器状态，发送读状态寄存器指令，并判断返回的数据。
PP：页编程状态，发送页编程指令、地址和数据。

从状态机状态转移图：
在这里插入图片描述
从状态机状态说明：
IDLE：空闲状态，等待请求。
CMD：发送指令字节状态。
ADDR：发送地址字节状态。
DATA：发送数据字节状态。
DELAY：延时状态。

2.flash_read模块

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

状态说明：
IDLE：空闲状态，等待读请求。
RDID_CMD：发送读ID指令。
RDID_DATA：接收读回的ID数据。
RDDA_CMD：发送读数据指令。
RDDA_ADDR：发送读数据地址字节。
RDDA_DATA：接收读回的数据。
RD_DONE：读ID或读数据完成。

四、信号说明

1、flash_control模块信号说明

PortI/O TypeDescription
rdid_reqinput读ID请求
rdda_reqinput读数据请求
wr_reqinput写数据请求
rx_data[7:0]input串口接收要写入FLASH的数据
rx_data_vldinput串口接收数据有效标志
readyinputuart_tx模块可以传输数据标志
tx_data[7:0]output串口发送从FLASH读取的数据
tx_data_vldoutput串口发送数据有效标志
rdininputSPI接口模块读回的数据
rw_doneinput读写一字节数据完成标志
doutoutput发送给SPI接口模块要写的数据
reqoutput读写请求
display_id[23:0]output数码管显示读ID数据
display_id_vldoutput显示数据有效标志
modle[2:0]output读写模式 001:读ID 010：读数据 100：写数据

2、flash_write模块信号说明

PortI/O TypeDescription
wr_req]input写数据请求
wr_data[7:0]input要写入的数据
rw_doneinputSPI接口模块读写一字节完成标志
rdsr_data[7:0]inputSPI接口模块读回的状态寄存器数据
dout[7:0]output输出给SPI接口模块要发送的数据
reqoutput写请求
getdata_flagoutput取数据标志，输出给flash_control模块，标志拉高时从fifo中取要写入flash的数据

3、flash_read模块信号说明

PortI/O TypeDescription
rdid_reqinput读ID请求
rdda_reqinput读数据请求
rw_doneinputSPI接口模块读写一字节完成标志
rdin[7:0]inputSPI接口模块读回的数据
dout[7:0]output输出给SPI接口模块要发送的数据
reqoutput读写请求
rddata[23:0]output数码管显示ID
rddata_vldoutput显示数据有效标志

五、代码实现

1、flash_control模块

//  **************************************************************
//  Author: Zhang JunYi
//  Create Date: 2022.11.15                        
//  Design Name: spi_flash    
//  Module Name: flash_control        
//  Target Device: Cyclone IV E (EP4CE6F17C8), FLASH(M25P16)                
//  Tool versions: Quartus Prime 18.1             
//  Description: FLASH读写控制模块
//  **************************************************************
`include "param.v"
module flash_control (
    input           clk             ,
    input           rst_n           ,
    //  key_filter
    input           rdid_req        ,       //  读ID请求
    input           rdda_req        ,       //  读数据请求
    input           wr_req          ,       //  写数据请求
    //  uart_rx
    input   [7:0]   rx_data         ,       //  串口接收要写入FLASH的数据
    input           rx_data_vld     ,
    //  uart_tx
    input           ready           ,       //  ready
    output  [7:0]   tx_data         ,       //  串口发送从FLASH读取的数据
    output          tx_data_vld     ,
    //  spi_interface
    input   [7:0]   rdin            ,       //  SPI接口模块读回的数据
    input           rw_done         ,       //  读写一字节数据完成标志
    output  [7:0]   dout            ,       //  发送给SPI接口模块要写的数据
    output          req             ,       //  读写请求
    //  seg_driver
    output  [23:0]  display_id      ,       //  数码管显示读ID
    output          display_id_vld  ,
    output  [2:0]   modle                   //  读写模式 001:读ID 010：读数据  100：写数据
);
    //  信号定义
    //  u_flash_read
    wire    [23:0]  rddata          ;
    wire            rddata_vld      ;

    reg     [23:0]  read_data       ;       //  从SPI接口读回的数据寄存
    reg             read_data_vld   ;

    reg     [2:0]   rw_flag         ;

    reg     [7:0]   rd_data         ;       //  读回的8bit数据寄存
    reg             rd_data_vld     ;

    reg     [7:0]   write_data      ;       //  fifo读出的将要写入FLASH的数据

    wire            read_done       ;
    wire            write_done      ;
    wire            read_req        ;
    wire            write_req       ;
    wire    [7:0]   read_rdin       ;
    wire    [7:0]   write_rdin      ;
    wire    [7:0]   read_dout       ;
    wire    [7:0]   write_dout      ; 
    wire            getdata_flag    ;
    //  wrfifo
    wire    [7:0]   wrfifo_datain   ;
    wire            wrfifo_rdreq    ;
    wire            wrfifo_wrreq    ;
    wire            wrfifo_empty    ;
    wire            wrfifo_full     ;
    wire    [7:0]   wrfifo_q        ;
    wire    [2:0]   wrfifo_usedw    ;
    //  rdfifo
    wire    [7:0]   rdfifo_datain   ;
    wire            rdfifo_rdreq    ;
    wire            rdfifo_wrreq    ;
    wire            rdfifo_empty    ;
    wire            rdfifo_full     ;
    wire    [7:0]   rdfifo_q        ;
    wire    [2:0]   rdfifo_usedw    ;

    //  防止信号冲突
    assign  read_done = (rw_flag[0] | rw_flag[1]) ? rw_done : 1'b0 ;
    assign  write_done = rw_flag[2] ? rw_done : 1'b0 ;
    assign  req = (rw_flag[0] | rw_flag[1]) ? read_req : write_req ;
    assign  read_rdin = (rw_flag[0] | rw_flag[1]) ? rdin : 0 ;
    assign  write_rdin = rw_flag[2] ? rdin : 0 ;
    assign  dout = (rw_flag[0] | rw_flag[1]) ? read_dout : write_dout ;

    //  模块例化
    flash_read u_flash_read (
    /*input           */.clk             (clk           ),
    /*input           */.rst_n           (rst_n         ),
    /*//  key_filter*/  
    /*input           */.rdid_req        (rdid_req      ),       //  读ID请求
    /*input           */.rdda_req        (rdda_req      ),       //  读数据请求
    /*//  spi_interface*/   
    /*input           */.rw_done         (read_done     ),       //  SPI接口模块读写一字节完成标志
    /*input   [7:0]   */.rdin            (read_rdin     ),       //  SPI接口模块读回的数据
    /*output  [7:0]   */.dout            (read_dout     ),       //  输出给SPI接口模块要发送的数据
    /*output          */.req             (read_req      ),       //  读写请求
    
    /*output  [23:0]  */.rddata          (rddata        ),       //  数码管显示ID数据
    /*output          */.rddata_vld      (rddata_vld    )        //  数据有效标志
    );

    flash_write u_flash_write (
        /*input           */.clk             (clk       ),
        /*input           */.rst_n           (rst_n     ),
        /*//  key_filter*/
        /*input           */.wr_req          (wr_req    ),       //  写数据请求
        /*input   [7:0]   */.wr_data         (write_data),       //  写数据
        /*//spi_interface*/
        /*input           */.rw_done         (write_done),       //  SPI接口模块读写一字节完成标志
        /*input   [7:0]   */.rdsr_data       (write_rdin),       //  SPI接口模块读回的状态寄存器数据
        /*output  [7:0]   */.dout            (write_dout),       //  输出给SPI接口模块要发送的数据
        /*output          */.req             (write_req ),       //  写请求
        /*//  flash_control*/
        /*output          */.getdata_flag    (getdata_flag)
    );

    //  read_data
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            read_data <= 0 ;
            read_data_vld <= 0 ;
        end
        else if(rw_flag == 3'b001 && rddata_vld)begin
            read_data <= rddata ;
            read_data_vld <= rddata_vld ;
        end
        else if(rw_flag == 3'b010 && rddata_vld)begin
            read_data[7:0] <= rddata ;
            read_data_vld <= rddata_vld ;
        end
        else begin
            read_data <= 0 ;
            read_data_vld <= 0 ;
        end
    end

    //  rw_flag
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            rw_flag <= 0 ;
        end
        else if(rdid_req)begin
            rw_flag <= 3'b001 ;
        end
        else if(rdda_req)begin
            rw_flag <= 3'b010 ;
        end
        else if(wr_req)begin
            rw_flag <= 3'b100 ;
        end
    end

    //  rd_data rd_data_vld
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            rd_data <= 0 ;
            rd_data_vld <= 0 ;
        end
        else if(rw_flag[1])begin
            rd_data <= read_data[7:0] ;
            rd_data_vld <= read_data_vld ;
        end
    end

    //  write_data
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            write_data <= 0 ;
        end
        else if(wrfifo_empty)begin
            write_data <= 0 ;
        end
        else begin
            write_data <= wrfifo_q ;
        end
    end

    //  wrfifo
    wrfifo	wrfifo_inst (
	    .aclr       ( ~rst_n        ),
	    .clock      ( clk           ),
	    .data       ( wrfifo_datain ),
	    .rdreq      ( wrfifo_rdreq  ),
	    .wrreq      ( wrfifo_wrreq  ),

	    .empty      ( wrfifo_empty  ),
	    .full       ( wrfifo_full   ),
	    .q          ( wrfifo_q      ),
	    .usedw      ( wrfifo_usedw  )
	);
    assign  wrfifo_datain = rx_data ;
    assign  wrfifo_wrreq = rx_data_vld && ~wrfifo_full ;
    assign  wrfifo_rdreq = getdata_flag && write_done && ~wrfifo_empty ;   // getdata_flag取数据标志拉高时，写完一字节数据再从FIFO中读取下一字节数据
    // rdfifo
    rdfifo	rdfifo_inst (
	    .aclr       ( ~rst_n        ),
	    .clock      ( clk           ),
	    .data       ( rdfifo_datain ),
	    .rdreq      ( rdfifo_rdreq  ),
	    .wrreq      ( rdfifo_wrreq  ),

	    .empty      ( rdfifo_empty  ),
	    .full       ( rdfifo_full   ),
	    .q          ( rdfifo_q      ),  
	    .usedw      ( rdfifo_usedw  )
	);
    assign  rdfifo_datain = rd_data ;
    assign  rdfifo_wrreq = rd_data_vld ;
    assign  rdfifo_rdreq =  ~rdfifo_empty && ready ;

    //  输出
    assign  display_id = (rw_flag[0] && read_data_vld) ? read_data : 0 ;
    assign  display_id_vld = read_data_vld ;
    assign  modle = rw_flag ;
    assign  tx_data = rdfifo_q ;
    assign  tx_data_vld = rdfifo_rdreq ;

endmodule

2、flash_write模块

//  **************************************************************
//  Author: Zhang JunYi
//  Create Date: 2022.11.15                        
//  Design Name: spi_flash    
//  Module Name: flash_write         
//  Target Device: Cyclone IV E (EP4CE6F17C8), FLASH(M25P16)                
//  Tool versions: Quartus Prime 18.1             
//  Description: SPI写FLASH模块
//  **************************************************************
`include "param.v"
module flash_write (
    input           clk             ,
    input           rst_n           ,
    //  key_filter
    input           wr_req          ,       //  写数据请求
    input   [7:0]   wr_data         ,       //  写数据
    //  flash_control
    input           rw_done         ,       //  SPI接口模块读写一字节完成标志
    input   [7:0]   rdsr_data       ,       //  SPI接口模块读回的状态寄存器数据
    output  [7:0]   dout            ,       //  输出给SPI接口模块要发送的数据
    output          req             ,       //  写请求
    output          getdata_flag            //  取数据标志，输出给flash_control模块，标志拉高时从fifo中取要写入flash的数据
);
    //  参数定义
    //  主状态机状态
    localparam  M_IDLE  =   5'b00001 ,      //  空闲状态
                M_WREN  =   5'b00010 ,      //  写使能
                M_SE    =   5'b00100 ,      //  擦除
                M_RDSR  =   5'b01000 ,      //  读状态寄存器
                M_PP    =   5'b10000 ;      //  页编程
    //  从状态机状态
    localparam  S_IDLE  =   5'b00001 ,      //  空闲状态
                S_CMD   =   5'b00010 ,      //  发送指令
                S_ADDR  =   5'b00100 ,      //  发送地址
                S_DATA  =   5'b01000 ,      //  发送/接收数据
                S_DELAY =   5'b10000 ;      //  延时

    //  信号定义
    reg     [4:0]       m_state_c       ;
    reg     [4:0]       m_state_n       ;

    reg     [4:0]       s_state_c       ;
    reg     [4:0]       s_state_n       ;

    reg     [3:0]       byte_num        ;       //  字节数
    reg     [3:0]       cnt_byte        ;       //  字节计数器
    wire                add_cnt_byte    ;
    wire                end_cnt_byte    ;

    reg     [27:0]      delay           ;       //  延时
    reg     [27:0]      cnt_delay       ;       //  延时计数器
    wire                add_cnt_delay   ;
    wire                end_cnt_delay   ;

    reg     [7:0]       wr_data_r       ;       //  写数据寄存
    reg     [7:0]       command         ;       //  指令寄存
    reg                 wip             ;       //  设置为1时，表示设备处于工作状态，当设置为0时，表示设备处于空闲状态
    reg                 wel             ;       //  当设置为1时，内部写使能被设置，当设置为0时，表示没有接收写状态寄存器，页编程或擦除指令
    reg     [7:0]       dout_data       ;       //  输出数据寄存
    reg                 wr_flag         ;       //  输出给SPI接口模块请求信号寄存
    reg     [1:0]       wren_flag       ;       //  写使能标志，区分m_rdsr2m_idle和m_rdsr2m_wren
    reg                 data_flag       ;       //  从flash_control模块取数据标志寄存

    //  主状态机状态转移条件
    wire                m_idle2m_wren   ; 
    wire                m_wren2m_se     ; 
    wire                m_wren2m_pp     ; 
    wire                m_se2m_rdsr     ; 
    wire                m_rdsr2m_pp     ; 
    wire                m_rdsr2m_idle   ; 
    wire                m_rdsr2m_wren   ; 
    wire                m_pp2m_rdsr     ; 
    //  从状态机状态转移条件
    wire                s_idle2s_cmd    ;
    wire                s_cmds_addr     ;
    wire                s_cmd2s_data    ;
    wire                s_cmd2s_delay   ;
    wire                s_addr2s_data   ;
    wire                s_addr2s_delay  ;
    wire                s_data2s_delay  ;
    wire                s_delay2s_idle  ;

/************************主状态机开始****************************/
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            m_state_c <= M_IDLE ;
        end
        else begin
            m_state_c <= m_state_n ;
        end
    end
    always @(*)begin
        case (m_state_c)
            M_IDLE: begin
                if(m_idle2m_wren)
                    m_state_n = M_WREN ;
                else
                    m_state_n = m_state_c ;
            end
            M_WREN: begin
                if(m_wren2m_se)
                    m_state_n = M_SE ;
                else if(m_wren2m_pp)
                    m_state_n = M_PP ;
                else
                    m_state_n = m_state_c ;
            end
            M_SE: begin
                if(m_se2m_rdsr)
                    m_state_n = M_RDSR ;
                else
                    m_state_n = m_state_c ;
            end
            M_RDSR: begin
                if(m_rdsr2m_pp)
                    m_state_n = M_PP ;
                else if(m_rdsr2m_idle)
                    m_state_n = M_IDLE ;
                else if(m_rdsr2m_wren)
                    m_state_n = M_WREN ;
                else
                    m_state_n = m_state_c ;
            end
            M_PP: begin
                if(m_pp2m_rdsr)
                    m_state_n = M_RDSR ;
                else
                    m_state_n = m_state_c ;
            end
            default: m_state_n = M_IDLE ;
        endcase
    end
    //  状态转移条件
    assign  m_idle2m_wren = m_state_c == M_IDLE && wr_req ;       //  收到写请求，进入写使能状态
    assign  m_wren2m_se   = m_state_c == M_WREN && s_delay2s_idle && ~wren_flag[0] ;    //   写使能延时结束，进入擦除状态 
    assign  m_wren2m_pp   = m_state_c == M_WREN && s_delay2s_idle && wren_flag[0] ;     //   写使能延时结束，进入页编程状态 
    assign  m_se2m_rdsr   = m_state_c == M_SE   && s_delay2s_idle ;     //   擦除延时结束，进入读状态寄存器状态
    assign  m_rdsr2m_pp   = m_state_c == M_RDSR && s_delay2s_idle && wip == 1'b0 && wel == 1'b1 ;   //   读状态寄存器wel位为高电平，直接跳转到页编程状态
    assign  m_rdsr2m_idle = m_state_c == M_RDSR && s_delay2s_idle && wel == 1'b0 && wip == 1'b0 && wren_flag[1] ;   //  一次写操作结束，回到空闲状态
    assign  m_rdsr2m_wren = m_state_c == M_RDSR && s_delay2s_idle && wel == 1'b0 && wip == 1'b0 && wren_flag[0] ;   //  wel为低电平，进入写使能状态
    assign  m_pp2m_rdsr   = m_state_c == M_PP   && s_delay2s_idle ;     //   页编程延时结束，进入读状态寄存器状态  
/************************主状态机结束****************************/

/************************从状态机开始****************************/
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            s_state_c <= S_IDLE ;
        end
        else begin
            s_state_c <= s_state_n ;
        end
    end
    always @(*)begin
        case (s_state_c)
            S_IDLE: begin
                if(s_idle2s_cmd)
                    s_state_n = S_CMD ;
                else
                    s_state_n = s_state_c ;
            end
            S_CMD: begin
                if(s_cmds_addr)
                    s_state_n = S_ADDR ;
                else if(s_cmd2s_data)
                    s_state_n = S_DATA ;
                else if(s_cmd2s_delay)
                    s_state_n = S_DELAY ;
                else
                    s_state_n = s_state_c ;
            end
            S_ADDR: begin
                if(s_addr2s_data)
                    s_state_n = S_DATA ;
                else if(s_addr2s_delay)
                    s_state_n = S_DELAY ;
                else
                    s_state_n = s_state_c ;
            end
            S_DATA: begin
                if(s_data2s_delay)
                    s_state_n = S_DELAY ;
                else
                    s_state_n = s_state_c ;
            end
            S_DELAY: begin
                if(s_delay2s_idle)
                    s_state_n = S_IDLE ;
                else
                    s_state_n = s_state_c ;
            end
            default: s_state_n = S_IDLE ;
        endcase
    end
    assign  s_idle2s_cmd    =   s_state_c == S_IDLE  && m_state_c != M_IDLE ;       //  主状态机非空闲状态下，从状态机进入发送指令状态
    assign  s_cmds_addr     =   s_state_c == S_CMD   && (m_state_c == M_SE || m_state_c == M_PP) && cnt_byte == 1 ;      //     主状态机擦除和页编程状态下，指令发送完成，进入发送地址状态  
    assign  s_cmd2s_data    =   s_state_c == S_CMD   && m_state_c == M_RDSR && cnt_byte == 1 ;      //      主状态机读状态寄存器状态下，指令发送完成，进入接收状态寄存器数据状态
    assign  s_cmd2s_delay   =   s_state_c == S_CMD   && m_state_c == M_WREN && end_cnt_byte ;       //      主状态机写使能指令发送完成，进入延时状态
    assign  s_addr2s_data   =   s_state_c == S_ADDR  && m_state_c == M_PP && cnt_byte == 4 ;        //      主状态机页编程状态下，地址发送完成，进入发送数据状态
    assign  s_addr2s_delay  =   s_state_c == S_ADDR  && m_state_c == M_SE && end_cnt_byte ;     //     主状态机擦除状态下，地址发送完成，进入延时状态
    assign  s_data2s_delay  =   s_state_c == S_DATA  && (m_state_c == M_PP || m_state_c == M_RDSR) && end_cnt_byte ;     //     主状态机页编程状态下，数据发送完成，进入延时状态
    assign  s_delay2s_idle  =   s_state_c == S_DELAY && end_cnt_delay ;     //  延时结束，回到空闲状态
/************************从状态机结束****************************/

    //  wr_data_r
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            wr_data_r <= 0 ;
        end
        else if(data_flag)begin     //  取数据标志拉高，寄存要写入flash的数据
            wr_data_r <= wr_data ;
        end
        else if(m_rdsr2m_idle)begin
            wr_data_r <= 0 ;
        end
    end

    //  command
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            command <= 0 ;
        end
        else if(m_idle2m_wren | m_rdsr2m_wren)begin     
            command <= `CMD_WREN ;      //  写使能指令
        end
        else if(m_wren2m_se)begin
            command <= `CMD_SE ;        //  擦除指令
        end
        else if(m_se2m_rdsr | m_pp2m_rdsr)begin
            command <= `CMD_RDSR ;      //  读状态寄存器指令
        end
        else if(m_wren2m_pp | m_rdsr2m_pp)begin
            command <= `CMD_PP ;        //  页编程指令
        end
    end

    //  byte_num
    always @(*)begin
        case (m_state_c)
            M_WREN: byte_num = 1 ; 
            M_SE  : byte_num = 4 ; 
            M_RDSR: byte_num = 2 ; 
            M_PP  : byte_num = 12 ;     //  页编程8byte数据 1bytePP指令字节+3byte地址字节+8byte数据字节
            default: byte_num = 0 ;
        endcase
    end

    //  cnt_byte
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt_byte <= 0 ;
        end
        else if(add_cnt_byte)begin
            if(end_cnt_byte)begin
                cnt_byte <= 0 ;
            end				
            else begin	    
                cnt_byte <= cnt_byte + 1 ;
            end 		    
        end
    end
    assign	add_cnt_byte = rw_done ;    //  读写一字节数据完成，字节计数器+1
    assign	end_cnt_byte = add_cnt_byte && (cnt_byte == byte_num - 1) ;

    //  delay
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            delay <= 0 ;
        end
        else if(m_wren2m_se)begin
            delay <= `DELAY_SE ;    //  擦除延时
        end
        else if(m_wren2m_pp | m_rdsr2m_pp)begin
            delay <= `DELAY_PP ;    //  页编程延时
        end
        else if(m_idle2m_wren | m_se2m_rdsr | m_rdsr2m_wren | m_pp2m_rdsr)begin
            delay <= `DELAY_CSH ;   //  指令间延时
        end
        else if(m_rdsr2m_idle)begin
            delay <= 0 ;
        end
    end

    //  cnt_delay
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt_delay <= 0 ;
        end
        else if(add_cnt_delay)begin
            if(end_cnt_delay)begin
                cnt_delay <= 0 ;
            end				
            else begin	    
                cnt_delay <= cnt_delay + 1 ;
            end 		    
        end
    end
    assign	add_cnt_delay = s_state_c == S_DELAY ;
    assign	end_cnt_delay = add_cnt_delay && (cnt_delay == delay - 1) ;

    //  wip,wel
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            wip <= 0 ;
            wel <= 0 ;
        end
        else begin
            wip <= rdsr_data[0] ;   //  设置为1时，表示设备处于工作状态，当设置为0时，表示设备处于空闲状态
            wel <= rdsr_data[1] ;   //  当设置为1时，内部写使能被设置，当设置为0时，表示没有接收写状态寄存器，页编程或擦除指令
        end
    end

    //  dout_data
    always @(*)begin
        if(m_state_c == M_WREN)begin   //  发送写使能指令
            dout_data = `CMD_WREN ;
        end
        else if(m_state_c == M_SE && s_state_c != S_DELAY)begin   //  发送擦除指令和地址
            case (cnt_byte)
                0: dout_data = `CMD_SE ;
                1: dout_data = `ADDR_HIGH ;
                2: dout_data = `ADDR_MID ;
                3: dout_data = `ADDR_LOW ;
                default: dout_data = 0 ;
            endcase
        end
        else if(m_state_c == M_RDSR)begin   //  发送读状态寄存器指令
            dout_data = `CMD_RDSR ;
        end
        else if(m_state_c == M_PP&& s_state_c != S_DELAY)begin   //  发送页编程指令、地址、数据
            case (cnt_byte)
                0: dout_data = `CMD_PP ;
                1: dout_data = `ADDR_HIGH ;
                2: dout_data = `ADDR_MID ;
                3: dout_data = `ADDR_LOW ;
                // 4: dout_data = wr_data_r ;   //  单字节写操作
                default: dout_data = wr_data_r ;// dout_data = 0 ;
            endcase
        end
        else begin
            dout_data = 0 ;
        end
    end

    //  wr_flag
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            wr_flag <= 1'b0 ;
        end
        else if(s_state_c == S_CMD || s_state_c == S_ADDR || s_state_c == S_DATA)begin
            wr_flag <= 1'b1 ;
        end
        else begin
            wr_flag <= 1'b0 ;
        end
    end

    //  wren_flag
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            wren_flag <= 2'b00 ;
        end
        else if(m_wren2m_se)begin
            wren_flag <= 2'b01 ;
        end
        else if(m_pp2m_rdsr)begin
            wren_flag <= 2'b10 ;
        end
    end

    //  data_flag
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            data_flag <= 1'b0 ;
        end
        else if(m_state_c == M_PP && cnt_byte > 3)begin     //  页编程状态下，发送完指令和地址字节后，取数据标志拉高
            data_flag <= 1'b1 ;
        end
        else begin
            data_flag <= 1'b0 ;
        end
    end

    //  输出
    assign dout = dout_data ;
    assign req = wr_flag ;
    assign getdata_flag = data_flag ;


endmodule

3、flash_read模块

//  **************************************************************
//  Author: Zhang JunYi
//  Create Date: 2022.11.15                        
//  Design Name: spi_flash    
//  Module Name: flash_read         
//  Target Device: Cyclone IV E (EP4CE6F17C8), FLASH(M25P16)                
//  Tool versions: Quartus Prime 18.1             
//  Description: SPI读FLASH模块
//  **************************************************************
`include "param.v"
module flash_read (
    input           clk             ,
    input           rst_n           ,
    //  key_filter
    input           rdid_req        ,       //  读ID请求
    input           rdda_req        ,       //  读数据请求
    //  flash_control
    input           rw_done         ,       //  SPI接口模块读写一字节完成标志
    input   [7:0]   rdin            ,       //  SPI接口模块读回的数据   
    output  [7:0]   dout            ,       //  输出给SPI接口模块要发送的数据
    output          req             ,       //  读写请求
    output  [23:0]  rddata          ,       //  数码管显示ID
    output          rddata_vld              //  数据有效标志
);

    //  参数定义
    //  读数据状态机参数定义
    parameter   IDLE        = 7'b000_0001   ,
                RDID_CMD    = 7'b000_0010   ,   //  发送读ID命令
                RDID_DATA   = 7'b000_0100   ,   //  接收读回ID数据
                RDDA_CMD    = 7'b000_1000   ,   //  发送读数据命令    
                RDDA_ADDR   = 7'b001_0000   ,   //  发送读数据地址
                RDDA_DATA   = 7'b010_0000   ,   //  接收读回数据
                RD_DONE     = 7'b100_0000   ;

    //  信号定义
    reg     [6:0]       state_c             ;
    reg     [6:0]       state_n             ;

    reg     [3:0]       cnt_byte            ;       //  字节计数器
    wire                add_cnt_byte        ;
    wire                end_cnt_byte        ;

    reg     [3:0]       byte_num            ;       //  字节数
    reg     [7:0]       dout_data           ;       //  输出数据寄存
    reg                 rw_req              ;       //  读写请求
    reg                 rd_flag             ;       //  读数据模式 0:读ID  1:读数据
    reg     [23:0]      rd_data             ;       //  读回的数据寄存
    reg                 rd_data_vld         ;       //  读回的数据有效标志寄存
    reg                 done                ;       //  rw_done寄存
    //  状态转移条件
    wire                idle2rdidcmd        ;
    wire                idle2rddacmd        ;
    wire                rdidcmd2rdiddata    ;
    wire                rddacmd2rddaaddr    ;
    wire                rddaaddr2rddadata   ;
    wire                rdiddata2rddone     ;
    wire                rddadata2rddone     ;
    wire                rddone2idle         ;

    //  状态机
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            state_c <= IDLE ;
        end
        else begin
            state_c <= state_n ;
        end
    end
    always @(*)begin
        case (state_c)
            IDLE: begin
                if(idle2rdidcmd)
                    state_n = RDID_CMD ;
                else if(idle2rddacmd)
                    state_n = RDDA_CMD ;
                else 
                    state_n = state_c ;
            end
            RDID_CMD: begin
                if(rdidcmd2rdiddata)
                    state_n = RDID_DATA ;
                else 
                    state_n = state_c ;
            end
            RDID_DATA: begin
                if(rdiddata2rddone)
                    state_n = RD_DONE ;
                else 
                    state_n = state_c ;
            end
            RDDA_CMD: begin
                if(rddacmd2rddaaddr)
                    state_n = RDDA_ADDR ;
                else 
                    state_n = state_c ;
            end 
            RDDA_ADDR: begin
                if(rddaaddr2rddadata)
                    state_n = RDDA_DATA ;
                else 
                    state_n = state_c ;
            end
            RDDA_DATA: begin
                if(rddadata2rddone)
                    state_n = RD_DONE ;
                else 
                    state_n = state_c ;
            end
            RD_DONE: begin
                if(rddone2idle)
                    state_n = IDLE ;
                else 
                    state_n = state_c ;
            end
            default: state_n = IDLE ;
        endcase
    end
    //  状态转移条件
    assign idle2rdidcmd        = state_c == IDLE        && rdid_req     ;   //  读ID请求拉高，进入发送读ID指令状态
    assign idle2rddacmd        = state_c == IDLE        && rdda_req     ;   //  读数据请求拉高，进入发送读数据指令状态
    assign rdidcmd2rdiddata    = state_c == RDID_CMD    && end_cnt_byte ;   //  读ID指令发送完成，进入接收ID数据状态
    assign rddacmd2rddaaddr    = state_c == RDDA_CMD    && end_cnt_byte ;   //  读数据指令发送完成，进入发送读地址状态
    assign rddaaddr2rddadata   = state_c == RDDA_ADDR   && end_cnt_byte ;   //  读地址发送完成，进入接收数据状态
    assign rdiddata2rddone     = state_c == RDID_DATA   && end_cnt_byte ;   //  读ID数据完成
    assign rddadata2rddone     = state_c == RDDA_DATA   && end_cnt_byte ;   //  读数据完成
    assign rddone2idle         = state_c == RD_DONE     && (1'b1)       ;   

    //  rd_flag
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            rd_flag <= 1'b1 ;
        end
        else if(rdid_req)begin
            rd_flag <= 1'b0 ;
        end
        else if(rdda_req | rddone2idle)begin
            rd_flag <= 1'b1 ;
        end    
    end

    //  byte_num
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            byte_num <= 0 ;
        end
        else if(rd_flag)begin       //  读数据模式
            case (state_c)
                RDDA_CMD : byte_num <= 1 ;
                RDDA_DATA : byte_num <= 8 ;
                RDDA_ADDR : byte_num <= 3 ;
                default: byte_num <= 0 ;
            endcase
            // if(state_c == RDDA_CMD)begin
            //     byte_num <= 1 ;
            // end
            // else if(state_c == RDDA_DATA)begin
            //     byte_num <= 8 ;
            // end
            // else if(state_c == RDDA_ADDR)begin
            //     byte_num <= 3 ;
            // end
            // else begin
            //     byte_num <= 0 ;
            // end
        end
        else if(~rd_flag)begin       //  读ID模式
            case (state_c)
                RDID_CMD : byte_num <= 1 ;
                RDID_DATA : byte_num <= 3 ;
                default: byte_num <= 0 ;
            endcase
            // if(state_c == RDID_CMD)begin
            //     byte_num <= 1 ;
            // end
            // else if(state_c == RDID_DATA)begin
            //     byte_num <= 3 ;
            // end
            // else begin
            //     byte_num <= 0 ;
            // end
        end
    end

    //  cnt_byte
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            cnt_byte <= 0 ;
        end
        else if(add_cnt_byte)begin
            if(end_cnt_byte)begin
                cnt_byte <= 0 ;
            end
            else begin
                cnt_byte <= cnt_byte + 1 ;
            end
        end
    end
    assign add_cnt_byte = done ;    //  读写一字节数据完成，字节计数器+1
    assign end_cnt_byte = add_cnt_byte && (cnt_byte == byte_num - 1) ;

    //  dout_data
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            dout_data <= 0 ;
        end
        else if(state_c == RDID_CMD)begin   //  输出读ID指令
            dout_data <= `CMD_RDID ;    
        end
        else if(state_c == RDDA_CMD)begin
            dout_data <= `CMD_RDDA ;        //  输出读数据指令
        end
        else if(state_c == RDDA_ADDR)begin  //  输出地址字节
            case (cnt_byte)
                0: dout_data <= `ADDR_HIGH ;
                1: dout_data <= `ADDR_MID  ;
                2: dout_data <= `ADDR_LOW  ;
                default: dout_data <= dout_data ;
            endcase
        end
        else begin
            dout_data <= 0 ;
        end
    end

    //  rw_req
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            rw_req <= 1'b0 ;
        end
        else if(idle2rdidcmd | idle2rddacmd)begin
            rw_req <= 1'b1 ;
        end
        else if(rdiddata2rddone | rddadata2rddone)begin
            rw_req <= 1'b0 ;
        end
    end

    //  rd_data
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            rd_data <= 0 ;
        end
        else if((state_c == RDID_DATA || state_c == RD_DONE) && done)begin  //  接收ID数据
            rd_data[23 - 8 * cnt_byte -:8] <= rdin ;
        end
        else if((state_c == RDDA_DATA || state_c == RD_DONE) && done)begin  //  接收数据
            rd_data <= rdin ;
        end
        else if(rddone2idle)begin
            rd_data <= 0 ;
        end
        else begin
            rd_data <= rd_data ;
        end
    end

    //  done
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            done <= 1'b0 ;
        end
        else if(rw_done)begin
            done <= 1'b1 ;
        end
        else begin
            done <= 1'b0 ;
        end
    end

    //  rd_data_vld
    always @(posedge clk or negedge rst_n)begin
        if(!rst_n)begin
            rd_data_vld <= 1'b0 ;
        end
        else if(state_c == RDDA_DATA && done)begin
            rd_data_vld <= 1'b1 ;
        end
        else begin
            rd_data_vld <= 1'b0 ;
        end
    end

    //  输出
    assign  dout = dout_data ;
    assign  req  = rw_req ;
    assign  rddata = rd_data ;
    assign  rddata_vld = (state_c == RDDA_DATA) ? rd_data_vld : rddone2idle ;

endmodule

六、仿真测试

1、写数据仿真
在这里插入图片描述
在这里插入图片描述

2、读ID仿真
在这里插入图片描述
3、读数据仿真
在这里插入图片描述

SPI协议读取FLASH【FPGA】
xyf_fate的博客
09-14 5305
spi_flash
基于FPGA的串行flash的读写控制
08-04
基于FPGA的串行flash的读写控制之串行flash的管脚、寄存器和操作命令。
基于FPGA的Flash读写（FPGA自主升级流程）
最新发布
2301_80286903的博客
06-25 458
在嵌入式系统和物联网设备中，​​已成为刚性需求。传统依赖外部处理器（如MCU）管理Flash存储的方案存在响应延迟高、资源占用大等瓶颈。而​​通过硬件逻辑直连存储设备，可实现微秒级擦写操作，并利用FPGA动态重构特性实现“自举式升级”——即FPGA通过自身逻辑完成新固件的接收、校验与烧录，无需外部干预。以航天设备为例，其存储系统需在极端环境下（高过载、强辐射）保持可靠性。FPGA的并行处理能力和抗干扰特性，结合双Bank存储切换机制，可在升级失败时自动回退至旧版本，显著提升系统鲁棒性。
FPGA实现Flash读写操作
weixin_44678052的博客
03-02 1万+
本篇文章所使用的Flash型号为M25P16，是ST公司的一款(好像还有一款同名的，是别的公司的)。容量为16Mbit，SPI接口，时钟速率可达50Mhz。要想完成对Flash的读写擦除操作，只需要弄懂两点即可：SPI时序 和 Flash操作指令。其他的细节和一些概念可以学习的过程中了解补充。
自已写的FPGA使用SPI模式读写FLASH
10-10
自已写的FPGA使用SPI模式读写FLASH ，Flash型号W25Q128BV。
基于FPGA的SPI的外设flash的读写控制
2301_78782773的博客
10-14 1398
FPGA驱动SPI接口控制flash进行读写
基于FPGA的flash读写控制
08-17
基于FPGA的flash读写控制，包括擦除（格式化），写数据和读数据，使用Verilog HDL描述。
FPGA的SPI Verilog源码，读写flash芯片
10-13
在本文中，我们将深入探讨如何使用Verilog编程语言在FPGA上实现SPI（Serial Peripheral Interface）协议，以读写SPI接口的flash芯片。这个项目特别针对Altera的Cyclone IV E系列FPGA，例如EP4CE10F17C8，并且已经...
FPGA平台下基于Verilog的四线SPI Flash读写模块设计与实现
04-24
内容概要：本文详细介绍了如何在Altera和Xilinx FPGA平台上使用Verilog语言实现四线SPI Flash读写模块。首先概述了四线SPI的基本概念及其重要信号（SCLK、MOSI、MISO、CS#）。接着深入探讨了状态机设计、时钟分频、...
FPGA Verilog SPI通用收发模块：基于AXI4-Lite接口的设计与应用
05-10
内容概要：本文介绍了FPGA Verilog SPI通用收发模块及其AXI4-Lite接口设计。该模块主要用于调试和控制SPI外设，支持作为SPI接口主机，能够控制多达32个SPI总线和32个从机。它不仅提供AXI4-Lite接口封装，还支持多种...
基于FPGA的四线SPI Flash读写设计：Verilog与Altera/Xilinx技术解析
05-09
使用场景及目标：适用于希望深入了解FPGA环境下四线SPI Flash读写设计原理及其实现方式的人群。目标是在掌握相关理论的基础上，能够独立完成类似项目的开发。 其他说明：文中不仅提供了理论指导，还给出了具体的实现...
基于FPGA的SPI控制器.pdf
09-05
基于FPGA的SPI控制器
并行flash FPGA读写测试，Verilog语言
12-03
并行flash FPGA读写测试，Verilog语言，可以实现并行flash读写单独测试。
单片机spi Flash读写控制
09-02
单片机读写spi Flash存储器的源代码，存储器为W25X系列和M25X系列等。
test_spi.zip_SPI_TEST_FPGA_altera SPI_de2-70 spi_spi实现altera板_sp
09-22
原创的altera de2-70 FPGA板功能测试实验，用于SPI的读写。包含完整源代码，仿真文件，可直接下载到板子上的SOF文件，适合初学者研习。
FPGA 20个例程篇：7.FLASH读写断电存储
热门推荐
wandou0511的博客
05-25 1万+
三、数据断电存储，工程必备 7.FLASH读写断电存储 这篇博客主要讲述QSPI-FLASH，怎么设计FPGA的时序逻辑去实现FLASH的页数据读写、擦除的，这个例程本身有着有非常深刻地学习价值，这里大家不妨去思考一些工作中的常见场景：1.做单片机STM32开发，KEIL编译过后下载直接通过ST-LINK，J-LINK等把bin文件烧写到单片机的内部FLASH里，同样地我们可以把一些希望掉电保存的大批量数据也烧写到STM32内部FLASH里，用后面的扇区即可；2.STM32外挂一颗FLA....
基于FPGA的SPI Flash控制器设计与实现
m0_57781768的博客
06-14 1091
SPI Flash是一种使用串行通信协议的存储器，具有体积小、功耗低、速度快等优点。FPGA通过SPI接口与Flash进行通信，完成数据的读写操作。SCLK（串行时钟）：用于同步数据传输的时钟信号。MOSI（主输出从输入）：FPGA发送数据到Flash的信号。MISO（主输入从输出）：Flash发送数据到FPGA的信号。CS（片选）：选择具体的SPI Flash芯片。本文详细介绍了基于FPGA的SPI Flash控制器设计与实现。
SPI控制Flash读写
weixin_56481118的博客
03-27 7614
1.SPI(Serial Peripheral Interface)是一种高速、全双工、同步串行通信总线，由摩托摩拉公司推出。2.优缺点：全双工通信，通信方式简单，相对数据传输速度较快；SPI没有应答机制确认数据是否接收，数据可靠性上有一定缺陷。（相对IIC协议）。16Mbit，一共32个扇区，每个扇区256页，每页256字节，Flash断电后数据不会擦除1.2 SPI模式支持：M25P16支持SPI模式0和模式31.3 引脚。
FPGA模块——SPI协议（读写FLASH）
Treasureljc的博客
11-25 5310
有个输入时序的要求 开始时CS拉低等待（tSLCH要求最小5ns）再开始， 结束时CS拉高等待（tSHSL用100ns ）再进行下一次操作。写使能：开始时CS拉低等待（tSLCH要求最小5ns）再开始，结束时CS拉高等待（tSHSL取100ns ）再进行下一次操作。方便进行读取和局部操作。100m时钟和clk_cnt配合进行数据的读取和输出（clk_cnt有等于1和0的时候）主机和从机在时钟上升沿放入要输出的数据，在时钟下降沿读取要输入的数据。数据写多了会把之前的数据覆盖掉，要判断操作是否完成。
FPGA spi读写eeprom
12-27
FPGA (Field-Programmable Gate Array) 是一种可编程逻辑器件，它允许用户在硬件级别上定制电路的行为。要通过SPI (Serial Peripheral Interface) 从FPGA读写EEPROM (Electrically Erasable Programmable Read-Only Memory)，通常需要按照以下步骤操作： 1. **配置FPGA内部资源**：首先，在FPGA设计中，你需要配置SPI模块，包括数据线、时钟线以及CS (Chip Select) 控制信号。这通常涉及到使用IP核（知识产权）或者自定义Verilog或VHDL代码。 2. **建立SPI通信接口**：使用FPGA内部的I/O口设置SPI模式，如Master模式，连接到外部的EEPROM。确保时序匹配，包括发送、接收和延迟。 3. **设置地址和命令**：SPI传输开始前，先通过CS控制信号选择EEPROM，然后发送写入或读取的起始地址和命令字节。对于写操作，通常会先写入地址，再写入数据；读操作则先写入地址，然后读取响应数据。 4. **数据传输**：根据操作类型，进行相应的数据传输。如果是写操作，将数据一帧帧地发送出去；如果是读操作，等待接收完整的数据帧。 5. **处理结果**：读取操作完成后，检查并解析接收到的数据，如果有校验位，还需要校验其完整性。如果一切正常，则表示操作成功。 6. **释放资源**：操作结束后，解除CS信号，释放与EEPROM的通信，并可能需要复位EEPROM或关闭其他相关的配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值