FPGA project : flash_write

最新推荐文章于 2024-05-19 23:06:32 发布
最新推荐文章于 2024-05-19 23:06:32 发布
阅读量381 收藏
点赞数
分类专栏： 野火征途pro 文章标签： fpga开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Meng_long2022/article/details/133845063
版权

本实验重点学习了：

flash的页编程指令pp。

在写之前要先进行擦除（全擦除和页擦除）；

本实验：先传写指令，然后进入写锁存周期，然后传页编程指令，+3个地址；

然后传数据，奇数传55，偶数传aa。

在之前扇区擦除的代码上改改就行了。加一个功能就是传入数据大于256个时候，mosi一直拉高。

模块框图：

状态机：

代码：

只放spi模块的。因为其他代码和扇区擦除指令是一样的。

module spi (
    input       wire            sys_clk     ,
    input       wire            sys_rst_n   , 
    input       wire            key_start   ,

    output      wire            miso        ,
    output      reg             mosi        ,
    output      reg             cs_n        ,
    output      reg             sck 
);
    // parameter 
    parameter   COMD_W    = 8'h06    , // 写指令, 先发送写指令，进入写锁存周期
                COMD_P    = 8'h02    , // 页写指令
                MAX_NUM   = 32'd270  ; // 要发送指令+地址+数据的字节数。 2 + 3 + 100
    parameter   ADR_SE    = 8'h00    , // 扇区地址 adress secter
                ADR_PA    = 8'h04    , // 页地址   adress page
                ADR_BY    = 8'h00    ; // 字节地址 adress byte
    parameter   DATA_ODD  = 8'h55    , // odd  奇数
                DATA_EVE  = 8'haa    ; // even 偶数
    parameter   IDLE      = 5'b00001 ,
                WREN      = 5'b00010 ,
                WEL       = 5'b00100 ,
                INST      = 5'b01000 , // instruct 传送pp指令和addr
                DATA      = 5'b10000 ; // instruct 传送要写入的数据。
    // wire signal degine
    wire                IDLEtoWREN; 
    wire                WRENtoWEL ;  
    wire                WRENtoINST;   
    wire                INSTtoDATA;   
    wire                DATAtoIDLE;   
    // reg signal define
    reg     [19:0]      data_num  ; // 记录传递的数据，如果超过256个，那么mosi将会一直拉高（传1）.
    reg     [4:0]       state_c   ;
    reg     [4:0]       state_n   ;
    reg     [3:0]       cnt_20ns  ;
    reg     [3:0]       cnt_bit   ;
    reg     [31:0]      cnt_byte  ;
    reg                 flag_bit  ;
    reg                 f_b_reg   ; // flag_bit_reg的缩写
