SRAM的读写操作

自己写的SRAM的程序，主要在于实用性，适应工作的工程需要。使用芯片为：

芯片时序图为：

代码：

    /********************************Copyright**************************************
    **----------------------------File information--------------------------
    ** File name  : ZF_SRAM.v
    ** CreateDate :2014.11
    ** Funtions   : SRAM的读写功能,CS、LB、UB都被固定住(CS1 =L,CS2 =H,LB=L,UB=L)。读：WE =H,OE =L/写：we = L,OE = X;
                                    上电之后，先对SRAM 进行初始化，然后再写入读出。
                                    sram上半屏的数据地址：0- 5183（288*18），下半屏地址：5184 - 10367
    ** Operate on :M5C06N3L114C7
    ** Copyright  :All rights reserved.
    ** Version    :V1.0
    **---------------------------Modify the file information----------------
    ** Modified by   :
    ** Modified data :
    ** Modify Content:
    *******************************************************************************/

    module ZF_SRAM(
                                    clk_90m,
                                    rst_n,

                                    wr_reg,   //写数据使能
                                    rd_reg,   //读数据使能

                                    addr_wr_reg,  //写数据地址
                                    addr_rd_reg,  //读数据地址
                                    data_wr_reg,  //写操作数据寄存器
                                    data_rd_reg,  //读出的数据寄存器

                                    cs_sram,
                                    wr_sram,        //we
                                    rd_sram,        //oe
                                    addr_sram,
                                    data_sram_wr,    //写入的数据
                                    data_sram_rd,    //读入的数据
                                    dir_data,        //数据方向控制
                                    wr_over,
                                    rd_over,

                                    test_1,
                                    test_2

                                        );

     parameter  width = ;

    input               clk_90m;
    input               rst_n;

    input                wr_reg;        //写使能
    input                rd_reg;        //读使能

    input  [width -:]  addr_wr_reg;   //地址寄存器
    input  [width -:]  addr_rd_reg;   //地址寄存器
    input  [width -:]  data_wr_reg;   //待写数据寄存器
    output [width -:]  data_rd_reg;   //读出的数据寄存器
    reg    [width -:]  data_rd_reg_1;   //读出的数据寄存器

    output     reg       wr_sram;       //we
    output     reg       rd_sram;       //oe
    output     reg       cs_sram;

    output   reg  [width-:]   addr_sram;    //写出的信号
    output   reg  [width-:]   data_sram_wr; //写出的数据
    input         [width-:]   data_sram_rd; //读入的数据
    output   reg                dir_data;     //数据方向的控制
    output   reg                wr_over;
    output   reg                rd_over;
    reg           [width-:]   data_zifu;
     output                     test_1;
     output                     test_2;

        //***************读写状态机**********************//
     parameter   idel_0 = 'd0;      //初始化显示界面
     parameter   idel_1 = 'd1;      //初始化显示界面2
     parameter   idel_2 = 'd2;      //初始化显示界面
     parameter   idel_3 = 'd3;      //初始化显示界面2
     parameter   idel_4 = 'd4;      //初始化显示界面
     parameter   idel_5 = 'd5;      //初始化显示界面 

     parameter   idel = 'd6;
     parameter   wr_1 = 'd7;        //拉低cs
     parameter   wr_2 = 'd8;        //拉低wr
     parameter   wr_3 = 'd9;        //保持
     parameter   wr_4 = 'd10;        //拉高cs，wr
     parameter   wr_5 = 'd11;        //拉高结束
     parameter   wr_6 = 'd12;        //拉低结束
     parameter   wr_7 = 'd13;        //拉低结束
                         /* 留几个状态间隔 */

     parameter   rd_1 = 'd17;        //拉低cs
     parameter   rd_2 = 'd18;        //拉低rd
     parameter   rd_3 = 'd19;        //保持
     parameter   rd_4 = 'd20;        //拉高cs，rd
     parameter   rd_5 = 'd21;        //拉高结束
     parameter   rd_6 = 'd22;        //拉低结束
   parameter   rd_7 = 'd23;        //拉低结束

     reg     [:]      state;
     reg     [:]     i;
     always @(posedge clk_90m or negedge rst_n)
     begin
        if(!rst_n)
         begin
                state <= idel_0;
                data_zifu <= ;
                wr_sram <= ;
                rd_sram <= ;
                cs_sram <= ;
                addr_sram<= ;
                data_sram_wr<= ;
                dir_data <= ;
                wr_over <= ;
                rd_over <= ;
                i <= ;
            end
        else
            begin
             case(state)
                idel_0:
                     begin
                                wr_sram  <= ;
                                rd_sram  <= ;
                                cs_sram  <= ;

                                addr_sram <= ;
                                dir_data <= ;
                                state <= idel_1;
                            end
                idel_1:
                     begin
                            if(i > )
                                begin
                                        i <= ;
                                        state <= idel;
                                end
                            else
                                    begin
                                         addr_sram <= i;
                                         data_sram_wr <= 'h0000;
                                         state <= idel_2;
                                        end
                         end
             idel_2:
                     begin
                            cs_sram <= ;
                            state <= idel_3;
                         end
             idel_3:
                     begin
                            state <= idel_4;
                            wr_sram <= ;
                         end
             idel_4:
                     begin
                          state <= idel_5;
                             wr_sram <= ;
                        end
            idel_5 :
               begin
                        wr_sram <= ;
                        cs_sram <= ;
                         i <= i + ;
                        state <= idel_1;
                    end
        //----------------------------//
          /* 初始化完毕  */
                idel:
                    begin
                        wr_sram  <= ;
                        rd_sram  <= ;
                        cs_sram  <= ;

                        addr_sram <= ;
                        dir_data <= ;
                        wr_over <= ;
                        rd_over <= ;
                        if(wr_reg)     //写使能有效
                            begin
                                dir_data <= ;     //写方向
                                addr_sram <= addr_wr_reg;  //寄存地址
                data_sram_wr <= data_wr_reg; //寄存写入的数据
                                state <= wr_1;
                            end
                         else if(rd_reg)
                             begin
                                 dir_data <= ;     //读方向
                                 addr_sram <= addr_rd_reg;  //寄存地址
                                 state <= rd_1;
                                end
                        else
                            state <= idel;
                    end
             wr_1:
                 begin
                        state <= wr_2;
                        cs_sram <= ;
                     end
             wr_2:
                 begin
                     state <= wr_3;
                     wr_sram <= ;
                  end
                wr_3:
                 begin
                     state <= wr_4;
                     wr_sram <= ;
                  end
                wr_4:
                 begin
                       state <= wr_5;
             cs_sram <= ;
                         wr_sram <= ;
                     end
                wr_5:
                    begin
                        wr_over <= ;
                        state <= wr_6;
                    end
              wr_6:
                    begin
                        wr_over <= ;
                        state <= idel;
                    end    

        //-------------------//
                rd_1:
                    begin
                             state <= rd_2;
                             cs_sram <= ;
                     end
                rd_2:
                    begin
                             state <= rd_3;
                             rd_sram <= ;
                     end
                rd_3:
                    begin
                         state <= rd_4;
                         rd_sram <= ;
                     end
                rd_4:
                    begin
                         data_zifu <= data_sram_rd;  //读取数据
                         state <= rd_5;
                         rd_sram <= ;
                         cs_sram <= ;
                     end
                rd_5:
                     begin
                         rd_over <= ;
                         state <= rd_7;
                     end
                rd_6:
                     begin
                         rd_over <= ;
                         state <= idel;
                     end
                default:state <= idel;
             endcase
            end
        end

    always @(posedge clk_90m or negedge rst_n)
     begin
        if(!rst_n)
         begin
             data_rd_reg_1 <= ;
            end
        else if(rd_over)
            begin
                data_rd_reg_1 <= data_zifu;
             end
        else
                data_rd_reg_1 <= data_rd_reg_1;
        end

   assign data_rd_reg = data_rd_reg_1;
    //----------------------------
     assign  test_1 = wr_reg;
     assign  test_2 = data_sram_wr[];

    endmodule

仿真后复合读写时序。

为了检测sram是否读写成功，则可以让FPGA来来写数据，用单片机来读取数据，然后在线验证是否读取的数据是否正确：

程序打包上传，链接地址为：http://i.cnblogs.com/Files.aspx