/****************************************************************************/
    // 三段式状态机
    // 现态与次态描述
    // state_c
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            state_c <= IDLE ;
        else
            state_c <= state_n ;
    end
    // state_n
    always @(*) begin
        case (state_c)
        IDLE   :if(IDLEtoWREN)
                    state_n <= WREN ;
                else 
                    state_n <= IDLE ;
        WREN   :if(WRENtoWEL)
                    state_n <= WEL  ;
                else 
                    state_n <= WREN ;
        WEL    :if(WRENtoINST)
                    state_n <= INST ;
                else 
                    state_n <= WEL  ;
        INST   :if(INSTtoDATA)
                    state_n <= DATA ;
                else 
                    state_n <= INST ;
        DATA   :if(DATAtoIDLE)
                    state_n <= IDLE ;
                else 
                    state_n <= DATA ;
        default:    state_n <= IDLE ;
        endcase
    end
    // 状态转移描述
    assign  IDLEtoWREN  = ( state_c == IDLE) && ( key_start     ) ;
    assign  WRENtoWEL   = ( state_c == WREN) && ( f_b_reg       ) ;
    assign  WRENtoINST  = ( state_c == WEL ) && ( cnt_20ns == 6 ) ;
    assign  INSTtoDATA  = ( state_c == INST) && ( f_b_reg       ) ;
    assign  DATAtoIDLE  = ( state_c == DATA) && ( f_b_reg && cnt_byte != 5) ; // 至少传递一个数据。否则会卡死在这个状态。
    // 相关信号描述
    // reg     [3:0]       cnt_20ns  ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_20ns <= 4'd0 ;
        else 
        case (state_c)
        IDLE :  cnt_20ns <= 4'd0 ;
        WREN :  if(cnt_20ns || f_b_reg)
                    cnt_20ns <= 4'd0 ;
                else 
                    cnt_20ns <= cnt_20ns + 1'b1 ;
        WEL  :  if(cnt_20ns == 6) // 60x20ns==120ns
                    cnt_20ns <= 4'd0 ;
                else
                    cnt_20ns <= cnt_20ns + 1'b1 ;
        INST :  if(cnt_20ns) // 由于下一个状态是发送数据，sck和cnt_20_ns的变换规律与INST相同。所以不需要f_b_reg。
                    cnt_20ns <= 4'd0 ;
                else 
                    cnt_20ns <= cnt_20ns + 1'b1 ;
        DATA :  if(cnt_20ns || (f_b_reg && cnt_byte != 5))
                    cnt_20ns <= 4'd0 ;
                else 
                    cnt_20ns <= cnt_20ns + 1'b1 ;
        default:    cnt_20ns <= 4'd0 ;
        endcase
    end
    // reg     [3:0]       cnt_bit   ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n)
            cnt_bit <= 4'd0 ;
        else 
        case (state_c)
        IDLE :  cnt_bit <= 4'd0 ;
        WREN :  if(!cnt_20ns && sck && cnt_bit == 7)
                    cnt_bit <= 4'd0 ;
                else if(!cnt_20ns && sck)
                    cnt_bit <= cnt_bit + 1'b1 ;
        WEL  :  cnt_bit <= 4'd0 ;
        INST :  if(!cnt_20ns && sck && cnt_bit == 7)
                    cnt_bit <= 4'd0 ;
                else if(!cnt_20ns && sck)
                    cnt_bit <= cnt_bit + 1'b1 ;
        DATA :  if(!cnt_20ns && sck && cnt_bit == 7)
                    cnt_bit <= 4'd0 ;
                else if(!cnt_20ns && sck)
                    cnt_bit <= cnt_bit + 1'b1 ;
        default:    cnt_bit <= 4'd0 ;
        endcase
    end
    // reg      [31:0]       cnt_byte
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            cnt_byte <= 32'd0 ;
        else if(cnt_bit == 7 && !cnt_20ns && sck && cnt_byte == MAX_NUM - 1) // 计数到传送字节的最大值。
            cnt_byte <= 32'd0 ;
        else if(cnt_bit == 7 && !cnt_20ns && sck)
            cnt_byte <= cnt_byte + 1'b1 ;
        else 
            cnt_byte <= cnt_byte ;
    end
    // reg                 flag_bit  ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) 
            flag_bit <= 1'b0 ;
        else
        case (state_c)
        IDLE :  flag_bit <= 1'b0 ;
        WREN :  if(cnt_bit == 7 && sck && !cnt_20ns)
                    flag_bit <= 1'b1 ;
                else 
                    flag_bit <= flag_bit ;
        WEL  :  flag_bit <= 1'b0 ;
        INST :  if(cnt_bit == 7 && sck && !cnt_20ns && cnt_byte == 4)
                    flag_bit <= 1'b1 ;
                else 
                    flag_bit <= flag_bit ;
        DATA :  if(cnt_bit == 0 && cnt_byte == 5)
                    flag_bit <= 1'b0 ;
                else if(cnt_bit == 7 && sck && !cnt_20ns && cnt_byte == MAX_NUM - 1)
                    flag_bit <= 1'b1 ;
                else 
                    flag_bit <= flag_bit ;
        default: flag_bit <= 1'b0 ;
        endcase
    end
    // reg                 f_b_reg   ;
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            f_b_reg <= 1'b0 ;
        end else begin
            f_b_reg <= flag_bit ;
        end
    end
    // reg  [19:0]   data_num
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n)
            data_num <= 20'd0 ;
        else if(state_c == DATA && cnt_bit == 7 && !cnt_20ns && sck)
            data_num <= data_num + 1'b1 ;
        else if(state_c != DATA)
            data_num <= 20'd0 ;
        else 
            data_num <= data_num ;
    end
    // output signal
    // wire            miso        ,
    assign miso = 1'bz ;
    // mosi
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n)
            mosi <= 1'b0 ;
        else
        case (state_c)
        IDLE :  mosi <= 1'b0 ;
        WREN :  if(!cnt_bit) // (cnt_bit == 0)
                    mosi <= COMD_W[7] ;
                else if(cnt_20ns && sck)
                    mosi <= COMD_W[7 - cnt_bit] ;
                else 
                    mosi <= mosi ;
        WEL  :  mosi <= 1'b0 ;
        INST :  case (cnt_byte)
                    1:  
                        begin
                            if(!cnt_bit)
                                mosi <= COMD_P[7] ;
                            else if(cnt_20ns && sck)
                                mosi <= COMD_P[7 - cnt_bit] ;
                            else 
                                mosi <= mosi ;  
                        end
                    2:  
                        begin
                            if(!cnt_bit)
                                mosi <= ADR_SE[7] ;
                            else if(cnt_20ns && sck)
                                mosi <= ADR_SE[7 - cnt_bit] ;
                            else 
                                mosi <= mosi ;  
                        end
                    3:  
                        begin
                            if(!cnt_bit)
                                mosi <= ADR_PA[7] ;
                            else if(cnt_20ns && sck)
                                mosi <= ADR_PA[7 - cnt_bit] ;
                            else 
                                mosi <= mosi ;  
                        end
                    4:  
                        begin
                            if(!cnt_bit)
                                mosi <= ADR_BY[7] ;
                            else if(cnt_20ns && sck)
                                mosi <= ADR_BY[7 - cnt_bit] ;
                            else 
                                mosi <= mosi ;  
                        end
                    5:  
                        begin
                            if(!cnt_bit) // 由于当cnt_byte == 5 时，有一段state_c没有立即跳转到data状态。
                                mosi <= DATA_ODD[7] ;
                            else if(cnt_20ns && sck)
                                mosi <= DATA_ODD[7 - cnt_bit] ;
                            else 
                                mosi <= mosi ;  
                        end
                default:        mosi <= 1'b0 ;
                endcase
        DATA :  if(data_num <= 255) begin
                    if(cnt_byte[0]) begin // 二进制最低为奇偶标志位，1表示奇位，发送数据5。
                        if(!cnt_bit)
                            mosi <= DATA_ODD[7] ;
                        else if(cnt_20ns && sck)
                            mosi <= DATA_ODD[7 - cnt_bit] ;
                        else 
                            mosi <= mosi ;  
                    end else begin // cnt_byte[0] == 0 偶数。发送数据a
                        if(!cnt_bit)
                            mosi <= DATA_EVE[7] ;
                        else if(cnt_20ns && sck)
                            mosi <= DATA_EVE[7 - cnt_bit] ;
                        else 
                            mosi <= mosi ;  
                    end
        end else begin
            mosi <= 1'b1 ; // 大于256个数据之后，mosi就一直传递1.
        end
        default:    mosi <= 1'b0 ;
        endcase
    end
    // reg             cs_n        ,
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n) begin
            cs_n <= 1'b1 ;
        end else begin
            case (state_c)
            IDLE :  if(key_start)
                        cs_n <= 1'b0 ;
                    else 
                        cs_n <= 1'b1 ;
            WREN :  if(f_b_reg)
                        cs_n <= 1'b1 ;
                    else 
                        cs_n <= cs_n ;
            WEL  :  if(cnt_20ns == 6) 
                        cs_n <= 1'b0 ;
                    else 
                        cs_n <= cs_n ;
            INST :  cs_n <= 1'b0 ;
            DATA :  if(f_b_reg && cnt_byte != 5 )
                        cs_n <= 1'b1 ;
                    else 
                        cs_n <= cs_n ;
            default:    cs_n <= 1'b1 ;
            endcase
        end
    end
    // reg             sck 
    always @(posedge sys_clk or negedge sys_rst_n) begin
        if(~sys_rst_n)
            sck <= 1'b0 ;
        else 
        case (state_c)
        IDLE :  sck <= 1'b0 ;
        WREN :  if(cnt_20ns)
                    sck <= ~sck ;
                else 
                    sck <= sck  ;
        WEL  :  sck <= 1'b0 ;
        INST :  if(cnt_20ns)
                    sck <= ~sck ;
                else 
                    sck <= sck  ;
        DATA :  if(cnt_20ns)
                    sck <= ~sck ;
                else 
                    sck <= sck  ;
        default:    sck <= 1'b0 ;
        endcase
    end

endmodule

仿真波形： 

 

 

核桃_warrior
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
matlab集成c代码-intan_project:intan_project
05-22
通过将原始Intan中提供的现有DAC阈值检测机制中的一组经过修改的阈值检测器组合在一起，在与Intan放大器芯片的现有FPGA接口中基本实现了一个类似于状态详细描述的有限状态机（FSM）。刺激控制器FPGA接口。 迄今为止...
fpga-dm9000a.rar_FPGA 串口_flash_fpga_fpga升级_串口 spartan
07-14
一个项目工程，硬件包含XINLINX FPGA，配置FLASH，串口，SDRAM,与以太网芯片DM9000A，实现数据采集，以太网传输，电路验证完全正确，请放心使用，SPARTAN 3E 的BGA引脚320个，不容易布板，可以参考使用的。要FPGA...
使用FlashWrite烧写FLASH
sunrock的专栏
01-28 5345
http://blog.chinaunix.net/u/26710/showart_257517.html这里所指的FlashWrite是与Banyan-U ARM仿真器配套及其后台服务程序配套使用的FLASH烧写工具，可以通过仿真器的JTAG接口将程序烧写到FLASH存储器中。       使用FlashWrite之前要先运行Banyan Daemon，在配置和初始化目标板之后，才能将程序烧
stm32中flash的写入与读取
热门推荐
weixin_42041380的博客
11-09 1万+
stm32中flash应用的常见函数： 1.擦除函数： FLASH_Status FLASH_ErasePage(u32 Page_Address)只要（）里面的数是flash第xx页中对应的任何一个地址！就是擦除xx页全部内容。 2.flash写入函数： STMFLASH_Write(uint32_t WriteAddr,uint32_t *pBuffer,uint32_t NumToWrite...
FPGA project ： flash_continue_write
Meng_long2022的博客
10-16 443
本实验学习了通过spi通信协议，驱动flash；完成连续写操作。
基于FPGA 外置qspi Flash的读写
weixin_43498765的博客
03-10 3083
fpga上实现flash读写代码
FPGA 外置Flash的读写，用户数据存储
qsj_csdn的博客
03-29 1万+
FPGA 外置Flash的读写，用户数据存储前言一，该功能验证平台及参考文章1，Xilinx xc7k325tffg676-22，vivado 2017.43，验证的flash芯片：MT25QL2563，参考文章：MT25QL256_datasheet二、实现的功能1，read Device ID2，设置4-byte模式5，flash的数据读写三，部分代码总结 前言 大多数FPGA内部不具有掉电存储程序的功能，所以都是外置flash存储器来存储程序，上电后加载flash中的程序到FPGA中，在运行。外置f
非图形界面开发FPGA_VIVADO
younghuadadao的博客
03-11 475
非工程模式开发FPGA
FPGA基础入门【8】开发板外部存储器SPI flash访问
qimoDIY的博客
08-13 1万+
前两篇教程利用数码管project介绍了chipscope和各种烧写开发板的方式，这篇开始继续探索开发板，这次关注外置存储器的控制，外置指的是芯片外部，不是开发板外部。 FPGA基础入门【8】开发板外部存储器访问开发板中的外置存储器调用 开发板中的外置存储器 开发板的具体介绍参考此链接：NEXYS 4 DDR Manual PDF 开发板上有两种外置存储器，一种是DDR2，另一种就是上一篇博文中用...
Verilog SPI-Flash读写总线控制模块
独木舟216的博客
06-18 3705
`timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2019/11/26 11:55:56 // Design Name: // Module Name: spi_driver // Project Name: // Target Devices: //.
基于FPGA的SPI FLASH控制器设计
weixin_34326429的博客
04-05 3500
1.SPI FLASH的基本特征 本文实现用FPGA来设计SPI FLASH，FLASH型号为W25Q128BV。支持3种通信方式，SPI、Dual SPI和Quad SPI。FLASH的存储单元无法写入bit 1，只能写入bit 0，所以写入数据之前要将原来的数据擦除（FFh），遇到写入bit 1的情况不作处理。W25Q128BV的特征为如下图所示： 2.SPI FLASH的基本结构 ...
01_test.rar_NgdBuild:488_fpga_middleol4
09-15
FPGA测试程序，仅供测试硬件是否能够运行，主要功能是点亮运行指示灯
fpga_control.rar_FPGA FLASH_flash_flash FPGA_fpga usb2.0_usb2.
07-14
FPGA控制FLASH和USB2.0数据通信
91331957FPGA_project_digitalclock_
10-01
FPGA VHDL Digital clock project
【chisel】学习chisel进行FPGA开发的步骤
最新发布
sqqwm的专栏
05-19 81
学习chisel进行FPGA开发的步骤
FPGA火在哪里？（从商业和专业角度分析）
Janice01的博客
05-10 1530
FPGA偏硬件，用语言（verilog、vhdl）或者图形（ip block）描述硬件电路，适合做底层通信时快速的硬协议。个人感觉，今后国家的大趋势应该是恶补底层建筑，应用范围比较广，而且自学难度大，适合投入整个本科或研究生阶段去学。FPGA在嵌入式领域的应用，只是FPGA广阔应用中很小的一部分。作为学生，FPGA更多的是作为载体，用来帮助你来学习和理解更多专业知识，并且提高自己的动手能力和技术水平。免责声明：本文内容部分摘抄自网络，仅供各位参考不做任何商业及其他用途。部分链接。
基于FPGA的超声波测距
wakeup_high的博客
05-18 863
从实验结果观察发现测量距离同实际还是具有一定的误差，可能是由传感器本身的噪声、回波的多路径传播、环境的干扰等原因造成。
[SV]Modules, Controls, and Interfaces
元直的博客
05-14 989
【代码】[SV]Modules, Controls, and Interfaces。
Critical Warning (176598): PLL "pll_u0:pll_sdvga|altpll:altpll_component|pll_u0_altpll:auto_generated|pll1" input clock inclk[0] is not fully compensated because it is fed by a remote clock pin "Pin_T21"这是为什么
06-09
这个warning是指FPGA中的一个PLL模块存在输入时钟信号的时钟抖动过大的问题。其中，输入时钟信号来自于远离PLL的输入引脚"Pin_T21"。由于信号传输过程中存在不可避免的时钟抖动和时钟偏差，因此在远离PLL的输入引脚...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值