• FPGA project ： sdram

    sdram读写控制器

    实验目标：

    设计并实现一个 SDRAM 数据读写控制器，使用 PC 机通过串口向 SDRAM 写入 10 字
    节数据，并将写入的 10 字节数据读出，通过串口回传至 PC 机，在串口助手上位机上打印
    显示回传数据。

    框图设计：

    第一部分：

    sdram基本操作实的实现sdram_ctrl

    要实现数据的读写，还要有初始化和刷新操作。所以该模块要有分别产生这四条指令的模块。

    由于时序冲突问题，刷新，和读写指令存在优先级的问题。所以还应有仲裁模块。

    如下：

    指令产生模块应该有指令端口，bank地址端口，行列地址端口，结束标志信号。

    刷新模块的请求信号传向仲裁模块，反馈给刷新模块一个使能信号。

     写指令模块的写数据，写地址，写突发长度。必不可少。

     

     

    需要注意的是有几个输入端口是外界给的，有几个输出端口直接输出出去。

    整体：

     

     第二部分：

    sdram控制器sdram_top

    fifo控制模块，实现sdram读写数据的跨时钟域处理。

     

     

     第三部分：

    uart_sdram。uart与sdram的数据交互与最顶层模块设计。

     指令：

    1,取消设备选择：1XXX；

    2,无操作指令：0111；

    3,配置模式指令：0000；+ addr A12~A0

    4,预充电指令：0010；+ addr

    5,自动刷新与自刷新指令：0001；

    6,激活指令：0011；+addr/bank

    7,写指令：0100；+bank/col；

    8,读指令：0101;+bank/col;

    明天完成初始化模块，加油！！！

    这个sdram读写控制器工程确实挺大的。

    代码设计：

    sdram_ctrl：

    sdram_init：

    设计思路：

    1 预充电指令，在写入0010指令+A10 == 1 之前，先等待200us，加载稳定时钟，并传递空操作指令。

    2 写入预充电之后要等待TRP = 2  ，并传递空操作指令0111。

    3 TRP时间结束后，写入自动刷新指令0001，并等待TRC = 7 ，并传递空操作指令。

    4 TRC时间结束后，再次刷新指令。

    5 TRC时间结束后，模式配置寄存器指令0000。+A11~A0；并等待TMRD = 时间，并传递空操作。

    6 等待TMRD结束后，完成初始化。

    时序图：
    代码： 
    1. // 初始化模块,产生控指令时序，预充电时序，刷新时序，模式配置时序。sys_clk == 100mHz
    2. module sdram_init(
    3.     input       wire            sys_clk     , 
    4.     input       wire            sys_rst_n   ,
    5.  
    6.     output      reg     [3:0]   init_cmd    ,
    7.     output      reg     [1:0]   init_ba     ,
    8.     output      reg     [12:0]  init_addr   ,
    9.     output      reg             init_end
    10. );
    11.  
    12.     // parameter
    13.     parameter   T_POWER   = 200_00       , // 等待时钟稳定。200us。
    14.                 T_RP      = 2            , // 2个时钟周期的预充电时间。
    15.                 T_RFC     = 7            , // 7个时钟周期的刷新时间。
    16.                 T_MRD     = 3            , // 3个时钟周期的模式配置时间。
    17.                 MAX_CNT_AR= 8            ; // 刷新次数。
    18.     localparam  INIT_NOP  = 4'b0111      , // 空指令
    19.                 INIT_PREC = 4'b0010      , // 预充电
    20.                 INIT_REF  = 4'b0001      , // 自动刷新
    21.                 INIT_MOD  = 4'b0000      ; // 模式配置
    22.     localparam  INIT_IDLE = 8'b0000_0001 ,
    23.                 INIT_PRE  = 8'b0000_0010 , // 预充电
    24.                 INIT_TRP  = 8'b0000_0100 ,
    25.                 INIT_AR   = 8'b0000_1000 , // 刷新
    26.                 INIT_TFR  = 8'b0001_0000 ,
    27.                 INIT_MRS  = 8'b0010_0000 , // 模式配置
    28.                 INIT_TMRD = 8'b0100_0000 ,
    29.                 INIT_ENDS = 8'b1000_0000 ; // 完成
    30.     // reg signal define
    31.     reg     [7:0]       state_c  ;
    32.     reg     [7:0]       state_n  ;
    33.     reg     [15:0]      cnt_init ;
    34.     reg     [3:0]       cnt_ar   ; // 记录刷新次数，以产生状态跳转条件。
    35.     // wire signal define
    36.     wire                INIT_IDLEtoINIT_PRE ;
    37.     wire                INIT_TRPtoINIT_AR   ;  
    38.     wire                INIT_TFRtoINIT_MRS  ; 
    39.     wire                INIT_TFRtoINIT_AR   ;
    40.     wire                INIT_TMRDtoINIT_ENDS;
    41.     /************************************************************************/
    42.     // reg     [7:0]       state_c  ;
    43.     always @(posedge sys_clk or negedge sys_rst_n) begin
    44.         if(~sys_rst_n) 
    45.             state_c <= INIT_IDLE ;
    46.         else
    47.             state_c <= state_n ;
    48.     end
    49.     // reg     [7:0]       state_n  ;
    50.     always @(*) begin
    51.         case(state_c)
    52.         INIT_IDLE : if(INIT_IDLEtoINIT_PRE)
    53.                         state_n = INIT_PRE ;
    54.                     else 
    55.                         state_n = INIT_IDLE ;
    56.         INIT_PRE  : state_n = INIT_TRP ;
    57.         INIT_TRP  : if(INIT_TRPtoINIT_AR)
    58.                         state_n = INIT_AR ;
    59.                     else 
    60.                         state_n = INIT_TRP ;
    61.         INIT_AR   : state_n = INIT_TFR ;
    62.         INIT_TFR  : if(INIT_TFRtoINIT_MRS)
    63.                         state_n = INIT_MRS ;
    64.                     else if(INIT_TFRtoINIT_AR) // 没有达到规定的刷新次数，回到刷新指令。
    65.                         state_n = INIT_AR ;
    66.                     else 
    67.                         state_n = INIT_TFR ;
    68.         INIT_MRS  : state_n = INIT_TMRD ;
    69.         INIT_TMRD : if(INIT_TMRDtoINIT_ENDS)
    70.                         state_n = INIT_ENDS ;
    71.                     else 
    72.                         state_n = INIT_TMRD ;
    73.         INIT_ENDS : state_n = INIT_ENDS ; // 保持在此状态。
    74.         default   : state_n = INIT_IDLE ;
    75.         endcase
    76.     end
    77.     assign INIT_IDLEtoINIT_PRE  = (state_c == INIT_IDLE) && (cnt_init == T_POWER - 1) ; 
    78.     assign INIT_TRPtoINIT_AR    = (state_c == INIT_TRP ) && (cnt_init == T_RP    - 1) ;
    79.     assign INIT_TFRtoINIT_MRS   = (state_c == INIT_TFR ) && ((cnt_ar == MAX_CNT_AR - 1) && (cnt_init == T_RFC - 1)) ;
    80.     assign INIT_TFRtoINIT_AR    = (state_c == INIT_TFR ) && ((cnt_ar != MAX_CNT_AR - 1) && (cnt_init == T_RFC - 1)) ;
    81.     assign INIT_TMRDtoINIT_ENDS = (state_c == INIT_TMRD) && (cnt_init == T_MRD    - 1) ;
    82.     // reg     [15:0]       cnt_init ;
    83.     always @(posedge sys_clk or negedge sys_rst_n) begin
    84.         if(~sys_rst_n) 
    85.             cnt_init <= 16'd0 ;
    86.         else 
    87.         case (state_c)
    88.         INIT_IDLE : if(cnt_init == T_POWER - 1)
    89.                         cnt_init <= 16'd0 ;
    90.                     else 
    91.                         cnt_init <= cnt_init + 1'b1 ;
    92.         INIT_PRE  : cnt_init <= 16'd0 ;
    93.         INIT_TRP  : if(cnt_init == T_RP    - 1)
    94.                         cnt_init <= 16'd0 ;
    95.                     else 
    96.                         cnt_init <= cnt_init + 1'b1 ;
    97.         INIT_AR   : cnt_init <= 16'd0 ;
    98.         INIT_TFR  : if(cnt_init == T_RFC - 1)
    99.                         cnt_init <= 16'd0 ;
    100.                     else 
    101.                         cnt_init <= cnt_init + 1'b1 ;
    102.         INIT_MRS  : cnt_init <= 16'd0 ;
    103.         INIT_TMRD : if(cnt_init == T_MRD    - 1)
    104.                         cnt_init <= 16'd0 ;
    105.                     else 
    106.                         cnt_init <= cnt_init + 1'b1 ;
    107.         INIT_ENDS : cnt_init <= 16'd0 ;
    108.         default   : cnt_init <= 16'd0 ;
    109.         endcase
    110.     end
    111.     // reg     [3:0]       cnt_ar   ;
    112.     always @(posedge sys_clk or negedge sys_rst_n) begin
    113.         if(~sys_rst_n) 
    114.             cnt_ar <= 4'd0 ;
    115.         else if((state_c == INIT_TFR) && (cnt_init == T_RFC - 1) && (cnt_ar == MAX_CNT_AR - 1))
    116.             cnt_ar <= 4'd0 ;
    117.         else if((state_c == INIT_TFR) && (cnt_init == T_RFC - 1))
    118.             cnt_ar <= cnt_ar + 1'b1 ;
    119.         else
    120.             cnt_ar <= cnt_ar ;  
    121.     end
    122.     // reg     [3:0]   init_cmd    ,
    123.     always @(posedge sys_clk or negedge sys_rst_n) begin
    124.         if(~sys_rst_n) 
    125.             init_cmd <= INIT_NOP ;
    126.         else 
    127.         case (state_c)
    128.         INIT_IDLE : init_cmd <= INIT_NOP ;
    129.         INIT_PRE  : init_cmd <= INIT_PREC;
    130.         INIT_TRP  : init_cmd <= INIT_NOP ;
    131.         INIT_AR   : init_cmd <= INIT_REF ;
    132.         INIT_TFR  : init_cmd <= INIT_NOP ;
    133.         INIT_MRS  : init_cmd <= INIT_MOD ;
    134.         INIT_TMRD : init_cmd <= INIT_NOP ;
    135.         INIT_ENDS : init_cmd <= INIT_NOP ;
    136.         default   : init_cmd <= INIT_NOP ;
    137.         endcase
    138.     end
    139.     // reg     [1:0]   init_ba     ,
    140.     // reg     [12:0]  init_addr   ,
    141.     always @(posedge sys_clk or negedge sys_rst_n) begin
    142.         if(~sys_rst_n) begin
    143.             init_ba <= 2'b11 ;
    144.             init_addr <= 13'h1FFF ;
    145.         end
    146.         else if(state_c == INIT_MRS) begin
    147.             init_ba <= 2'b00 ;
    148.             init_addr <= 13'b000_0_00_011_0_111 ;
    149.         end
    150.         else begin
    151.             init_ba <= 2'b11 ;
    152.             init_addr <= 13'h1FFF ;
    153.         end
    154.     end
    155.     // reg             init_end
    156.     always @(posedge sys_clk or negedge sys_rst_n) begin
    157.         if(~sys_rst_n) 
    158.             init_end <= 1'b0 ;
    159.         else if(state_c == INIT_ENDS)
    160.             init_end <= 1'b1 ;
    161.         else 
    162.             init_end <= init_end ;
    163.     end
    164. endmodule
    仿真： 
    1. `timescale 1ns/1ns
    2. module test_sdram_init ();
    3.     reg              sys_clk     ; // 100mHz
    4.     reg              sys_rst_n   ;
    5.  
    6.     wire     [3:0]   init_cmd    ;
    7.     wire     [1:0]   init_ba     ;
    8.     wire     [12:0]  init_addr   ;
    9.     wire             init_end    ;
    10.  
    11. sdram_init sdram_init_inst(
    12.     .sys_clk    ( sys_clk  ) , 
    13.     .sys_rst_n  ( sys_rst_n) ,
    14.  
    15.     .init_cmd   ( init_cmd ) ,
    16.     .init_ba    ( init_ba  ) ,
    17.     .init_addr  ( init_addr) ,
    18.     .init_end   ( init_end )
    19. );
    20.  
    21.     parameter CYCLE = 10 ; // 10ns
    22.     initial begin
    23.         sys_clk = 1'b1 ;
    24.         sys_rst_n <= 1'b0 ;
    25.         #(CYCLE) ;
    26.         sys_rst_n <= 1'b1 ;
    27.         #(CYCLE * 250_00) ;
    28.         $stop ;
    29.     end
    30.     always #(CYCLE / 2) sys_clk = ~sys_clk ;
    31. endmodule

    sdram_aref:

    设计思路： 

    分析时序图可知，刷新模块要做的是先传预充电时序，然后传刷新时序>=2次。简化版的初始化。

    自动刷新周期为7.5us。设参数MAX_CNT_REF = 750.

    在初始化结束信号拉高后，cnt_750us开始计数，计满后aref_req拉高，等待仲裁模块给出aref_en拉高，开始进行刷新状态机跳转。当跳转到预充电命令时，说明已经开始刷新了，aref_req拉低。

    根据时序，绘制状态跳转。

    当进入结束状态时，发出一个周期的aref_end==1信号，仲裁模块把aref_en拉低。完成一次刷新。

    cnt_750us计数器是在init_end==1后循环计数的。

    cnt_ar记录刷新次数，要刷新两次才可以。

    时序图：

     代码：
    1. // 模块说明：刷新模块，在初始化完成后，以750us为周期进行刷新时序的输出（要受仲裁模块控制），但刷新周期不会大于750us。
    2. module sdram_aref(
    3.     input       wire                sys_clk     ,
    4.     input       wire                sys_rst_n   ,
    5.     input       wire                init_end    ,
    6.     input       wire                aref_en     ,
    7.  
    8.     output      reg                 aref_req    ,
    9.     output      reg     [3:0]       aref_cmd    ,
    10.     output      wire    [1:0]       aref_ba     ,
    11.     output      wire    [12:0]      aref_addr   ,
    12.     output      wire                aref_end    
    13. );
    14.     // parameter    
    15.     parameter   MAX_CNT_750US   = 750        ;
    16.     // localparam
    17.     localparam  T_RP            = 2          , // 2个时钟周期的预充电时间。
    18.                 T_RFC           = 7          , // 7个时钟周期的刷新时间。
    19.                 MAX_CNT_AR      = 2          , // 刷新次数。
    20.                 AREF_NOP        = 4'b0111    , // 空指令
    21.                 AREF_PREC       = 4'b0010    , // 预充电
    22.                 AREF_REFC       = 4'b0001    ; // 自动刷新,指令与状态机命名冲突了，后面加个C。
    24.     localparam  AREF_IDLE       = 6'b00_0001 ,
    25.                 AREF_PCHA       = 6'b00_0010 ,
    26.                 AREF_TRP        = 6'b00_0100 ,
    27.                 AREF_REF        = 6'b00_1000 ,
    28.                 AREF_TRF        = 6'b01_0000 ,
    29.                 AREF_END        = 6'b10_0000 ;
    30.     // reg signal define
    31.     reg     [5:0]       state_c   ;
    32.     reg     [5:0]       state_n   ;
    33.     reg     [9:0]       cnt_750us ;
    34.     reg     [3:0]       cnt_aref  ;
    35.     reg                 cnt_ar    ;
    36.     // wire signal define 
    37.     wire                AREF_IDLEtoAREF_PCHA;    
    38.     wire                AREF_TRPtoAREF_REF  ;      
    39.     wire                AREF_TRFtoAREF_REF  ;      
    40.     wire                AREF_TRFtoAREF_END  ;      
    41.     /*************************************************************/
    42.     // reg     [5:0]       state_c   ;
    43.     always @(posedge sys_clk or negedge sys_rst_n) begin
    44.         if(~sys_rst_n) 
    45.             state_c <= AREF_IDLE ;
    46.         else 
    47.             state_c <= state_n ;
    48.     end
    49.     // reg     [5:0]       state_n   ;
    50.     always @(*) begin
    51.         case(state_c)
    52.         AREF_IDLE : if(AREF_IDLEtoAREF_PCHA)
    53.                         state_n = AREF_PCHA ;
    54.                     else 
    55.                         state_n = AREF_IDLE ;
    56.         AREF_PCHA : state_n = AREF_TRP ;
    57.         AREF_TRP  : if(AREF_TRPtoAREF_REF)
    58.                         state_n = AREF_REF ;
    59.                     else 
    60.                         state_n = AREF_TRP ;
    61.         AREF_REF  : state_n = AREF_TRF ;
    62.         AREF_TRF  : if(AREF_TRFtoAREF_END)
    63.                         state_n = AREF_END ;
    64.                     else if(AREF_TRFtoAREF_REF)
    65.                         state_n = AREF_REF ;
    66.                     else 
    67.                         state_n = AREF_TRF ;
    68.         AREF_END  : state_n = AREF_IDLE ;
    69.         default   : state_n = AREF_IDLE ;
    70.         endcase
    71.     end
    72.     assign  AREF_IDLEtoAREF_PCHA    = (state_c == AREF_IDLE) && ( aref_en  ) ; 
    73.     assign  AREF_TRPtoAREF_REF      = (state_c == AREF_TRP ) && ( cnt_aref ) ; 
    74.     assign  AREF_TRFtoAREF_REF      = (state_c == AREF_TRF ) && ( cnt_aref == 6 && ~cnt_ar ) ; 
    75.     assign  AREF_TRFtoAREF_END      = (state_c == AREF_TRF ) && ( cnt_aref == 6 &&  cnt_ar ) ; 
    76.     // reg     [9:0]       cnt_750us ;
    77.     always @(posedge sys_clk or negedge sys_rst_n) begin
    78.         if(~sys_rst_n) 
    79.             cnt_750us <= 10'd0 ;
    80.         else if(init_end) 
    81.             begin 
    82.                 if(cnt_750us == MAX_CNT_750US - 1)
    83.                     cnt_750us <= 10'd0 ;
    84.                 else 
    85.                     cnt_750us <= cnt_750us + 1'b1 ;
    86.             end
    87.             else
    88.                 cnt_750us <= 10'd0 ;
    89.     end
    90.     // reg     [3:0]       cnt_aref  ;
    91.     always @(posedge sys_clk or negedge sys_rst_n) begin
    92.         if(~sys_rst_n) 
    93.             cnt_aref <= 4'd0 ;
    94.         else
    95.         case (state_c)
    96.         AREF_IDLE : cnt_aref <= 4'd0 ;
    97.         AREF_PCHA : cnt_aref <= 4'd0 ;
    98.         AREF_TRP  : if(cnt_aref == T_RP -1)
    99.                         cnt_aref <= 4'd0 ;
    100.                     else    
    101.                         cnt_aref <= cnt_aref + 1'b1 ;
    102.         AREF_REF  : cnt_aref <= 4'd0 ;
    103.         AREF_TRF  : if(cnt_aref == T_RFC - 1)
    104.                         cnt_aref <= 4'd0 ;
    105.                     else    
    106.                         cnt_aref <= cnt_aref + 1'b1 ;
    107.         AREF_END  : cnt_aref <= 4'd0 ;
    108.         default   : cnt_aref <= 4'd0 ;
    109.         endcase
    110.     end
    111.     // reg                 cnt_ar    ;
    112.     always @(posedge sys_clk or negedge sys_rst_n) begin
    113.         if(~sys_rst_n) 
    114.             cnt_ar <= 1'b0 ;
    115.         else if(state_c == AREF_TRF && cnt_aref == T_RFC - 1) // 由于是一位宽的，就不用写归零情况了。
    116.             cnt_ar <= cnt_ar + 1'b1 ;
    117.         else 
    118.             cnt_ar <= cnt_ar ;
    119.     end
    120.     // output signal describe
    121.     // reg                 aref_req  ;
    122.     always @(posedge sys_clk or negedge sys_rst_n) begin
    123.         if(~sys_rst_n) 
    124.             aref_req <= 1'b0 ;
    125.         else if(cnt_750us == MAX_CNT_750US - 1)
    126.             aref_req <= 1'b1 ;
    127.         else if(state_c == AREF_PCHA)
    128.             aref_req <= 1'b0 ;
    129.         else 
    130.             aref_req <= aref_req ;
    131.     end
    132.     // reg     [3:0]       aref_cmd  ;
    133.     always @(posedge sys_clk or negedge sys_rst_n) begin
    134.         if(~sys_rst_n) 
    135.             aref_cmd <= 4'd0 ;
    136.         else
    137.         case (state_c)
    138.         AREF_IDLE : aref_cmd <= AREF_NOP ;
    139.         AREF_PCHA : aref_cmd <= AREF_PREC;
    140.         AREF_TRP  : aref_cmd <= AREF_NOP ;
    141.         AREF_REF  : aref_cmd <= AREF_REFC;
    142.         AREF_TRF  : aref_cmd <= AREF_NOP ;
    143.         AREF_END  : aref_cmd <= AREF_NOP ;
    144.         default   : aref_cmd <= AREF_NOP ;
    145.         endcase
    146.     end
    147.     // wire     [1:0]       aref_ba   ;
    148.     assign  aref_ba = 2'b11 ;
    149.     // reg     [12:0]      aref_addr ;
    150.     assign  aref_addr = 13'h1FFF ;
    151.     // wire                aref_end  ;
    152.     assign  aref_end = (state_c == AREF_END) ? 1'b1 : 1'b0 ;
    153. endmodule
    仿真：

    在仿真代码中模拟了一小部分仲裁。

    1. `timescale 1ns/1ns
    2. module test_sdram_aref ();
    3.     reg             sys_clk     ; // 50mHz
    4.     reg             sys_rst_n   ;
    5.  
    6.     reg             aref_en     ; // 自刷新模块的输入，应该是仲裁模块传出。
    7.  
    8.     wire    [3:0]   init_cmd    ; // 初始化模块的输出。
    9.     wire    [1:0]   init_ba     ;
    10.     wire    [12:0]  init_addr   ;
    11.     wire            init_end    ;
    12.  
    13.     wire            aref_req    ; // 自刷新模块输出
    14.     wire    [3:0]   aref_cmd    ; 
    15.     wire    [1:0]   aref_ba     ;  
    16.     wire    [12:0]  aref_addr   ;
    17.     wire            aref_end    ; 
    18.  
    19.     wire    [3:0]   sdram_cmd   ; 
    20.     wire    [1:0]   sdram_ba    ;  
    21.     wire    [12:0]  sdram_addr  ;
    22.     assign          sdram_cmd   = (init_end) ? aref_cmd  : init_cmd  ; // 经过仲裁后的命令与地址。
    23.     assign          sdram_ba    = (init_end) ? aref_ba   : init_ba   ;  
    24.     assign          sdram_addr  = (init_end) ? aref_addr : init_addr ;
    25.  
    26.     wire            c0_sig      ; // pll的输出。
    27.     wire            c1_sig      ;
    28.     wire            c2_sig      ;
    29.     wire            locked_sig  ;
    30.     wire            rst_n       ; // 全局复位。
    31.     assign          rst_n = sys_rst_n && (locked_sig) ;
    32. sdram_aref sdram_aref_inst(
    33.     .sys_clk                            ( c1_sig     ) ,
    34.     .sys_rst_n                          ( rst_n      ) ,
    35.     .init_end                           ( init_end   ) ,
    36.     .aref_en                            ( aref_en    ) ,
    37.   
    38.     .aref_req                           ( aref_req   ) ,
    39.     .aref_cmd                           ( aref_cmd   ) ,
    40.     .aref_ba                            ( aref_ba    ) ,
    41.     .aref_addr                          ( aref_addr  ) ,
    42.     .aref_end                           ( aref_end   ) 
    43. );
    44.  
    45. clk_gen	clk_gen_inst (
    46. 	.areset                             (~sys_rst_n  ) ,
    47. 	.inclk0                             ( sys_clk    ) ,
    48.  
    49. 	.c0                                 ( c0_sig     ) , // 50
    50. 	.c1                                 ( c1_sig     ) , // 100
    51. 	.c2                                 ( c2_sig     ) , // 100+shift30
    52. 	.locked                             ( locked_sig )
    53. );
    54.  
    55. sdram_model_plus sdram_model_plus_inst(
    56.     .Dq                                 (  ) , 
    57.     .Addr                               ( sdram_addr  ) , 
    58.     .Ba                                 ( sdram_ba    ) , 
    59.     .Clk                                ( c2_sig      ) , 
    60.     .Cke                                ( 1'b1        ) , 
    61.     .Cs_n                               ( sdram_cmd[3]) , 
    62.     .Ras_n                              ( sdram_cmd[2]) , 
    63.     .Cas_n                              ( sdram_cmd[1]) , 
    64.     .We_n                               ( sdram_cmd[0]) , 
    65.     .Dqm                                ( 2'b00       ) ,
    66.     .Debug                              ( 1'b1        )  
    67. );
    69. sdram_init sdram_init_inst(
    70.     .sys_clk                            ( c1_sig   ) , 
    71.     .sys_rst_n                          ( rst_n    ) ,
    73.     .init_cmd                           ( init_cmd ) ,
    74.     .init_ba                            ( init_ba  ) ,
    75.     .init_addr                          ( init_addr) ,
    76.     .init_end                           ( init_end )
    77. );
    79.     parameter   CYCLE = 20 ; // 10ns
    80.     defparam    sdram_model_plus_inst.addr_bits = 13 ;
    81.     defparam    sdram_model_plus_inst.data_bits = 16 ;
    82.     defparam    sdram_model_plus_inst.col_bits  = 9  ;
    83.     defparam    sdram_model_plus_inst.mem_sizes = 2*1024*1024  ;
    84.     // aref_en 仲裁
    85.     always @(posedge c1_sig or negedge sys_rst_n) begin
    86.         if(~sys_rst_n)
    87.             aref_en <= 1'b0 ;
    88.         else if(init_end && aref_req)
    89.             aref_en <= 1'b1 ;
    90.         else if(aref_end)
    91.             aref_en <= 1'b0 ;
    92.         else 
    93.             aref_en <= aref_en ;
    94.     end
    95.  
    96.     initial begin
    97.         sys_clk = 1'b1    ;
    98.         sys_rst_n <= 1'b0 ;
    99.         #(CYCLE)          ;
    100.         sys_rst_n <= 1'b1 ;
    101.         #(CYCLE * 250_00) ;
    102.     end
    103.     always #(CYCLE / 2) sys_clk = ~sys_clk ;
    104. endmodule

     sdram_write:

    设计思路：

     指令：激活指令0011，空指令0111，写指令0100，突发停止指令0110（也就是中止页写的指令）。

    由于使用的模式是突发一页的读写模式，给出列首地址后，会自动生成下一个地址。

    1，传送激活指令+bank地址+列地址，激活特定行。0011

    2，等待tRCD，激活时间。此过程中，传送空指令。0111

    3.tRCD时间结束后，传送写指令，同时A8~A0开始传送列地址（首地址），DQ开始传送要写入的数据。

    4，在最后一个数据写入后的下一个时钟周期写入突发中止指令。

    5，突发中止指令写入后，页写突发操作完成。0110

    但是在设计的时候，在页写突发指令完成后加了预充电指令。

    设计状态机时，把突发中止指令放进了写数据状态的最后。

    一个细节：在写指令传送时，DQ已经开始传递第一个数据了。

    sdram_en用作三态门的写数据使能，输出使能。

    第一部分：状态机。

     第二部分：数据写响应设计。wr_ack。

    第三部分：各输出信号的设计与实现。

    时序图：

    代码：
    1. // 模块说明：写数据模块，在初始化完成后，fifo_ctrl模块产生wr_req信号传给仲裁模块，仲裁模块传回写使能信号，开始写数据是时序传输。
    2. // input       wire    [23:0]      write_addr  , // 高两位是bank地址，中间13位为数据写入位置的行地址，后9位为列首地址。
    3. // input       wire    [9:0]       write_burst_len , // 写突发长度由fifo_ctrl模块给出。
    4. // output      wire                wr_sdram_en , // 用作三态输出使能信号。
    5. // wr_ack 传给fifo_ctrl模块，用来做读数据使能，告知fifo_ctrl模块，已经开始读时序了，请求信号可以拉低了。
    6. // wr_burst_len    , // 写突发长度，控制WR_DATA状态下传输数据的个数。每一行有512个存储单元。
    7. module sdram_write(
    8.     input       wire                sys_clk         ,
    9.     input       wire                sys_rst_n       ,
    10.     input       wire                init_end        ,
    11.     input       wire                wr_en           ,
    12.     input       wire    [23:0]      wr_addr         ,
    13.     input       wire    [15:0]      wr_data         ,
    14.     input       wire    [9:0]       wr_burst_len    , // 写突发长度，控制WR_DATA状态下传输数据的个数。
    15.  
    16.     output      reg     [3:0]       write_cmd       ,
    17.     output      reg     [1:0]       write_ba        ,
    18.     output      reg     [12:0]      write_addr      ,
    19.     output      wire                wr_end          ,
    20.     output      wire                wr_sdram_en     ,
    21.     output      wire    [15:0]      wr_sdram_data   ,
    22.     output      wire                wr_ack          
    23. );
    24.     // parameter
    25.     parameter   TRCD        = 2       ,
    26.                 TRP         = 2       ,
    27.                 NOP         = 4'b0111 ,
    28.                 ACTIVE      = 4'b0011 ,
    29.                 WRITE       = 4'b0100 ,
    30.                 B_STOP      = 4'b0110 ,
    31.                 P_CHARGE    = 4'b0010 ;
    32.     // localparam
    33.     localparam  WR_IDLE     = 3'b000 ,
    34.                 WR_ACTIVE   = 3'b001 ,
    35.                 WR_TRCD     = 3'b011 ,
    36.                 WR_WRITE    = 3'b010 ,
    37.                 WR_DATA     = 3'b110 ,
    38.                 WR_PRE      = 3'b111 ,
    39.                 WR_TRP      = 3'b101 ,
    40.                 WR_END      = 3'b100 ;
    42.     // reg signal define
    43.     reg     [2:0]       state_c      ;
    44.     reg     [2:0]       state_n      ;
    45.     reg     [9:0]       cnt_wr       ; // 位宽注意。
    46.     reg                 cnt_wr_rst   ; // 用组合逻辑赋值。
    47.     // wire dignal define
    48.     wire                trcd_end     ;
    49.     wire                twrite_end   ;
    50.     wire                trp_end      ;
    51.     wire                WR_IDLEtoWR_ACTIVE ;
    52.     wire                WR_TRCDtoWR_WRITE  ;
    53.     wire                WR_DATAtoWR_PRE    ;
    54.     wire                WR_TRPtoWR_END     ;
    55.     /********************************************************************/
    56.     // reg     [2:0]       state_c     ;
    57.     always @(posedge sys_clk or negedge sys_rst_n) begin
    58.         if(~sys_rst_n) 
    59.             state_c <= WR_IDLE ;
    60.         else
    61.             state_c <= state_n ;
    62.     end
    63.     // reg     [2:0]       state_n     ;
    64.     always @(*) begin
    65.         case(state_c)
    66.         WR_IDLE   : if(WR_IDLEtoWR_ACTIVE)
    67.                         state_n = WR_ACTIVE ;
    68.                     else 
    69.                         state_n = WR_IDLE ;
    70.         WR_ACTIVE : state_n = WR_TRCD ;
    71.         WR_TRCD   : if(WR_TRCDtoWR_WRITE)
    72.                         state_n = WR_WRITE ;
    73.                     else 
    74.                         state_n = WR_TRCD ;
    75.         WR_WRITE  : state_n = WR_DATA ;
    76.         WR_DATA   : if(WR_DATAtoWR_PRE)
    77.                         state_n = WR_PRE ;
    78.                     else 
    79.                         state_n = WR_DATA ;
    80.         WR_PRE    : state_n = WR_TRP ;
    81.         WR_TRP    : if(WR_TRPtoWR_END)
    82.                         state_n = WR_END ;
    83.                     else 
    84.                         state_n = WR_TRP ;
    85.         WR_END    : state_n = WR_IDLE ;
    86.         default   : state_n = WR_IDLE ;
    87.         endcase
    88.     end
    89.     assign  WR_IDLEtoWR_ACTIVE  = (state_c == WR_IDLE) && (wr_en     ) && (init_end);
    90.     assign  WR_TRCDtoWR_WRITE   = (state_c == WR_TRCD) && (trcd_end  ) && (init_end);
    91.     assign  WR_DATAtoWR_PRE     = (state_c == WR_DATA) && (twrite_end) && (init_end);
    92.     assign  WR_TRPtoWR_END      = (state_c == WR_TRP ) && (trp_end   ) && (init_end);
    93.     // reg     [9:0]       cnt_wr      ;
    94.     always @(posedge sys_clk or negedge sys_rst_n) begin
    95.         if(~sys_rst_n) 
    96.             cnt_wr <= 10'd0 ;
    97.         else if(cnt_wr_rst)
    98.             cnt_wr <= 10'd0 ;
    99.         else 
    100.             cnt_wr <= cnt_wr + 1'b1 ;
    101.     end
    102.     // reg                 cnt_wr_rst  ;
    103.     always @(*) begin
    104.         case(state_c)
    105.         WR_IDLE   : cnt_wr_rst = 1'b1 ;
    106.         WR_ACTIVE : cnt_wr_rst = trcd_end ;
    107.         WR_TRCD   : cnt_wr_rst = trcd_end ;
    108.         WR_WRITE  : cnt_wr_rst = 1'b1 ;
    109.         WR_DATA   : cnt_wr_rst = twrite_end ;
    110.         WR_PRE    : cnt_wr_rst = trp_end ;
    111.         WR_TRP    : cnt_wr_rst = trp_end ;
    112.         WR_END    : cnt_wr_rst = 1'b1 ;
    113.         default   : cnt_wr_rst = 1'b1 ;
    114.         endcase
    115.     end
    116.     // wire                trcd_end    ;
    117.     assign  trcd_end = (state_c == WR_TRCD && cnt_wr == TRCD) ? 1'b1 : 1'b0 ;
    118.     // wire                twrite_end  ;
    119.     assign  twrite_end = (state_c == WR_DATA && cnt_wr == (wr_burst_len - 1)) ? 1'b1 : 1'b0 ;
    120.     // wire                trp_end     ;
    121.     assign  trp_end = (state_c == WR_TRP && cnt_wr == TRP) ? 1'b1 : 1'b0 ;
    122.     // output signal describe
    123.     // wire                wr_end      ,
    124.     assign  wr_end = (state_c == WR_END) ? 1'b1 : 1'b0 ;
    125.     // reg     [3:0]       write_cmd   ,
    126.     // reg     [1:0]       write_ba    ,
    127.     // reg     [12:0]      write_addr  ,
    128.     always @(posedge sys_clk or negedge sys_rst_n) begin
    129.         if(~sys_rst_n) begin
    130.             write_cmd   <= NOP      ;
    131.             write_ba    <= 2'b11    ;
    132.             write_addr  <= 13'h1FFF ;
    133.         end else begin
    134.             case (state_c)
    135.             WR_IDLE  : 
    136.                 begin
    137.                     write_cmd   <= NOP      ;
    138.                     write_ba    <= 2'b11    ;
    139.                     write_addr  <= 13'h1FFF ;   
    140.                 end
    141.             WR_ACTIVE: 
    142.                 begin
    143.                     write_cmd   <= ACTIVE   ;
    144.                     write_ba    <= wr_addr[23:22] ;
    145.                     write_addr  <= wr_addr[21:9 ] ; //wr_addr[23:0]
    146.                 end
    147.             WR_TRCD  : 
    148.                 begin
    149.                     write_cmd   <= NOP      ;
    150.                     write_ba    <= 2'b11    ;
    151.                     write_addr  <= 13'h1FFF ;   
    152.                 end
    153.             WR_WRITE : 
    154.                 begin
    155.                     write_cmd   <= WRITE    ;
    156.                     write_ba    <= wr_addr[23:22] ;
    157.                     write_addr  <= {4'b0000,wr_addr[ 8:0 ]} ; 
    158.                 end
    159.             WR_DATA  : 
    160.                 if(!twrite_end)
    161.                 begin
    162.                     write_cmd   <= NOP      ;
    163.                     write_ba    <= 2'b11    ;
    164.                     write_addr  <= 13'h1FFF ;
    165.                 end
    166.                 else 
    167.                 begin
    168.                     write_cmd   <= B_STOP   ;
    169.                     write_ba    <= 2'b11    ;
    170.                     write_addr  <= 13'h1FFF ;
    171.                 end
    172.             WR_PRE   : 
    173.                 begin
    174.                     write_cmd   <= P_CHARGE ; // 预充电指令，一开始忘记赋值了。
    175.                     write_ba    <= wr_addr[23:22] ;
    176.                     write_addr  <= 13'h0400 ;
    177.                 end
    178.             WR_TRP   : 
    179.                 begin
    180.                     write_cmd   <= NOP      ;
    181.                     write_ba    <= 2'b11    ;
    182.                     write_addr  <= 13'h1FFF ;
    183.                 end
    184.             WR_END   : 
    185.                 begin
    186.                     write_cmd   <= NOP      ;
    187.                     write_ba    <= 2'b11    ;
    188.                     write_addr  <= 13'h1FFF ;
    189.                 end
    190.             default  : 
    191.                 begin
    192.                     write_cmd   <= NOP      ;
    193.                     write_ba    <= 2'b11    ;
    194.                     write_addr  <= 13'h1FFF ;
    195.                 end
    196.             endcase
    197.         end
    198.     end
    199.     // wire                wr_sdram_en ,
    200.     assign  wr_sdram_en = (state_c == WR_DATA) ? 1'b1 : 1'b0 ;
    201.     // reg     [15:0]      wr_sdram_data ,
    202.     assign  wr_sdram_data = (wr_sdram_en) ? wr_data : 16'd0 ;
    203.     // wire                wr_ack   
    204.     assign  wr_ack = (((state_c == WR_WRITE) || (state_c == WR_DATA)) && (cnt_wr <= wr_burst_len - 2)) ? 1'b1 : 1'b0 ;   
    205. endmodule
    1. `timescale 1ns/1ns
    2. module test_sdram_write ();
    3.     reg             sys_clk     ; // 50mHz
    4.     reg             sys_rst_n   ;
    5.  
    6.     wire    [3:0]   init_cmd    ;
    7.     wire    [1:0]   init_ba     ;
    8.     wire    [12:0]  init_addr   ;
    9.     wire            init_end    ;
    10.  
    11.     wire    [15:0]  sdram_data  ;
    12.     wire    [3:0]   sdram_cmd   ; 
    13.     wire    [1:0]   sdram_ba    ;  
    14.     wire    [12:0]  sdram_addr  ;
    15.  
    16.     wire            c0_sig      ;
    17.     wire            c1_sig      ;
    18.     wire            c2_sig      ;
    19.     wire            locked_sig  ;
    20.     wire            rst_n       ;
    21.     assign          rst_n = sys_rst_n && (locked_sig) ;
    22.  
    23.     reg             wr_en           ;
    24.     reg     [15:0]  wr_data         ;
    25.     wire    [3:0]   write_cmd       ;
    26.     wire    [1:0]   write_ba        ;
    27.     wire    [12:0]  write_addr      ;
    28.     wire            wr_end          ;
    29.     wire            wr_sdram_en     ;
    30.     wire    [15:0]  wr_sdram_data   ;
    31.     wire            wr_ack          ; 
    32.     reg             wr_en_flag      ;
    33.     always @(posedge c1_sig or negedge sys_rst_n) begin
    34.         if(~sys_rst_n)  
    35.             wr_en_flag <= 1'b0 ;
    36.         else if(wr_end)
    37.             wr_en_flag <= ~wr_en_flag ;
    38.     end
    39.     // always @(posedge c1_sig or negedge sys_rst_n) begin
    40.     //     if(~sys_rst_n) 
    41.     //         wr_en <= 1'b0 ;
    42.     //     else if(wr_end)
    43.     //         wr_en <= 1'b0 ;
    44.     //     else if(init_end && !wr_en_flag)
    45.     //         wr_en <= 1'b1 ;
    46.     //     else 
    47.     //         wr_en <= wr_en ;
    48.     // end
    49.     always @(posedge c1_sig or negedge sys_rst_n) begin
    50.         if(~sys_rst_n) 
    51.             wr_en <= 1'b0 ;
    52.         else if(wr_end)
    53.             wr_en <= 1'b0 ;
    54.         else if(init_end)
    55.             wr_en <= 1'b1 ;
    56.         else 
    57.             wr_en <= wr_en ;
    58.     end
    59.     always @(posedge c1_sig or negedge sys_rst_n) begin
    60.         if(~sys_rst_n)
    61.             wr_data <= 16'd0 ;
    62.         else if(wr_ack == 0)
    63.             wr_data <= 16'd0 ;
    64.         else
    65.             wr_data <= wr_data + 1'b1 ;
    66.     end
    67.     assign          sdram_cmd   = (init_end) ? write_cmd  : init_cmd  ; 
    68.     assign          sdram_ba    = (init_end) ? write_ba   : init_ba   ; 
    69.     assign          sdram_addr  = (init_end) ? write_addr : init_addr ;
    70.     assign          sdram_data  = (wr_sdram_en) ? wr_data : 16'hzzzz     ;
    71. sdram_write sdram_write_inst(
    72.     .sys_clk                ( c1_sig        ) ,
    73.     .sys_rst_n              ( rst_n         ) ,
    74.     .init_end               ( init_end      ) ,
    75.     .wr_en                  ( wr_en         ) ,
    76.     .wr_addr                ( 24'd0         ) ,
    77.     .wr_data                ( wr_data       ) ,
    78.     .wr_burst_len           ( 10            ) , // 写突发长度，控制WR_DATA状态下传输数据的个数。
    79.  
    80.     .write_cmd              ( write_cmd     ) ,
    81.     .write_ba               ( write_ba      ) ,
    82.     .write_addr             ( write_addr    ) ,
    83.     .wr_end                 ( wr_end        ) ,
    84.     .wr_sdram_en            ( wr_sdram_en   ) ,
    85.     .wr_sdram_data          ( wr_sdram_data ) ,
    86.     .wr_ack                 ( wr_ack        )  
    87. );
    88.  
    89.  
    90. clk_gen	clk_gen_inst (
    91. 	.areset             (~sys_rst_n     ) ,
    92. 	.inclk0             ( sys_clk       ) ,
    93.  
    94. 	.c0                 ( c0_sig        ) , // 50
    95. 	.c1                 ( c1_sig        ) , // 100
    96. 	.c2                 ( c2_sig        ) , // 100+shift30
    97. 	.locked             ( locked_sig    )
    98. );
    99. sdram_model_plus sdram_model_plus_inst(
    100.     .Dq                                 ( sdram_data  ) , 
    101.     .Addr                               ( sdram_addr  ) , 
    102.     .Ba                                 ( sdram_ba    ) , 
    103.     .Clk                                ( c2_sig      ) , 
    104.     .Cke                                ( 1'b1        ) , 
    105.     .Cs_n                               ( sdram_cmd[3]) , 
    106.     .Ras_n                              ( sdram_cmd[2]) , 
    107.     .Cas_n                              ( sdram_cmd[1]) , 
    108.     .We_n                               ( sdram_cmd[0]) , 
    109.     .Dqm                                ( 2'b00       ) ,
    110.     .Debug                              ( 1'b1        )  
    111. );
    113. sdram_init sdram_init_inst(
    114.     .sys_clk                            ( c1_sig   ) , 
    115.     .sys_rst_n                          ( rst_n    ) ,
    117.     .init_cmd                           ( init_cmd ) ,
    118.     .init_ba                            ( init_ba  ) ,
    119.     .init_addr                          ( init_addr) ,
    120.     .init_end                           ( init_end )
    121. );
    123.     parameter   CYCLE = 20 ; // 10ns
    124.     defparam    sdram_model_plus_inst.addr_bits = 13 ;
    125.     defparam    sdram_model_plus_inst.data_bits = 16 ;
    126.     defparam    sdram_model_plus_inst.col_bits  = 9  ;
    127.     defparam    sdram_model_plus_inst.mem_sizes = 2*1024*1024  ;
    128.     initial begin
    129.         sys_clk = 1'b1 ;
    130.         sys_rst_n <= 1'b0 ;
    131.         #(CYCLE) ;
    132.         sys_rst_n <= 1'b1 ;
    133.         #(CYCLE * 250_00) ;
    134.         $stop ;
    135.     end
    136.     always #(CYCLE / 2) sys_clk = ~sys_clk ;
    137. endmodule
    仿真：

    sdram_read:

    设计思路：

     1，传送激活指令（0011），同时传递bank地址与行地址，激活特定行。

    2，然后进入激活等待状态，等待时间tRCD，此过程中传送空指令。

    3， 然后传动读指令，同时A8~A0写入列地址。

    4，然后跳转到潜伏状态，3个clk，结束后，开始读数据。

    5，进入读数据状态。设读取的数据为N。

    6，从读指令周期开始计数，N个周期后，写入突发中止指令。

    7，突发中止指令写入后，DQ继续传送2个周期数据。数据传输完成后，sdram页突发读操作完成。

    8,然后要发预充电命令，进入预充电等待状态，结束后进入读结束状态。

     第一部分状态机；

    第二部分读突发中止指令应该何时写入？

     assign rd_bust_flag = (state_c == RD_DATA && cnt_clk == rd_bust_len - CL - 1).

    提前CL个时钟周期传送中止指令，又因为从零开始计数。

    第三部分输出信号。

    注意，写计数器时，先写归零条件，把它放在最高优先级。

    本模块偏移时钟向前移动和向后移动会造成很大的不同。

    由于我一开始设置的向后移动30，导致潜伏期状态，读数据状态，ack响应信号，与官方教程里的代码很不一样。

    由于时序图是仿照官方画的，和代码有很多不相符合的地方，但是对于代码而言只需改动两个地方。

    tcl_end与rd_bust_flag！！！！！！！！！！！

    时序图：

    代码：
    1. // 读时序产生模块。先传送激活指令，然后传送读指令，然后读突发中止指令，然后预充电指令。
    2. // 注意rd_data的跨时钟域处理。
    3. module sdram_read(
    4.     input       wire                sys_clk         ,
    5.     input       wire                sys_rst_n       ,
    6.     input       wire                init_end        ,
    7.     input       wire    [23:0]      rd_addr         ,
    8.     input       wire    [15:0]      rd_data         ,
    9.     input       wire    [9:0]       rd_burst_len    ,
    10.     input       wire                rd_en           ,
    11.  
    12.     output      wire                rd_end          ,
    13.     output      reg     [3:0]       read_cmd        ,
    14.     output      reg     [1:0]       read_ba         ,
    15.     output      reg     [12:0]      read_addr       ,
    16.     output      wire    [15:0]      rd_sdram_data   ,
    17.     output      wire                rd_ack          
    18. );
    19.     // parameter 
    20.     parameter   NOP       = 4'b0111 , // 空指令
    21.                 P_CHARGE  = 4'b0010 , // 预充电指令
    22.                 ACTIVE    = 4'b0011 , // 激活指令
    23.                 READ      = 4'b0101 , // 读指令
    24.                 B_STOP    = 4'b0110 ; // 读中止指令
    25.     parameter   T_RCD     = 2       , // 激活周等待期
    26.                 T_CL      = 3       , // 列潜伏
    27.                 T_RP      = 2       ; // 预充电
    28.     localparam  RD_IDLE   = 9'b0_0000_0001 , // 空闲状态
    29.                 RD_ACTIVE = 9'b0_0000_0010 , // 激活状态
    30.                 RD_TRCD   = 9'b0_0000_0100 , // 激活等待状态
    31.                 RD_READ   = 9'b0_0000_1000 , // 传送读指令状态
    32.                 RD_CL     = 9'b0_0001_0000 , // 潜伏状态
    33.                 RD_DATA   = 9'b0_0010_0000 , // 读数据状态
    34.                 RD_PRE    = 9'b0_0100_0000 , // 预充电指令传送状态
    35.                 RD_TRP    = 9'b0_1000_0000 , // 预充电等待状态
    36.                 RD_END    = 9'b1_0000_0000 ; // 读结束
    37.     // reg signal define
    38.     // reg     [15:0]      rd_data_reg ; 
    39.     reg     [9:0]       state_c     ;
    40.     reg     [9:0]       state_n     ; // 用的组合逻辑
    41.     reg     [9:0]       cnt_read    ;
    42.     reg                 cnt_rd_rst  ; // 用的组合逻辑
    43.     // wire signal define
    44.     wire                trcd_end    ;
    45.     wire                tcl_end     ;
    46.     wire                tread_end   ;
    47.     wire                trp_end     ;
    48.     wire                rd_bust_flag;
    49.     wire                RD_IDLEtoRD_ACTIVE  ;
    50.     wire                RD_TRCDtoRD_READ    ;
    51.     wire                RD_CLtoRD_DATA      ;
    52.     wire                RD_DATAto_RD_PRE    ;
    53.     wire                RD_TRPtoRD_END      ;
    54.     /****************************************************************************/
    55.     // // reg     [15:0]      rd_data_reg ; 
    56.     // always @(posedge sys_clk or negedge sys_rst_n) begin
    57.     //     if(~sys_rst_n) 
    58.     //         rd_data_reg <= 16'd0 ; 
    59.     //     else 
    60.     //         rd_data_reg <= rd_data ; 
    61.     // end
    62.     // reg     [9:0]       state_c     ;
    63.     always @(posedge sys_clk or negedge sys_rst_n) begin
    64.         if(~sys_rst_n) 
    65.             state_c <= RD_IDLE ;
    66.         else
    67.             state_c <= state_n ;
    68.     end
    69.     // reg     [9:0]       state_n     ;
    70.     always @(*) begin
    71.         case (state_c)
    72.         RD_IDLE   : if(RD_IDLEtoRD_ACTIVE)
    73.                         state_n = RD_ACTIVE ;
    74.                     else 
    75.                         state_n = RD_IDLE ;
    76.         RD_ACTIVE : state_n = RD_TRCD ;
    77.         RD_TRCD   : if(RD_TRCDtoRD_READ) // 可以写成三元运算符：state_n <= (RD_TRCDtoRD_READ) ? RD_READ : RD_TRCD ;
    78.                         state_n = RD_READ ;
    79.                     else 
    80.                         state_n = RD_TRCD ;
    81.         RD_READ   : state_n = RD_CL ;
    82.         RD_CL     : if(RD_CLtoRD_DATA)
    83.                         state_n = RD_DATA ;
    84.                     else 
    85.                         state_n = RD_CL ;
    86.         RD_DATA   : if(RD_DATAto_RD_PRE)
    87.                         state_n = RD_PRE ;
    88.                     else 
    89.                         state_n = RD_DATA ;
    90.         RD_PRE    : state_n = RD_TRP ;
    91.         RD_TRP    : if(RD_TRPtoRD_END)
    92.                         state_n = RD_END ;
    93.                     else 
    94.                         state_n = RD_TRP ;
    95.         RD_END    : state_n = RD_IDLE ;
    96.         default   : state_n = RD_IDLE ;
    97.         endcase
    98.     end
    99.     assign  RD_IDLEtoRD_ACTIVE  = ( state_c == RD_IDLE ) && ( rd_en    ) && ( init_end ) ;
    100.     assign  RD_TRCDtoRD_READ    = ( state_c == RD_TRCD ) && ( trcd_end ) && ( init_end ) ;
    101.     assign  RD_CLtoRD_DATA      = ( state_c == RD_CL   ) && ( tcl_end  ) && ( init_end ) ;
    102.     assign  RD_DATAto_RD_PRE    = ( state_c == RD_DATA ) && ( tread_end) && ( init_end ) ;
    103.     assign  RD_TRPtoRD_END      = ( state_c == RD_TRP  ) && ( trp_end  ) && ( init_end ) ;
    104.     // reg     [9:0]       cnt_read    ;
    105.     always @(posedge sys_clk or negedge sys_rst_n) begin
    106.         if(~sys_rst_n) 
    107.             cnt_read <= 10'd0 ;
    108.         else if(cnt_rd_rst)
    109.             cnt_read <= 10'd0 ;
    110.         else    
    111.             cnt_read <= cnt_read + 1'b1 ;
    112.     end
    113.     // wire                cnt_rd_rst  ;
    114.     always @(*) begin
    115.         case(state_c)
    116.         RD_IDLE   : cnt_rd_rst = 1'b1 ;
    117.         RD_ACTIVE : cnt_rd_rst = trcd_end ;
    118.         RD_TRCD   : cnt_rd_rst = trcd_end ;
    119.         RD_READ   : cnt_rd_rst = tcl_end ;
    120.         RD_CL     : cnt_rd_rst = tcl_end ;
    121.         RD_DATA   : cnt_rd_rst = tread_end ;
    122.         RD_PRE    : cnt_rd_rst = trp_end ;
    123.         RD_TRP    : cnt_rd_rst = trp_end ;
    124.         RD_END    : cnt_rd_rst = 1'b1 ;
    125.         default   : cnt_rd_rst = 1'b1 ; 
    126.         endcase
    127.     end
    128.     // wire                trcd_end    ;T_RP
    129.     assign  trcd_end = (state_c == RD_TRCD && cnt_read == T_RCD) ? 1'b1 : 1'b0 ;
    130.     // wire                tcl_end     ;
    131.     assign  tcl_end  = (state_c == RD_CL   && cnt_read == T_CL - 1) ? 1'b1 : 1'b0 ; // 注意这里时序图多画了一个时钟周期。要计数到2，而不是3。
    132.     // wire                tread_end   ;
    133.     assign  tread_end= (state_c == RD_DATA && cnt_read == rd_burst_len) ? 1'b1 : 1'b0 ;
    134.     // wire                trp_end     ;
    135.     assign  trp_end  = (state_c == RD_TRP  && cnt_read == T_RP) ? 1'b1 : 1'b0 ;
    136.     // wire                rd_bust_flag;
    137.     assign  rd_bust_flag = (state_c == RD_DATA && cnt_read == (rd_burst_len - T_CL)) ? 1'b1 : 1'b0 ;
    138.     // // output 
    139.     // wire                rd_end       ;
    140.     assign  rd_end  = (state_c == RD_END) ? 1'b1 : 1'b0 ;
    141.     // reg     [3:0]       read_cmd     ;
    142.     // reg     [1:0]       read_ba      ;
    143.     // reg     [12:0]      read_addr    ;
    144.     always @(posedge sys_clk or negedge sys_rst_n) begin
    145.         if(~sys_rst_n) 
    146.         begin
    147.             read_cmd  <= NOP ;
    148.             read_ba   <= 2'b11 ;
    149.             read_addr <= 13'h1FFF ;
    150.         end
    151.         else 
    152.         case (state_c)
    153.         RD_IDLE   : 
    154.                     begin
    155.                         read_cmd  <= NOP ;
    156.                         read_ba   <= 2'b11 ;
    157.                         read_addr <= 13'h1FFF ;
    158.                     end
    159.         RD_ACTIVE : 
    160.                     begin
    161.                         read_cmd  <= ACTIVE ;
    162.                         read_ba   <= rd_addr[23:22] ;
    163.                         read_addr <= rd_addr[21:9] ;
    164.                     end
    165.         RD_TRCD   : 
    166.                     begin
    167.                         read_cmd  <= NOP ;
    168.                         read_ba   <= 2'b11 ;
    169.                         read_addr <= 13'h1FFF ;
    170.                     end
    171.         RD_READ   : 
    172.                     begin
    173.                         read_cmd  <= READ ;
    174.                         read_ba   <= rd_addr[23:22] ;
    175.                         read_addr <= rd_addr[8:0] ;
    176.                     end
    177.         RD_CL     : 
    178.                     begin
    179.                         read_cmd  <= NOP ;
    180.                         read_ba   <= 2'b11 ;
    181.                         read_addr <= 13'h1FFF ;
    182.                     end
    183.         RD_DATA   : 
    184.                     if(!rd_bust_flag)
    185.                     begin
    186.                         read_cmd  <= NOP ;
    187.                         read_ba   <= 2'b11 ;
    188.                         read_addr <= 13'h1FFF ;
    189.                     end
    190.                     else
    191.                     begin
    192.                         read_cmd  <= B_STOP ;
    193.                         read_ba   <= 2'b11 ;
    194.                         read_addr <= 13'h1FFF ;
    195.                     end
    196.         RD_PRE    : 
    197.                     begin
    198.                         read_cmd  <= P_CHARGE ;
    199.                         read_ba   <= rd_addr[23:22] ;
    200.                         read_addr <= 13'h0400 ; // 辅助预充电，选中所有bank 
    201.                     end
    202.         RD_TRP    : 
    203.                     begin
    204.                         read_cmd  <= NOP ;
    205.                         read_ba   <= 2'b11 ;
    206.                         read_addr <= 13'h1FFF ;
    207.                     end
    208.         RD_END    : 
    209.                     begin
    210.                         read_cmd  <= NOP ;
    211.                         read_ba   <= 2'b11 ;
    212.                         read_addr <= 13'h1FFF ;
    213.                     end
    214.         default   : 
    215.                     begin
    216.                         read_cmd  <= NOP ;
    217.                         read_ba   <= 2'b11 ;
    218.                         read_addr <= 13'h1FFF ;
    219.                     end
    220.         endcase
    221.     end
    222.     // wire    [15:0]      rd_sdram_data;
    223.     assign  rd_sdram_data = (rd_ack) ? rd_data : 16'd0 ; // rd_data_reg
    224.     // wire                rd_ack       ;
    225.     assign  rd_ack = (state_c == RD_DATA && (cnt_read >= 1 && cnt_read <= rd_burst_len)) ? 1'b1 : 1'b0 ;
    226. endmodule
    1. `timescale 1ns/1ns
    2. module test_sdram_read ();
    3. //
    4.  
    5. reg                 rd_en           ;
    6.  
    7. wire                rd_end          ;
    8. wire    [3:0]       read_cmd        ;
    9. wire    [1:0]       read_ba         ;
    10. wire    [12:0]      read_addr       ;
    11. wire    [15:0]      rd_sdram_data   ;
    12. wire                rd_ack          ;
    13. //
    14.     reg             sys_clk     ; // 50mHz
    15.     reg             sys_rst_n   ;
    16.  
    17.     wire    [3:0]   init_cmd    ;
    18.     wire    [1:0]   init_ba     ;
    19.     wire    [12:0]  init_addr   ;
    20.     wire            init_end    ;
    21.  
    22.     wire    [15:0]  sdram_data  ;
    23.     wire    [3:0]   sdram_cmd   ; 
    24.     wire    [1:0]   sdram_ba    ;  
    25.     wire    [12:0]  sdram_addr  ;
    26.  
    27.     wire            c0_sig      ;
    28.     wire            c1_sig      ;
    29.     wire            c2_sig      ;
    30.     wire            locked_sig  ;
    31.     wire            rst_n       ;
    32.     assign          rst_n = sys_rst_n && (locked_sig) ;
    33.  
    34.     reg             wr_en           ;
    35.     reg     [15:0]  wr_data         ;
    36.     wire    [3:0]   write_cmd       ;
    37.     wire    [1:0]   write_ba        ;
    38.     wire    [12:0]  write_addr      ;
    39.     wire            wr_end          ;
    40.     wire            wr_sdram_en     ;
    41.     wire    [15:0]  wr_sdram_data   ;
    42.     wire            wr_ack          ; 
    43.     reg             wr_en_flag      ;
    44.     always @(posedge c1_sig or negedge sys_rst_n) begin
    45.         if(~sys_rst_n)  
    46.             wr_en_flag <= 1'b0 ;
    47.         else if(wr_end)
    48.             wr_en_flag <= ~wr_en_flag ;
    49.     end
    50.     always @(posedge c1_sig or negedge sys_rst_n) begin
    51.         if(~sys_rst_n) 
    52.             wr_en <= 1'b0 ;
    53.         else if(wr_end)
    54.             wr_en <= 1'b0 ;
    55.         else if(init_end && !wr_en_flag)
    56.             wr_en <= 1'b1 ;
    57.         else 
    58.             wr_en <= wr_en ;
    59.     end
    60.     // always @(posedge c1_sig or negedge sys_rst_n) begin
    61.     //     if(~sys_rst_n) 
    62.     //         wr_en <= 1'b0 ;
    63.     //     else if(wr_end)
    64.     //         wr_en <= 1'b0 ;
    65.     //     else if(init_end)
    66.     //         wr_en <= 1'b1 ;
    67.     //     else 
    68.     //         wr_en <= wr_en ;
    69.     // end
    70.     reg     rd_en_flag ;
    71.     always @(posedge c1_sig or negedge sys_rst_n) begin
    72.         if(~sys_rst_n)  
    73.             rd_en_flag <= 1'b0 ;
    74.         else if(rd_end)
    75.             rd_en_flag <= ~rd_en_flag ;
    76.     end
    77.     always @(posedge c1_sig or negedge sys_rst_n) begin
    78.         if(~sys_rst_n) 
    79.             rd_en <= 1'b0 ;
    80.         else if(rd_end || rd_en_flag)
    81.             rd_en <= 1'b0 ;
    82.         else if(init_end == 1 && wr_en == 0 && wr_en_flag == 1 && ~rd_en_flag)
    83.             rd_en <= 1'b1 ;
    84.         else 
    85.             rd_en <= rd_en ;
    86.     end 
    87.     always @(posedge c1_sig or negedge sys_rst_n) begin
    88.         if(~sys_rst_n)
    89.             wr_data <= 16'd0 ;
    90.         else if(wr_ack == 0)
    91.             wr_data <= 16'd0 ;
    92.         else
    93.             wr_data <= wr_data + 1'b1 ;
    94.     end
    95.     assign          sdram_cmd   = (init_end) ? (( wr_en ) ?  write_cmd  : read_cmd ) : init_cmd  ; 
    96.     assign          sdram_ba    = (init_end) ? (( wr_en ) ?  write_ba   : read_ba  ) : init_ba   ; 
    97.     assign          sdram_addr  = (init_end) ? (( wr_en ) ?  write_addr : read_addr) : init_addr ;
    98.     assign          sdram_data  = (wr_sdram_en) ? wr_data : 16'hzzzz     ;
    99. sdram_read sdram_read_inst(
    100.     .sys_clk                ( c1_sig       ) ,
    101.     .sys_rst_n              ( rst_n        ) ,
    102.     .init_end               ( init_end     ) ,
    103.     .rd_addr                ( 24'd0        ) ,
    104.     .rd_data                ( sdram_data   ) ,
    105.     .rd_burst_len           ( 10'd20       ) ,
    106.     .rd_en                  ( rd_en        ) ,
    108.     .rd_end                 ( rd_end       ) ,
    109.     .read_cmd               ( read_cmd     ) ,
    110.     .read_ba                ( read_ba      ) ,
    111.     .read_addr              ( read_addr    ) ,
    112.     .rd_sdram_data          ( rd_sdram_data) ,
    113.     .rd_ack                 ( rd_ack       )  
    114. );
    115. sdram_write sdram_write_inst(
    116.     .sys_clk                ( c1_sig        ) ,
    117.     .sys_rst_n              ( rst_n         ) ,
    118.     .init_end               ( init_end      ) ,
    119.     .wr_en                  ( wr_en         ) ,
    120.     .wr_addr                ( 24'd0         ) ,
    121.     .wr_data                ( wr_data       ) ,
    122.     .wr_burst_len           ( 10            ) , // 写突发长度，控制WR_DATA状态下传输数据的个数。
    123.  
    124.     .write_cmd              ( write_cmd     ) ,
    125.     .write_ba               ( write_ba      ) ,
    126.     .write_addr             ( write_addr    ) ,
    127.     .wr_end                 ( wr_end        ) ,
    128.     .wr_sdram_en            ( wr_sdram_en   ) ,
    129.     .wr_sdram_data          ( wr_sdram_data ) ,
    130.     .wr_ack                 ( wr_ack        )  
    131. );
    132.  
    133.  
    134. clk_gen	clk_gen_inst (
    135. 	.areset             (~sys_rst_n     ) ,
    136. 	.inclk0             ( sys_clk       ) ,
    137.  
    138. 	.c0                 ( c0_sig        ) , // 50
    139. 	.c1                 ( c1_sig        ) , // 100
    140. 	.c2                 ( c2_sig        ) , // 100+shift30
    141. 	.locked             ( locked_sig    )
    142. );
    143. sdram_model_plus sdram_model_plus_inst(
    144.     .Dq                                 ( sdram_data  ) , 
    145.     .Addr                               ( sdram_addr  ) , 
    146.     .Ba                                 ( sdram_ba    ) , 
    147.     .Clk                                ( c2_sig      ) , 
    148.     .Cke                                ( 1'b1        ) , 
    149.     .Cs_n                               ( sdram_cmd[3]) , 
    150.     .Ras_n                              ( sdram_cmd[2]) , 
    151.     .Cas_n                              ( sdram_cmd[1]) , 
    152.     .We_n                               ( sdram_cmd[0]) , 
    153.     .Dqm                                ( 2'b00       ) ,
    154.     .Debug                              ( 1'b1        )  
    155. );
    157. sdram_init sdram_init_inst(
    158.     .sys_clk                            ( c1_sig   ) , 
    159.     .sys_rst_n                          ( rst_n    ) ,
    161.     .init_cmd                           ( init_cmd ) ,
    162.     .init_ba                            ( init_ba  ) ,
    163.     .init_addr                          ( init_addr) ,
    164.     .init_end                           ( init_end )
    165. );
    167.     parameter   CYCLE = 20 ; // 10ns
    168.     defparam    sdram_model_plus_inst.addr_bits = 13 ;
    169.     defparam    sdram_model_plus_inst.data_bits = 16 ;
    170.     defparam    sdram_model_plus_inst.col_bits  = 9  ;
    171.     defparam    sdram_model_plus_inst.mem_sizes = 2*1024*1024  ;
    172.     initial begin
    173.         sys_clk = 1'b1 ;
    174.         sys_rst_n <= 1'b0 ;
    175.         #(CYCLE) ;
    176.         sys_rst_n <= 1'b1 ;
    177.         #(CYCLE * 250_00) ;
    178.         $stop ;
    179.     end
    180.     always #(CYCLE / 2) sys_clk = ~sys_clk ;
    181. endmodule
    仿真：

     sdram_arbit:

    设计思路：

    仲裁模块通过状态机协调各个模块的正常进行，每项操作的实现都需要对sdram写入对应操作指令，且各项操作指令不同，为了方便赋值与准确传输指令，内部声明sdram_cmd信号，用来保存不同状态下对应的指令。

    如状态机所示：

    we_n:写使能有效信号，低电平有效，使能写操作和预充电。

     

    时序图：

    看着状态机与之前画的时序图就能写出来代码。

    代码：
    1. module  sdram_arbit(
    2.     input       wire            sys_clk   ,
    3.     input       wire            sys_rst_n ,
    4.  
    5.     input       wire    [3:0]   init_cmd  ,
    6.     input       wire    [1:0]   init_ba   ,
    7.     input       wire    [12:0]  init_addr ,
    8.     input       wire            init_end  ,
    9.  
    10.     input       wire            aref_req  ,
    11.     input       wire    [3:0]   aref_cmd  ,
    12.     input       wire    [1:0]   aref_ba   ,
    13.     input       wire    [12:0]  aref_addr ,
    14.     input       wire            aref_end  ,
    15.  
    16.     input       wire            read_req  ,
    17.     input       wire    [3:0]   read_cmd  ,
    18.     input       wire    [1:0]   read_ba   ,
    19.     input       wire    [12:0]  read_addr ,
    20.     input       wire            read_end  ,
    21.  
    22.     input       wire            write_req ,
    23.     input       wire    [3:0]   write_cmd ,
    24.     input       wire    [1:0]   write_ba  ,
    25.     input       wire    [12:0]  write_addr,
    26.     input       wire            wr_end    ,
    27.     input       wire            wr_sdram_en   ,
    28.     input       wire    [15:0]  wr_sdram_data ,
    29.  
    30.     output      wire            sdram_cke , // 时钟使能
    31.     output      wire            sdram_csn ,
    32.     output      wire            sdram_ras ,
    33.     output      wire            sdram_cas ,
    34.     output      wire            sdram_wen , // 写使能。
    35.     output      reg     [1:0]   sdram_bank,
    36.     output      reg     [12:0]  sdram_addr,
    37.  
    38.     inout       wire    [15:0]  sdram_dq  ,
    39.  
    40.     output      wire            aref_en   ,
    41.     output      wire            write_en  ,
    42.     output      wire            read_en   
    43. );
    44.     // localparam
    45.     localparam  NOP   = 4'b0111   ;
    46.     localparam  INIT  = 5'b0_0001 ,
    47.                 ARBIT = 5'b0_0010 , // 仲裁状态
    48.                 WRITE = 5'b0_0100 ,
    49.                 READ  = 5'b0_1000 ,
    50.                 AREF  = 5'b1_0000 ;
    51.  
    52.     // reg signal define
    53.     reg     [4:0]   state_c   ;
    54.     reg     [4:0]   state_n   ;
    55.     reg     [3:0]   sdram_cmd ; // 组合逻辑
    56.     // wire signal define
    57.     wire            INITtoARBIT ; 
    58.     wire            ARBITtoAREF ; 
    59.     wire            ARBITtoWRITE;
    60.     wire            ARBITtoREAD ; 
    61.     wire            WRITEtoARBIT;
    62.     wire            READtoARBIT ; 
    63.     wire            AREFtoARBIT ; 
    64.     /****************************************************************/
    65.     // reg     [4:0]   state_c   ;
    66.     always @(posedge sys_clk or negedge sys_rst_n) begin
    67.         if(~sys_rst_n) 
    68.             state_c <= INIT ;
    69.         else 
    70.             state_c <= state_n ;
    71.     end
    72.     // reg     [4:0]   state_n   ;
    73.     always @(*) begin
    74.         case(state_c)
    75.         INIT  : 
    76.                 if(INITtoARBIT)
    77.                     state_n = ARBIT ;
    78.                 else 
    79.                     state_n = INIT ;
    80.         ARBIT : 
    81.                 if(ARBITtoAREF)
    82.                     state_n = AREF ;
    83.                 else if(ARBITtoWRITE)
    84.                     state_n = WRITE ;
    85.                 else if(ARBITtoREAD)
    86.                     state_n = READ ;
    87.                 else 
    88.                     state_n = ARBIT ;
    89.         WRITE : 
    90.                 if(WRITEtoARBIT)
    91.                     state_n = ARBIT ;
    92.                 else 
    93.                     state_n = WRITE ;
    94.         READ  : 
    95.                 if(READtoARBIT)
    96.                     state_n = ARBIT ;
    97.                 else 
    98.                     state_n = READ ;
    99.         AREF  : if(AREFtoARBIT)
    100.                     state_n = ARBIT ;
    101.                 else 
    102.                     state_n = AREF ;
    103.         default:    state_n = ARBIT ;
    104.         endcase
    105.     end
    106.     assign  INITtoARBIT     = ( state_c == INIT  ) && ( init_end    ) ;
    107.     assign  ARBITtoAREF     = ( state_c == ARBIT ) && ( aref_req    ) ;
    108.     assign  ARBITtoWRITE    = ( state_c == ARBIT ) && ( write_req   ) ;
    109.     assign  ARBITtoREAD     = ( state_c == ARBIT ) && ( read_req    ) ;
    110.     assign  WRITEtoARBIT    = ( state_c == WRITE ) && ( wr_end      ) ;
    111.     assign  READtoARBIT     = ( state_c == READ  ) && ( read_end    ) ;
    112.     assign  AREFtoARBIT     = ( state_c == AREF  ) && ( aref_end    ) ;
    113.     // output 
    114.     // wire            sdram_cke , 
    115.     assign  sdram_cke = 1'b1 ;
    116.     // wire            sdram_csn ,
    117.     // wire            sdram_ras ,
    118.     // wire            sdram_cas ,
    119.     // wire            sdram_wen , 
    120.     assign  sdram_csn = sdram_cmd[3] ;
    121.     assign  sdram_ras = sdram_cmd[2] ;
    122.     assign  sdram_cas = sdram_cmd[1] ;
    123.     assign  sdram_wen = sdram_cmd[0] ;
    124.     // assign {sdram_cs_n, sdram_ras_n, sdram_cas_n, sdram_we_n} = sdram_cmd;
    125.     // reg     [3:0]   sdram_cmd ;
    126.     // reg     [1:0]   sdram_bank,
    127.     // reg     [12:0]  sdram_addr,
    128.     always @(*) begin
    129.         case (state_c)
    130.         INIT  : 
    131.                 begin
    132.                     sdram_cmd  = init_cmd  ;
    133.                     sdram_bank = init_ba   ;
    134.                     sdram_addr = init_addr ;
    135.                 end
    136.         ARBIT : 
    137.                 begin
    138.                     sdram_cmd  = NOP      ;
    139.                     sdram_bank = 2'b11    ;
    140.                     sdram_addr = 13'h1FFF ;
    141.                 end
    142.         WRITE : 
    143.                 begin
    144.                     sdram_cmd  = write_cmd  ;
    145.                     sdram_bank = write_ba   ;
    146.                     sdram_addr = write_addr ;
    147.                 end
    148.         READ  : 
    149.                 begin
    150.                     sdram_cmd  = read_cmd  ;
    151.                     sdram_bank = read_ba   ;
    152.                     sdram_addr = read_addr ;
    153.                 end
    154.         AREF  : 
    155.                 begin
    156.                     sdram_cmd  = aref_cmd  ;
    157.                     sdram_bank = aref_ba   ;
    158.                     sdram_addr = aref_addr ;
    159.                 end
    160.         default:    
    161.                 begin
    162.                     sdram_cmd  = NOP      ;
    163.                     sdram_bank = 2'b11    ;
    164.                     sdram_addr = 13'h1FFF ;
    165.                 end
    166.         endcase
    167.     end
    168.     // wire    [15:0]  sdram_dq  ,
    169.     assign  sdram_dq = (wr_sdram_en) ? wr_sdram_data : 16'hzzzz ;
    170.     // wire            aref_en   ,
    171.     assign  aref_en  = (state_c == AREF) ? 1'b1 : 1'b0 ; // 灵活运用三段式状态机。
    172.     // wire            write_en  ,
    173.     assign  write_en  = (state_c == WRITE) ? 1'b1 : 1'b0 ;
    174.     // wire            read_en    
    175.     assign  read_en  = (state_c == READ) ? 1'b1 : 1'b0 ;
    176.  
    177. endmodule
    1. `timescale 1ns/1ns
    2. module test_sdram_ctrl();
    3.     reg             sys_clk     ; // 50mHz
    4.     reg             sys_rst_n   ;
    5.  
    6.  
    7.     wire            c0_sig      ;
    8.     wire            c1_sig      ;
    9.     wire            c2_sig      ;
    10.     wire            locked_sig  ;
    11.     wire            rst_n       ;
    12.     assign          rst_n = sys_rst_n && (locked_sig) ;
    13.  
    14.     wire            wr_end ; // 需要从sdram_write模块引出。
    15.     assign  wr_end = sdram_ctrl_inst.sdram_write_inst.wr_end ;
    16.     // sdram_ctrl模块输入端口信号。
    17.     reg             sdram_wr_req  ;
    18.     reg     [23:0]  sdram_wr_addr ;
    19.     reg     [15:0]  sdram_wr_data ;
    20.     reg     [9:0]   sdram_wr_bust ;
    21.  
    22.     reg             sdram_rd_req  ;
    23.     reg     [23:0]  sdram_rd_addr ;
    24.     reg     [9:0]   sdram_rd_bust ;
    25.     // sdram_ctrl模块的输出信号。
    26.     wire            sdram_sck     ;
    27.     wire            sdram_cke     ; 
    28.     wire            sdram_csn     ;
    29.     wire            sdram_ras     ;
    30.     wire            sdram_cas     ;
    31.     wire            sdram_wen     ; 
    32.     wire    [1:0]   sdram_bank    ;
    33.     wire    [12:0]  sdram_addr    ;
    34.     wire    [15:0]  sdram_dq      ;
    35.     wire            sdram_wr_ack  ;
    36.     wire            sdram_rd_ack  ;
    37.     wire            sdram_init_end;
    38.     wire    [15:0]  sdram_data_out;
    39.  
    40. clk_gen	clk_gen_inst (
    41. 	.areset                     (~sys_rst_n      ) ,
    42. 	.inclk0                     ( sys_clk        ) ,
    43.  
    44. 	.c0                         ( c0_sig         ) , // 50
    45. 	.c1                         ( c1_sig         ) , // 100
    46. 	.c2                         ( c2_sig         ) , // 100+shift30
    47. 	.locked                     ( locked_sig     )
    48. );
    49. sdram_ctrl sdram_ctrl_inst(
    50.     .sys_clk                    ( c1_sig         ) ,
    51.     .sys_rst_n                  ( rst_n          ) ,
    52.     .clk_shift                  ( c2_sig         ) ,
    53.  
    54.     .sdram_wr_req               ( sdram_wr_req   ) ,
    55.     .sdram_wr_addr              ( sdram_wr_addr  ) ,
    56.     .sdram_wr_data              ( sdram_wr_data  ) ,
    57.     .sdram_wr_bust              ( sdram_wr_bust  ) ,
    58.  
    59.     .sdram_rd_req               ( sdram_rd_req   ) ,
    60.     .sdram_rd_addr              ( sdram_rd_addr  ) ,
    61.     .sdram_rd_bust              ( sdram_rd_bust  ) ,
    62.  
    63.     .sdram_sck                  ( sdram_sck      ) ,        
    64.     .sdram_cke                  ( sdram_cke      ) ,         // 时钟使能
    65.     .sdram_csn                  ( sdram_csn      ) ,        
    66.     .sdram_ras                  ( sdram_ras      ) ,        
    67.     .sdram_cas                  ( sdram_cas      ) ,        
    68.     .sdram_wen                  ( sdram_wen      ) ,         // 写使能。
    69.     .sdram_bank                 ( sdram_bank     ) ,        
    70.     .sdram_addr                 ( sdram_addr     ) ,        
    71.  
    72.     .sdram_dq                   ( sdram_dq       ) ,        
    73.  
    74.     .sdram_wr_ack               ( sdram_wr_ack   ) ,        
    75.     .sdram_rd_ack               ( sdram_rd_ack   ) ,        
    76.     .sdram_init_end             ( sdram_init_end ) ,        
    77.     .sdram_data_out             ( sdram_data_out ) 
    78. );      
    79. sdram_model_plus sdram_model_plus_inst(
    80.     .Dq                         ( sdram_dq       ) , 
    81.     .Addr                       ( sdram_addr     ) , 
    82.     .Ba                         ( sdram_bank     ) , 
    83.     .Clk                        ( sdram_sck      ) , 
    84.     .Cke                        ( sdram_cke      ) , 
    85.     .Cs_n                       ( sdram_csn      ) , 
    86.     .Ras_n                      ( sdram_ras      ) , 
    87.     .Cas_n                      ( sdram_cas      ) , 
    88.     .We_n                       ( sdram_wen      ) , 
    89.     .Dqm                        ( 2'b00          ) ,
    90.     .Debug                      ( 1'b1           )  
    91. );
    92.  
    93.     parameter   CYCLE = 20 ; // 10ns
    94.     defparam    sdram_model_plus_inst.addr_bits = 13 ;
    95.     defparam    sdram_model_plus_inst.data_bits = 16 ;
    96.     defparam    sdram_model_plus_inst.col_bits  = 9  ;
    97.     defparam    sdram_model_plus_inst.mem_sizes = 2*1024*1024  ;
    98.     defparam    sdram_ctrl_inst.sdram_aref_inst.MAX_CNT_750US = 75 ;
    99.     /**********************************************************************/
    100.     reg     init_end_reg1 ;
    101.     reg     init_end_reg2 ;
    102.     wire    wr_flag ;
    103.     always @(posedge c1_sig or negedge rst_n) begin
    104.         if(~rst_n) begin
    105.             init_end_reg1 <= 1'b0 ;
    106.             init_end_reg2 <= 1'b0 ;
    107.         end 
    108.         else begin
    109.             init_end_reg1 <= sdram_init_end ;
    110.             init_end_reg2 <= init_end_reg1 ;
    111.         end
    112.     end
    113.     assign  wr_flag = init_end_reg1 && ~init_end_reg2 ;
    114.     // reg             sdram_wr_req  ;
    115.     always @(posedge c1_sig or negedge rst_n) begin
    116.         if(~rst_n) 
    117.             sdram_wr_req <= 1'b0 ;
    118.         else if(wr_flag) // 初始化完成之后第一个始终周期就拉高写亲求。
    119.             sdram_wr_req <= 1'b1 ;
    120.         else if(sdram_wr_ack) // sdram_ctrl回应给FIFO控制模块一个写响应信号后，写请求就可以拉低了。
    121.             sdram_wr_req <= 1'b0 ;
    122.         else    
    123.             sdram_wr_req <= sdram_wr_req ;
    124.     end
    125.     // reg     [23:0]  sdram_wr_addr ;
    126.     // reg     [15:0]  sdram_wr_data ;
    127.     // reg     [9:0]   sdram_wr_bust ;
    128.     always @(posedge c1_sig or negedge sys_rst_n) begin
    129.         if(~sys_rst_n)
    130.             sdram_wr_data <= 16'd0 ;
    131.         else if(sdram_wr_ack == 0)
    132.             sdram_wr_data <= 16'd0 ;
    133.         else
    134.             sdram_wr_data <= sdram_wr_data + 1'b1 ;
    135.     end
    136.     initial begin
    137.         sdram_wr_addr <= 24'd0 ; // bank00,行13'd0,列9'd0;
    138.         sdram_wr_bust <= 10'd20 ; // 写入10个数据。
    139.     end 
    140.     // reg             sdram_rd_req  ;
    141.     // always @(posedge c1_sig or negedge sys_rst_n) begin
    142.     //     if(~rst_n)
    143.     //         sdram_rd_req <= 1'b0;
    144.     //     else if(wr_end) // 写操作结束后拉高读请求信号。
    145.     //         sdram_rd_req >= 1'b1 ;
    146.     //     else if(sdram_rd_ack) // 读响应信号拉高后，读请求信号拉低。
    147.     //         sdram_rd_req <= 1'b0;
    148.     //     else
    149.     //         sdram_rd_req <= sdram_rd_req ;
    150.     // end
    151.     always @(posedge c1_sig or negedge sys_rst_n) begin
    152.         if(~rst_n)
    153.             sdram_rd_req <= 1'b0 ;
    154.         else if(wr_end) 
    155.             sdram_rd_req <= 1'b1 ;
    156.         else 
    157.             sdram_rd_req <= sdram_rd_req ;
    158.     end
    159.     // reg     [23:0]  sdram_rd_addr ;
    160.     // reg     [9:0]   sdram_rd_bust ;
    161.     initial begin
    162.         sdram_rd_addr <= 24'd0 ; 
    163.         sdram_rd_bust <= 10'd13 ;
    164.     end 
    165.     initial begin
    166.         sys_clk = 1'b1 ;
    167.         sys_rst_n <= 1'b0 ;
    168.         #(CYCLE) ;
    169.         sys_rst_n <= 1'b1 ;
    170.         #(CYCLE * 250_00) ;
    171.         $stop ;
    172.     end
    173.     always #(CYCLE / 2) sys_clk = ~sys_clk ;
    174.  
    175. endmodule

    仿真：

    fifo_ctrl: 

    设计思路：

    这个模块要想写好，需要先明确输入端口具体信号是什么样子的。

    我在代码部分有详细说明。 

    第一部分：

    输入端口的设计

    写数据控制部分：fifo_ctrl模块先把uart传输接收到的数据，传输进（write_fifo）中。然后用wr_ack做（write_fifo）的读使能，并把数据传输给sdram_data_in[15:0]。

    读数据控制部分：fifo_ctrl模块先从sdram_ctrl中把数据读出来，并存进（read_fifo）中。然后根据rd_fifo_rd_req把（read_fifo）中的数据读出来。

    1，wr_fifo_wr_clk:写FIFO时钟。

    2,wr_fifo_wr_req:写fifo，写请求。应该连接uart_rx,的po_falg端口。

    3，wr_fifo_wr_data：写进fifo中的数据，应该连接uart_rx，的po_data端口。

    4，sdram_wr_b_addr[23:0]：先把从uart_rx模块接收到的数据存进写fifo做跨时钟域处理，然后写进sdram中。这个sdram_wr_b_addr是写数据进sdram的首地址。

    5，sdram_wr_e_addr[23:0]：是末地址。

    6，wr_rst：地址复位信号，高电平有效。

    7，wr_burst_len[9:0]：写突发长度，由顶层自己设置一个数据写入。

    读数据部分：先从sdram_ctrl模块中读出数据，然后写进FIFO控制模块中的读fifo存储器。

    8，rd_fifo_rd_clk：读fifo的读时钟。

    9，rd_fifo_rd_req：读FIFO的读请求信号。串口数据发送模块产生，读取fifo控制模块中“读FIFO”中的数据。

    10，sdram_rd_b_addr[23:0]，需要先读取SDRAM、中的数据，然后写进读fifo。这个信号时读sdram的首地址。

    11，sdram_rd_e_addr[23:0]，末地址。

    12，rd_rst，读地址复位信号。

    13，rd_valid：由顶层模块传入，高电平有效，表示可进行sdram读操作。

    14，rd_burst_len[9:0]：读数据突发长度。

    15：init_end:初始化结束信号。

    16：sdram_rd_ack与sdram_wr_ack，分别为sdram对应操作的响应信号。

    17：sdram_data_out[15:0]：从sdram中读出的数据，传递给fifo控制模块中的读fifo模块。为了通过uart_tx模块发送数据，做跨时钟域同步处理。

    第二部分：

    内部变量的设计

    满足数据通路，时序对齐，怎么设计都行。明天完成这个fifo_ctrl模块。

    时序图：

    代码：

    编译时遇到一个时序逻辑中产生锁存器的情况：

    时序逻辑，复位某变量时，如果给该变量赋值某变量（非常量），会产生锁存器。

     改成常量就好了。

    1. // 该模块的作用是辅助sdram_ctrl模块进行数据的读写。
    2. // 将要写进sdram模块的数据进行跨时钟域同步处理。
    3. // 通过uart接收模块（50Mhz）接收（写）数据，缓存进write_fifo中。然后大于突发长度时，产生写请求信号，把写数据，写进sdram。
    4. // 通过uart发送模块（50Mhz）发送（读）数据。读数据是通过saram读模块（100Mhz）读取到的缓存进read_fifo的（读）数据。
    5. // 这个读数据的读请求信号是当，初始化完成，写操作完成，read_fifo中数据量小于读突发长度，那么读请求拉高。从sdram中读数据，并写进read_fifo中。
    6. // uart发送模块产生读请求信号，读取read_fifo中的数据，并传输给上位机。
    7. // 该模块部分代码设计与野火官方有很大不同，与模块框图有不一致的地方。但是谁规定一定要完全仿照别人的东西了？
    8. module fifo_ctrl(
    9.     input       wire            clk_50Mhz       , // write_fifo的输入端时钟，read_fifo的输出端时钟。
    10.     input       wire            clk_100Mhz      , // 大多数信号的时钟，write_fifo的输出端时钟，read_fifo的输入端时钟。
    11.     input       wire            sys_rst_n       , // 系统复位
    12.     input       wire            init_end        , // 一切请求在初始化完成之后产生？其实没有必要，因为你即使产生了，也不会被响应。
    13.     // 写数据进写write_fifo
    14.     input       wire            wr_fifo_wr_req  , // 与uart_rx模块的po_flag相连。
    15.     input       wire    [15:0]  wr_fifo_wr_data , // 与uart_rx模块的po_data相连。
    16.     // 把数据从write_fifo中读出来并写进sdram
    17.     output      reg             sdram_wr_req    , // 当write_fifo中的二数据量大于一次写突发长度时，即可拉高。不大于时拉低。也就是说如果write_fifo中数据比写突发长度大很多倍，写请求会一直拉高。直到write_fifo中数据小于写突发长度时拉低。
    18.     output      reg     [23:0]  sdram_wr_addr   , // 输出一次突发写sdram的首地址。
    19.     output      wire    [15:0]  sdram_data_in   , // 输出突发写，数据。连接到write_fifo的读出数据端口。
    20.     input       wire    [23:0]  sdram_wr_b_addr , // 写进sdram的首末地址。2bit，bank地址，9bit列地址,中间13bit的行地址。
    21.     input       wire    [23:0]  sdram_wr_e_addr , // 写进sdram的首末地址。
    22.     input       wire            sdram_wr_ack    , // 用来复位写进sdram地址的（sdram_wr_addr），它的下降沿表示一次写突发数据完成，可以用此下降沿作数据更新依据。因为采用突发方式写数据（写突发长度是任意的）。写完后需要更新地址。除非你想一直在相同地址范围内写数据，那就不用更新写地址，就不用复位。
    23.     input       wire            wr_rst          , 
    24.     input       wire    [9:0]   wr_bust_len     , // 写数据突发长度。
    25.     // 从sdram中读数据
    26.     output      reg             sdram_rd_req    , // 申请读sdram中数据的读请求。
    27.     output      reg     [23:0]  sdram_rd_addr   , // 一次读突发的，读首地址。
    28.     input       wire    [23:0]  rd_fifo_b_addr  , // 外界传入的读突发的首末地址。作为sdram_rd_addr的赋值参考依据。
    29.     input       wire    [23:0]  rd_fifo_e_addr  , // 外界传入的读突发的首末地址。作为sdram_rd_addr的赋值参考依据。
    30.     input       wire            sdram_rd_ack    , // 用来复位读突发地址。用来做read_fifo的写入数据使能。
    31.     input       wire            rd_rst          , // 与wr_rst一样，是外界传输的
    32.     input       wire    [9:0]   rd_bust_len     , // 读突发长度。
    33.     input       wire    [15:0]  sdram_data_out  , // 从sdram中读数据。
    34.     // 从read_fifo中读出数据。传给下一个模块。
    35.     output      wire    [15:0]  rd_fifo_rd_data , // 从read_fifo中读出的数据。连接到read_fifo的数据输出端口。
    36.     output      wire    [9:0]   rd_fifo_num     , // read_fifo中“存储”的数据个数，传给外界的一个读模块，用来产生read_fifo的读请求模块。
    37.     input       wire            rd_valid        , // 读数据有效信号，sdram_top凭空产生的。个人认为没什么用。类似于使能信号？但是下面都有请求信号了。
    38.     input       wire            rd_fifo_rd_req    // 下一个模块产生的，根据read_fifo中存储的数据个数。
    39. );                                                // 仿真时记得把rd_valid信号拉高；rd_rst ；wr_rst 信号相对于sys_rst_n 取反。
    40.     // 例化间连线。
    41.     wire    [9:0]   wrusedw_write_num1  ; // write_fifo中存储的数据个数。
    42.     wire    [9:0]   wrusedw_write_num2  ; // write_fifo中存储的数据个数。
    43.     wire    [9:0]   wrusedw_read_num1   ; // read_fifo中存储的数据个数。
    44.     wire    [9:0]   wrusedw_read_num2   ; // read_fifo中存储的数据个数。
    45.     wire            wr_ack_dly1_nege    ;
    46.     wire            rd_ack_dly1_nege    ;
    47.     // reg signal define
    48.     reg             wr_ack_dly1 ;
    49.     reg             rd_ack_dly1 ;
    50.     // wr_ack_dly1  rd_ack_dly1
    51.     always @(posedge clk_100Mhz or negedge sys_rst_n) begin
    52.         if(~sys_rst_n) 
    53.         begin
    54.             wr_ack_dly1 <= 1'b0 ;
    55.             rd_ack_dly1 <= 1'b0 ;
    56.         end
    57.         else 
    58.         begin
    59.             wr_ack_dly1 <= sdram_wr_ack ;
    60.             rd_ack_dly1 <= sdram_rd_ack ;
    61.         end
    62.     end
    63.     // wr_ack_dly1_nege  rd_ack_dly1_nege
    64.     assign  wr_ack_dly1_nege = (~sdram_wr_ack) && (wr_ack_dly1);
    65.     assign  rd_ack_dly1_nege = (~sdram_rd_ack) && (rd_ack_dly1);
    66.     // reg             sdram_wr_req
    67.     always @(posedge clk_100Mhz or negedge sys_rst_n) begin
    68.         if(~sys_rst_n) 
    69.             sdram_wr_req <= 1'b0 ;
    70.         else if(init_end && wrusedw_write_num1 >= wr_bust_len) 
    71.             sdram_wr_req <= 1'b1 ;
    72.         else 
    73.             sdram_wr_req <= 1'b0 ;
    74.     end
    75.     // reg     [23:0]  sdram_wr_addr   , // 输出一次突发写sdram的首地址
    76.     // always @(posedge clk_100Mhz or negedge sys_rst_n) begin
    77.     //     if(~sys_rst_n) 
    78.     //         sdram_wr_addr <= sdram_wr_b_addr ;
    79.     //     else if((sdram_wr_addr < (sdram_wr_e_addr - sdram_wr_b_addr - wr_bust_len)) && wr_ack_dly1_nege)
    80.     //         sdram_wr_addr <= sdram_wr_addr + wr_bust_len;
    81.     //     else if(wr_ack_dly1_nege)
    82.     //         sdram_wr_addr <= sdram_wr_b_addr ;
    83.     //     else 
    84.     //         sdram_wr_addr <= sdram_wr_addr ;
    85.     // end
    86.     always @(posedge clk_100Mhz or negedge sys_rst_n) begin
    87.         if(~sys_rst_n) 
    88.             sdram_wr_addr <= 24'd0 ;
    89.         else if(wr_rst == 1)
    90.             sdram_wr_addr <= sdram_wr_b_addr ;
    91.         else if(wr_ack_dly1_nege) 
    92.         begin
    93.             if(sdram_wr_addr < (sdram_wr_e_addr - sdram_wr_b_addr - wr_bust_len))
    94.                 sdram_wr_addr <= sdram_wr_addr + wr_bust_len;
    95.             else
    96.                 sdram_wr_addr <= sdram_wr_b_addr ;
    97.         end
    98.         else
    99.             sdram_wr_addr <= sdram_wr_addr ; 
    100.     end
    101.     // reg            sdram_rd_req    , // 申请读sdram中数据的读请求。每完成一次写操作,或者读操作后，若read_fifo中的数据小于rd_bust_len，则需拉高读请求。
    102.     always @(posedge clk_100Mhz or negedge sys_rst_n) begin
    103.         if(~sys_rst_n) 
    104.             sdram_rd_req <= 1'b0 ;
    105.         else 
    106.         if(rd_valid == 1) 
    107.         begin
    108.             if(wrusedw_read_num1 < rd_bust_len && (wr_ack_dly1_nege || rd_ack_dly1_nege)) 
    109.                 sdram_rd_req <= 1'b1 ;
    110.             else if(wrusedw_read_num1 >= rd_bust_len && (wr_ack_dly1_nege || rd_ack_dly1_nege))
    111.                 sdram_rd_req <= 1'b0 ;
    112.             else 
    113.                 sdram_rd_req <= sdram_rd_req ;
    114.         end
    115.         else 
    116.             sdram_rd_req <= 1'b0 ;
    117.     end
    118.     // reg    [23:0]  sdram_rd_addr   , // 一次读突发的，读首地址。
    119.     always @(posedge clk_100Mhz or negedge sys_rst_n) begin
    120.         if(~sys_rst_n) 
    121.             sdram_rd_addr <= 24'd0 ;
    122.         else if(rd_rst == 1)
    123.             sdram_rd_addr <= rd_fifo_b_addr ;
    124.         else if(sdram_rd_addr < (rd_fifo_e_addr - rd_fifo_b_addr - rd_bust_len) && rd_ack_dly1_nege)
    125.             sdram_rd_addr <= sdram_rd_addr + rd_bust_len ;
    126.         else if(sdram_rd_addr >= (rd_fifo_e_addr - rd_fifo_b_addr - rd_bust_len) && rd_ack_dly1_nege)
    127.             sdram_rd_addr <= rd_fifo_b_addr ;
    128.         else 
    129.             sdram_rd_addr <= sdram_rd_addr ;
    130.     end
    131.     // wire    [9:0]   rd_fifo_num     , // read_fifo中“存储”的数据个数，传给外界的一个读模块，用来产生read_fifo的读请求模块。
    132.     assign  rd_fifo_num = wrusedw_read_num1 ;
    133.     // 例化write_fifo read_fifo
    134. fifo_data_16x1024 write_fifo_data_16x1024(
    135. 	.data                   ( wr_fifo_wr_data    ) ,
    136. 	.wrclk                  ( clk_50Mhz          ) ,
    137. 	.wrreq                  ( wr_fifo_wr_req     ) ,
    138. 	.wrusedw                ( wrusedw_write_num1 ) ,  // ？？？
    139. 	.rdclk                  ( clk_100Mhz         ) ,
    140. 	.rdreq                  ( sdram_wr_ack       ) ,
    141. 	.q                      ( sdram_data_in      ) ,
    142. 	.rdusedw                ( wrusedw_write_num2 )  // ？？？
    143. );
    145. fifo_data_16x1024 read_fifo_data_16x1024(
    146. 	.data                   ( sdram_data_out     ) ,
    147. 	.wrclk                  ( clk_100Mhz         ) ,
    148. 	.wrreq                  ( sdram_rd_ack       ) ,
    149. 	.wrusedw                ( wrusedw_read_num1  ) ,  // ？？？
    150. 	.rdclk                  ( clk_50Mhz          ) ,
    151. 	.rdreq                  ( rd_fifo_rd_req     ) ,
    152. 	.q                      ( rd_fifo_rd_data    ) ,
    153. 	.rdusedw                ( wrusedw_read_num2  )  // ？？？
    154. );
    156. endmodule
    仿真：

    没有单独仿真。

    sdram_top:

    设计思路

    该模块例化了fifo_ctrl模块与sdram_ctrl模块。

    例化完后对sdram_top进行仿真验证：

    通过uart_rx模块，先传输10个数据进write_fifo

    等待sdram完成初始化，然后拉高写请求，把write_fifo中的10个数据写进sdram中。

    写完后仲裁模块响应读请求，然后读取10个数据进read_fifo

    然后拉高rd_fifo_rd_req读读fifo请求信号，把read_fifo中存的10个数据读出来。

    但是要保持read_fifo存储器中存有10个数据，会再次拉高读请求，从sdram中读出10个数据进read_fifo。

    之后不会再次拉高rd_fifo_rd_req，除非有其他控制信号干预，想要再次读取数据时会拉高。

    代码： 

    1. module sdram_top(
    2.     input       wire            clk_50Mhz       ,
    3.     input       wire            clk_100Mhz      ,
    4.     input       wire            clk_shift       ,
    5.     input       wire            sys_rst_n       ,
    6.     input       wire            wr_fifo_wr_req  ,
    7.     input       wire    [15:0]  wr_fifo_wr_data ,
    8.     input       wire    [23:0]  sdram_wr_b_addr ,
    9.     input       wire    [23:0]  sdram_wr_e_addr ,
    10.     input       wire            wr_rst          ,
    11.     input       wire    [9:0]   wr_bust_len     ,
    12.     input       wire    [23:0]  rd_fifo_b_addr  ,
    13.     input       wire    [23:0]  rd_fifo_e_addr  ,
    14.     input       wire            rd_rst          ,
    15.     input       wire    [9:0]   rd_bust_len     ,
    16.     input       wire            rd_valid        , 
    17.     input       wire            rd_fifo_rd_req  ,
    18.  
    19.     output      wire    [15:0]  rd_fifo_rd_data ,
    20.     output      wire    [9:0]   rd_fifo_num     ,
    21.     output      wire            sdram_sck       , // 偏移+30度的时钟。
    22.     output      wire            sdram_cke       , // 时钟使能
    23.     output      wire            sdram_csn       ,
    24.     output      wire            sdram_ras       ,
    25.     output      wire            sdram_cas       ,
    26.     output      wire            sdram_wen       , // 写使能。
    27.     output      wire    [1:0]   sdram_bank      ,
    28.     output      wire    [12:0]  sdram_addr      ,
    29.  
    30.     inout       wire    [15:0]  sdram_dq        ,
    31.  
    32.     output      wire    [1:0]   sdram_dqm        // 数据掩码。
    33. );
    34.     assign          sdram_dqm = 2'b00 ;
    35.     // 例化间连线
    36.     wire            sdram_init_end  ;
    37.     wire            sdram_wr_req    ;
    38.     wire    [23:0]  sdram_wr_addr   ;
    39.     wire    [15:0]  sdram_data_in   ;
    40.     wire            sdram_wr_ack    ;
    41.     wire            sdram_rd_ack    ;
    42.     wire            sdram_rd_req    ;
    43.     wire    [23:0]  sdram_rd_addr   ;  
    44.     wire    [15:0]  sdram_data_out  ; 
    45. fifo_ctrl fifo_ctrl_inst(
    46.     .clk_50Mhz                  ( clk_50Mhz         ) , // write_fifo的输入端时钟，read_fifo的输出端时钟。
    47.     .clk_100Mhz                 ( clk_100Mhz        ) , // 大多数信号的时钟，write_fifo的输出端时钟，read_fifo的输入端时钟。
    48.     .sys_rst_n                  ( sys_rst_n         ) , // 系统复位
    49.     .init_end                   ( sdram_init_end    ) , // 一切请求在初始化完成之后产生？其实没有必要，因为你即使产生了，也不会被响应。
    50.     // 写数据进写write_fifo
    51.     .wr_fifo_wr_req             ( wr_fifo_wr_req    ) , // 与uart_rx模块的po_flag相连。
    52.     .wr_fifo_wr_data            ( wr_fifo_wr_data   ) , // 与uart_rx模块的po_data相连。
    53.     // 把数据从write_fifo中读出来并写进sdram
    54.     .sdram_wr_req               ( sdram_wr_req      ) , // 当write_fifo中的二数据量大于一次写突发长度时，即可拉高。不大于时拉低。也就是说如果write_fifo中数据比写突发长度大很多倍，写请求会一直拉高。直到write_fifo中数据小于写突发长度时拉低。
    55.     .sdram_wr_addr              ( sdram_wr_addr     ) , // 输出一次突发写sdram的首地址。
    56.     .sdram_data_in              ( sdram_data_in     ) , // 输出突发写，数据。连接到write_fifo的读出数据端口。
    57.     .sdram_wr_b_addr            ( sdram_wr_b_addr   ) , // 写进sdram的首末地址。2bit，bank地址，9bit列地址,中间13bit的行地址。
    58.     .sdram_wr_e_addr            ( sdram_wr_e_addr   ) , // 写进sdram的首末地址。
    59.     .sdram_wr_ack               ( sdram_wr_ack      ) , // 用来复位写进sdram地址的（sdram_wr_addr），它的下降沿表示一次写突发数据完成，可以用此下降沿作数据更新依据。因为采用突发方式写数据（写突发长度是任意的）。写完后需要更新地址。除非你想一直在相同地址范围内写数据，那就不用更新写地址，就不用复位。
    60.     .wr_rst                     ( wr_rst            ) , 
    61.     .wr_bust_len                ( wr_bust_len       ) , // 写数据突发长度。
    62.     // 从sdram中读数据
    63.     .sdram_rd_req               ( sdram_rd_req      ) , // 申请读sdram中数据的读请求。
    64.     .sdram_rd_addr              ( sdram_rd_addr     ) , // 一次读突发的，读首地址。
    65.     .rd_fifo_b_addr             ( rd_fifo_b_addr    ) , // 外界传入的读突发的首末地址。作为sdram_rd_addr的赋值参考依据。
    66.     .rd_fifo_e_addr             ( rd_fifo_e_addr    ) , // 外界传入的读突发的首末地址。作为sdram_rd_addr的赋值参考依据。
    67.     .sdram_rd_ack               ( sdram_rd_ack      ) , // 用来复位读突发地址。用来做read_fifo的写入数据使能。
    68.     .rd_rst                     ( rd_rst            ) , // 与wr_rst一样，是外界传输的
    69.     .rd_bust_len                ( rd_bust_len       ) , // 读突发长度。
    70.     .sdram_data_out             ( sdram_data_out    ) , // 从sdram中读数据。
    71.     // 从read_fifo中读出数据。传给下一个模块。
    72.     .rd_fifo_rd_data            ( rd_fifo_rd_data   ) , // 从read_fifo中读出的数据。连接到read_fifo的数据输出端口。
    73.     .rd_fifo_num                ( rd_fifo_num       ) , // read_fifo中“存储”的数据个数，传给外界的一个读模块，用来产生read_fifo的读请求模块。
    74.     .rd_valid                   ( rd_valid          ) , // 读数据有效信号，sdram_top凭空产生的。个人认为没什么用。类似于使能信号？但是下面都有请求信号了。
    75.     .rd_fifo_rd_req             ( rd_fifo_rd_req    )   // 下一个模块产生的，根据read_fifo中存储的数据个数。
    76. );            
    78. sdram_ctrl sdram_ctrl_inst(
    79.     .sys_clk                    ( clk_100Mhz        ) ,
    80.     .sys_rst_n                  ( sys_rst_n         ) ,
    81.     .clk_shift                  ( clk_shift         ) ,
    83.     .sdram_wr_req               ( sdram_wr_req      ) ,
    84.     .sdram_wr_addr              ( sdram_wr_addr     ) ,
    85.     .sdram_wr_data              ( sdram_data_in     ) ,
    86.     .sdram_wr_bust              ( wr_bust_len       ) ,
    88.     .sdram_rd_req               ( sdram_rd_req      ) ,
    89.     .sdram_rd_addr              ( sdram_rd_addr     ) ,
    90.     .sdram_rd_bust              ( rd_bust_len       ) ,
    92.     .sdram_sck                  ( sdram_sck         ) , // 偏移+30度的时钟。
    93.     .sdram_cke                  ( sdram_cke         ) , // 时钟使能
    94.     .sdram_csn                  ( sdram_csn         ) ,
    95.     .sdram_ras                  ( sdram_ras         ) ,
    96.     .sdram_cas                  ( sdram_cas         ) ,
    97.     .sdram_wen                  ( sdram_wen         ) , // 写使能。
    98.     .sdram_bank                 ( sdram_bank        ) ,
    99.     .sdram_addr                 ( sdram_addr        ) ,
    101.     .sdram_dq                   ( sdram_dq          ) ,
    103.     .sdram_wr_ack               ( sdram_wr_ack      ) ,
    104.     .sdram_rd_ack               ( sdram_rd_ack      ) ,
    105.     .sdram_init_end             ( sdram_init_end    ) ,
    106.     .sdram_data_out             ( sdram_data_out    ) 
    107. );
    108. endmodule

    仿真： 

    1. `timescale 1ns/1ns
    2. module test_sdram_top ();
    3.     reg             sys_clk_50Mhz   ;
    4.     reg             sys_rst_n       ;
    5.     wire            c0_sig          ;
    6.     wire            c1_sig          ;
    7.     wire            c2_sig          ;
    8.     wire            locked_sig      ;
    9.     wire            rst_n           ;
    10.     reg             rx              ;
    11.     wire            po_flag         ;
    12.     wire    [7:0]   po_data         ;
    13.     reg             rd_fifo_rd_req  ;
    14.     wire    [15:0]  rd_fifo_rd_data ;
    15.     wire    [9:0]   rd_fifo_num     ;
    16.     wire            sdram_sck       ;
    17.     wire            sdram_cke       ;
    18.     wire            sdram_csn       ;
    19.     wire            sdram_ras       ;
    20.     wire            sdram_cas       ;
    21.     wire            sdram_wen       ;
    22.     wire    [1:0]   sdram_bank      ;
    23.     wire    [12:0]  sdram_addr      ;
    24.     wire    [15:0]  sdram_dq        ;
    25.     wire    [1:0]   sdram_dqm       ;
    26.     wire    [9:0]   rd_bust_len     ;
    27.     wire    [9:0]   wr_bust_len     ;
    28.     reg             rd_flag         ;
    29.     //  例化
    30. clk_gen	clk_gen_inst (
    31. 	.areset             ( ~sys_rst_n    ) ,
    32. 	.inclk0             ( sys_clk_50Mhz ) ,
    33. 	.c0                 ( c0_sig        ) , // 50m
    34. 	.c1                 ( c1_sig        ) , // 100m
    35. 	.c2                 ( c2_sig        ) , // 100m shift
    36. 	.locked             ( locked_sig    )
    37. );
    38. uart_rx uart_rx_inst(
    39.     .sys_clk            ( c0_sig        ) ,
    40.     .sys_rst_n          ( rst_n         ) ,
    41.     .rx                 ( rx            ) ,
    42.  
    43.     .po_flag            ( po_flag       ) ,
    44.     .po_data            ( po_data       )  
    45. );
    46. sdram_top sdram_top_inst(
    47.     .clk_50Mhz          ( c0_sig        ) ,
    48.     .clk_100Mhz         ( c1_sig        ) ,
    49.     .clk_shift          ( c2_sig        ) ,
    50.     .sys_rst_n          ( rst_n         ) ,
    51.     .wr_fifo_wr_req     ( po_flag       ) ,
    52.     .wr_fifo_wr_data    ( {8'h00,po_data}       ) ,
    53.     .sdram_wr_b_addr    ( 24'd0         ) ,
    54.     .sdram_wr_e_addr    ( 24'd10        ) ,
    55.     .wr_rst             ( ~rst_n        ) ,
    56.     .wr_bust_len        ( wr_bust_len   ) ,
    57.     .rd_fifo_b_addr     ( 24'd0         ) ,
    58.     .rd_fifo_e_addr     ( 24'd10        ) ,
    59.     .rd_rst             ( ~rst_n        ) ,
    60.     .rd_bust_len        ( rd_bust_len   ) ,
    61.     .rd_valid           ( 1'b1          ) , 
    62.     .rd_fifo_rd_req     ( rd_fifo_rd_req) ,
    63.  
    64.     .rd_fifo_rd_data    (rd_fifo_rd_data) ,
    65.     .rd_fifo_num        ( rd_fifo_num   ) ,
    66.     .sdram_sck          ( sdram_sck     ) , // 偏移+30度的时钟。
    67.     .sdram_cke          ( sdram_cke     ) , // 时钟使能
    68.     .sdram_csn          ( sdram_csn     ) ,
    69.     .sdram_ras          ( sdram_ras     ) ,
    70.     .sdram_cas          ( sdram_cas     ) ,
    71.     .sdram_wen          ( sdram_wen     ) , // 写使能。
    72.     .sdram_bank         ( sdram_bank    ) ,
    73.     .sdram_addr         ( sdram_addr    ) ,
    74.  
    75.     .sdram_dq           ( sdram_dq      ) ,
    76.  
    77.     .sdram_dqm          ( sdram_dqm     ) // 数据掩码。
    78. );
    79. sdram_model_plus sdram_model_plus_inst(
    80.     .Dq                 ( sdram_dq      ) , 
    81.     .Addr               ( sdram_addr    ) , 
    82.     .Ba                 ( sdram_bank    ) , 
    83.     .Clk                ( sdram_sck     ) , 
    84.     .Cke                ( sdram_cke     ) , 
    85.     .Cs_n               ( sdram_csn     ) , 
    86.     .Ras_n              ( sdram_ras     ) , 
    87.     .Cas_n              ( sdram_cas     ) , 
    88.     .We_n               ( sdram_wen     ) , 
    89.     .Dqm                ( {2'b00,sdram_dqm}     ) ,
    90.     .Debug              ( 1'b1          )  
    91. );
    92. /****************************************************************/
    93.     parameter   CYCLE = 20 ;
    94.     defparam    uart_rx_inst.CLK_UART = 50_000_0 ;
    95.     defparam    sdram_top_inst.sdram_ctrl_inst.sdram_aref_inst.MAX_CNT_750US = 200 ;
    96.     defparam    sdram_model_plus_inst.addr_bits = 13 ;
    97.     defparam    sdram_model_plus_inst.data_bits = 16 ;
    98.     defparam    sdram_model_plus_inst.col_bits  = 9  ;
    99.     defparam    sdram_model_plus_inst.mem_sizes = 2*1024*1024  ;
    100.     // rst_n rd_bust_len wr_bust_len
    101.     assign  rst_n = sys_rst_n && locked_sig ;
    102.     assign  rd_bust_len = 10'd10 ;
    103.     assign  wr_bust_len = 10'd10 ;
    104.     // rx
    105.     task rx_bit ;
    106.         input   [7:0]   data ;
    107.         integer i ;
    108.         for (i = 0;i <= 9 ;i = i  + 1 ) begin
    109.             case (i)
    110.                 0: rx <= 1'b0 ;
    111.                 1: rx <= data[i - 1];
    112.                 2: rx <= data[i - 1];
    113.                 3: rx <= data[i - 1];
    114.                 4: rx <= data[i - 1];
    115.                 5: rx <= data[i - 1];
    116.                 6: rx <= data[i - 1];
    117.                 7: rx <= data[i - 1];
    118.                 8: rx <= data[i - 1];
    119.                 9: rx <= 1'b1 ;
    120.                 default: rx <= 1'b1 ;
    121.             endcase
    122.             #(CYCLE * 52) ;
    123.         end
    124.     endtask
    125.     // rd_fifo_rd_req
    126.     // always @(posedge c0_sig or negedge rst_n) begin
    127.     //     if(~rst_n)
    128.     //         rd_fifo_rd_req <= 1'b0 ;
    129.     //     else if(rd_fifo_num == rd_bust_len)
    130.     //         rd_fifo_rd_req <= 1'b1 ;
    131.     //     else if(rd_fifo_num ==  0)
    132.     //         rd_fifo_rd_req <= 1'b0 ;
    133.     //     else 
    134.     //         rd_fifo_rd_req <= rd_fifo_rd_req ;
    135.     // end
    136.     always @(posedge c0_sig or negedge rst_n) begin
    137.         if(~rst_n) 
    138.             rd_flag <= 1'b1 ;
    139.         else if(rd_fifo_num == rd_bust_len && rd_flag == 1'b1)
    140.             rd_flag <= 1'b0 ;
    141.         else 
    142.             rd_flag <= rd_flag ;
    143.     end
    144.     always @(posedge c0_sig or negedge rst_n) begin
    145.         if(~rst_n)
    146.             rd_fifo_rd_req <= 1'b0 ;
    147.         else if(rd_fifo_num == rd_bust_len && rd_flag)
    148.             rd_fifo_rd_req <= 1'b1 ;
    149.         else if(rd_fifo_num ==  0)
    150.             rd_fifo_rd_req <= 1'b0 ;
    151.         else 
    152.             rd_fifo_rd_req <= rd_fifo_rd_req ;
    153.     end
    154.     initial begin
    155.         sys_clk_50Mhz = 1'b1    ;
    156.         sys_rst_n    <= 1'b0    ;
    157.         rx           <= 1'b1    ;
    158.         #(CYCLE)                ;
    159.         sys_rst_n     <= 1'b1   ;
    160.         #( CYCLE * 100  )       ;
    161.         rx_bit(8'b1)            ;
    162.         rx_bit(8'd2)            ;
    163.         rx_bit(8'd3)            ;
    164.         rx_bit(8'd4)            ;
    165.         rx_bit(8'd5)            ;
    166.         rx_bit(8'd6)            ;
    167.         rx_bit(8'd7)            ;
    168.         rx_bit(8'd8)            ;
    169.         rx_bit(8'd9)            ;
    170.         rx_bit(8'd9)            ;
    171.     end
    172.     always #(CYCLE / 2) sys_clk_50Mhz = ~sys_clk_50Mhz ;
    173.  
    174. endmodule

    uart_sdram:

    read_fifo:

    设计思路：

    从read_fifo中读出的10个数据时50Mhz时钟下的，需要先存进fifo，然后由波特率产生标志信号，作为fifo的读标志。把标志打拍与读出的数据作为po_flag_tx与po_flag_tx。传给uart_tx模块。

    修改uart_tx模块，产生一个data_over信号，传递完一帧数据的最后一位拉高一个时钟周期，作为read_fifo的读信号。

    时序图：

    代码：
    1. module fifo_read(
    2.     input       wire            sys_clk     , // clk_50M
    3.     input       wire            sys_rst_n   ,
    4.     input       wire    [7:0]   rd_fifo_rd_data ,
    5.     input       wire    [9:0]   rd_fifo_num ,
    6.     input       wire    [9:0]   bust_num    , // 作为顶层模块设置并输入，为固定参数，表示本模块一次读取读 FIFO 中数据个数，参数数值与数据读模块中读突发长度一致，防止数据读空。
    7.     input       wire            data_over   ,
    8.  
    9.     output      reg             read_en     , // read_en的设计可以参考仿真模块里的设计。
    10.     output      wire    [7:0]   tx_data     ,
    11.     output      reg             tx_flag     
    12. );
    13.     parameter       BPS = 9600  ,
    14.                     BIT = 10    ;
    15.  
    16.     reg             fifo_256_wren ;  // 经过观察read_en与rd_fifo_rd_data的关系，打一拍，会与rd_fifo_rd_data对齐，做fifo的写使能。
    17.     wire    [7:0]   wrusedw       ;  // 写进本模块fifo中的数据。当wrusedw == bust_len - 2时，read_en拉低。
    18.     reg             rd_fifo256_en ;  // fifo256开始进行读的使能信号。
    19.     reg             rd_fifo256_en_r ;  // fifo256开始进行读的使能信号。打拍
    20.     reg             rd_fifo256    ;  // fifo256读请求信号。
    21.     wire            empty         ;
    22.  
    23.     // fifo_256_wren
    24.     always @(posedge sys_clk or negedge sys_rst_n) begin
    25.         if(~sys_rst_n)
    26.             fifo_256_wren <= 1'b0 ;
    27.         else 
    28.             fifo_256_wren <= read_en ;
    29.     end
    30.     // rd_fifo256_en
    31.     always @(posedge sys_clk or negedge sys_rst_n) begin
    32.         if(~sys_rst_n) 
    33.             rd_fifo256_en <= 1'b0 ;
    34.         else if(empty == 1)
    35.             rd_fifo256_en <= 1'b0 ;
    36.         else if(!empty && !read_en && fifo_256_wren)
    37.             rd_fifo256_en <= 1'b1 ;
    38.     end
    39.     // rd_fifo256_en_r
    40.     always @(posedge sys_clk or negedge sys_rst_n) begin
    41.         if(~sys_rst_n)
    42.             rd_fifo256_en_r <= 1'b0 ;
    43.         else 
    44.             rd_fifo256_en_r <= rd_fifo256_en ;
    45.     end
    46.     // rd_fifo256
    47.     always @(posedge sys_clk or negedge sys_rst_n) begin
    48.         if(~sys_rst_n)
    49.             rd_fifo256 <= 1'b0 ;
    50.         else if(rd_fifo256_en) begin
    51.                 if((~rd_fifo256_en_r) || (!empty && data_over))
    52.                     rd_fifo256 <= 1'b1 ;
    53.                 else
    54.                     rd_fifo256 <= 1'b0 ;
    55.             end
    56.         else 
    57.             rd_fifo256 <= 1'b0 ;
    58.     end
    59.     // output signal describe
    60.     // read_en
    61.     always @(posedge sys_clk or negedge sys_rst_n) begin
    62.         if(~sys_rst_n)
    63.             read_en <= 1'b0 ;
    64.         else if(rd_fifo_num == bust_num)
    65.             read_en <= 1'b1 ;
    66.         else if(wrusedw == bust_num - 3) // 提前拉低。
    67.             read_en <= 1'b0 ;
    68.         else 
    69.             read_en <= read_en ;
    70.     end
    71.     // wire    [7:0]   tx_data     ,
    72.     // reg             tx_flag     
    73.     always @(posedge sys_clk or negedge sys_rst_n) begin
    74.         if(~sys_rst_n) 
    75.             tx_flag <= 1'b0 ;
    76.         else
    77.             tx_flag <= rd_fifo256 ;
    78.     end
    80.     // 例化
    81. fifo_data_8x256 fifo_data_8x256_inst(
    82. 	.wrclk              ( sys_clk         ) , // 写时钟与读时钟貌似是相同的。
    83. 	.wrreq              ( fifo_256_wren   ) , // 写请求。
    84. 	.data               ( rd_fifo_rd_data ) ,
    85. 	.rdclk              ( sys_clk         ) ,
    86. 	.rdreq              ( rd_fifo256      ) ,
    87.     .rdempty            ( empty           ),
    88. 	.q                  ( tx_data         ) ,
    89. 	.rdusedw            (  ) ,
    90. 	.wrusedw            ( wrusedw         ) 
    91. );
    93. endmodule
    仿真：

    仍然对顶层模块仿真，测试文件稍作修改。

    把read_fifo模块与uart_tx加进去。

    1. `timescale 1ns/1ns
    2. module test_sdram_top ();
    3.     reg             sys_clk_50Mhz   ;
    4.     reg             sys_rst_n       ;
    5.     wire            c0_sig          ;
    6.     wire            c1_sig          ;
    7.     wire            c2_sig          ;
    8.     wire            locked_sig      ;
    9.     wire            rst_n           ;
    10.     reg             rx              ;
    11.     wire            po_flag         ;
    12.     wire    [7:0]   po_data         ;
    13.     reg             rd_fifo_rd_req  ;
    14.     wire    [15:0]  rd_fifo_rd_data ;
    15.     wire    [9:0]   rd_fifo_num     ;
    16.     wire            sdram_sck       ;
    17.     wire            sdram_cke       ;
    18.     wire            sdram_csn       ;
    19.     wire            sdram_ras       ;
    20.     wire            sdram_cas       ;
    21.     wire            sdram_wen       ;
    22.     wire    [1:0]   sdram_bank      ;
    23.     wire    [12:0]  sdram_addr      ;
    24.     wire    [15:0]  sdram_dq        ;
    25.     wire    [1:0]   sdram_dqm       ;
    26.     wire    [9:0]   rd_bust_len     ;
    27.     wire    [9:0]   wr_bust_len     ;
    28.     reg             rd_flag         ;
    29.     wire            data_over       ;
    30.     wire            read_en         ;
    31.     wire    [7:0]   tx_data         ;
    32.     wire            tx_flag         ;
    33.     wire            tx              ;
    34.     //  例化
    35. clk_gen	clk_gen_inst (
    36. 	.areset             ( ~sys_rst_n    ) ,
    37. 	.inclk0             ( sys_clk_50Mhz ) ,
    38. 	.c0                 ( c0_sig        ) , // 50m
    39. 	.c1                 ( c1_sig        ) , // 100m
    40. 	.c2                 ( c2_sig        ) , // 100m shift
    41. 	.locked             ( locked_sig    )
    42. );
    43. uart_rx uart_rx_inst(
    44.     .sys_clk            ( c0_sig        ) ,
    45.     .sys_rst_n          ( rst_n         ) ,
    46.     .rx                 ( rx            ) ,
    47.  
    48.     .po_flag            ( po_flag       ) ,
    49.     .po_data            ( po_data       )  
    50. );
    51. sdram_top sdram_top_inst(
    52.     .clk_50Mhz          ( c0_sig        ) ,
    53.     .clk_100Mhz         ( c1_sig        ) ,
    54.     .clk_shift          ( c2_sig        ) ,
    55.     .sys_rst_n          ( rst_n         ) ,
    56.     .wr_fifo_wr_req     ( po_flag       ) ,
    57.     .wr_fifo_wr_data    ( {8'h00,po_data}       ) ,
    58.     .sdram_wr_b_addr    ( 24'd0         ) ,
    59.     .sdram_wr_e_addr    ( 24'd10        ) ,
    60.     .wr_rst             ( ~rst_n        ) ,
    61.     .wr_bust_len        ( wr_bust_len   ) ,
    62.     .rd_fifo_b_addr     ( 24'd0         ) ,
    63.     .rd_fifo_e_addr     ( 24'd10        ) ,
    64.     .rd_rst             ( ~rst_n        ) ,
    65.     .rd_bust_len        ( rd_bust_len   ) ,
    66.     .rd_valid           ( 1'b1          ) , 
    67.     .rd_fifo_rd_req     ( read_en       ) , // rd_fifo_rd_req
    68.  
    69.     .rd_fifo_rd_data    (rd_fifo_rd_data) ,
    70.     .rd_fifo_num        ( rd_fifo_num   ) ,
    71.     .sdram_sck          ( sdram_sck     ) , // 偏移+30度的时钟。
    72.     .sdram_cke          ( sdram_cke     ) , // 时钟使能
    73.     .sdram_csn          ( sdram_csn     ) ,
    74.     .sdram_ras          ( sdram_ras     ) ,
    75.     .sdram_cas          ( sdram_cas     ) ,
    76.     .sdram_wen          ( sdram_wen     ) , // 写使能。
    77.     .sdram_bank         ( sdram_bank    ) ,
    78.     .sdram_addr         ( sdram_addr    ) ,
    79.  
    80.     .sdram_dq           ( sdram_dq      ) ,
    81.  
    82.     .sdram_dqm          ( sdram_dqm     ) // 数据掩码。
    83. );
    84. sdram_model_plus sdram_model_plus_inst(
    85.     .Dq                 ( sdram_dq      ) , 
    86.     .Addr               ( sdram_addr    ) , 
    87.     .Ba                 ( sdram_bank    ) , 
    88.     .Clk                ( sdram_sck     ) , 
    89.     .Cke                ( sdram_cke     ) , 
    90.     .Cs_n               ( sdram_csn     ) , 
    91.     .Ras_n              ( sdram_ras     ) , 
    92.     .Cas_n              ( sdram_cas     ) , 
    93.     .We_n               ( sdram_wen     ) , 
    94.     .Dqm                ( {2'b00,sdram_dqm}     ) ,
    95.     .Debug              ( 1'b1          )  
    96. );
    97. fifo_read fifo_read_inst(
    98.     .sys_clk            ( c0_sig ) , // clk_50M
    99.     .sys_rst_n          ( rst_n  ) ,
    100.     .rd_fifo_rd_data    ( rd_fifo_rd_data[7:0] ) ,
    101.     .rd_fifo_num        ( rd_fifo_num          ) ,
    102.     .bust_num           ( rd_bust_len          ) ,
    103.     .data_over          ( data_over            ) ,
    104.  
    105.     .read_en            ( read_en              ) , // read_en的设计可以参考仿真模块里的设计。
    106.     .tx_data            ( tx_data              ) ,
    107.     .tx_flag            ( tx_flag              ) 
    108. );
    109. uart_tx uart_tx_inst(
    110.     .sys_clk            ( c0_sig    ) ,
    111.     .sys_rst_n          ( rst_n     ) ,
    112.     .pi_data            ( tx_data   ) ,
    113.     .pi_flag            ( tx_flag   ) ,
    114.  
    115.     .data_over          ( data_over ) ,
    116.     .tx                 ( tx        )        
    117. );
    118. /****************************************************************/
    119.     parameter   CYCLE = 20 ;
    120.     defparam    uart_tx_inst.CLK_UART = 50_000_0 ;
    121.     defparam    uart_rx_inst.CLK_UART = 50_000_0 ;
    122.     defparam    sdram_top_inst.sdram_ctrl_inst.sdram_aref_inst.MAX_CNT_750US = 200 ;
    123.     defparam    sdram_model_plus_inst.addr_bits = 13 ;
    124.     defparam    sdram_model_plus_inst.data_bits = 16 ;
    125.     defparam    sdram_model_plus_inst.col_bits  = 9  ;
    126.     defparam    sdram_model_plus_inst.mem_sizes = 2*1024*1024  ;
    127.     // rst_n rd_bust_len wr_bust_len
    128.     assign  rst_n = sys_rst_n && locked_sig ;
    129.     assign  rd_bust_len = 10'd10 ;
    130.     assign  wr_bust_len = 10'd10 ;
    131.     // rx
    132.     task rx_bit ;
    133.         input   [7:0]   data ;
    134.         integer i ;
    135.         for (i = 0;i <= 9 ;i = i  + 1 ) begin
    136.             case (i)
    137.                 0: rx <= 1'b0 ;
    138.                 1: rx <= data[i - 1];
    139.                 2: rx <= data[i - 1];
    140.                 3: rx <= data[i - 1];
    141.                 4: rx <= data[i - 1];
    142.                 5: rx <= data[i - 1];
    143.                 6: rx <= data[i - 1];
    144.                 7: rx <= data[i - 1];
    145.                 8: rx <= data[i - 1];
    146.                 9: rx <= 1'b1 ;
    147.                 default: rx <= 1'b1 ;
    148.             endcase
    149.             #(CYCLE * 52) ;
    150.         end
    151.     endtask
    152.     // rd_fifo_rd_req
    153.     // always @(posedge c0_sig or negedge rst_n) begin
    154.     //     if(~rst_n)
    155.     //         rd_fifo_rd_req <= 1'b0 ;
    156.     //     else if(rd_fifo_num == rd_bust_len)
    157.     //         rd_fifo_rd_req <= 1'b1 ;
    158.     //     else if(rd_fifo_num ==  0)
    159.     //         rd_fifo_rd_req <= 1'b0 ;
    160.     //     else 
    161.     //         rd_fifo_rd_req <= rd_fifo_rd_req ;
    162.     // end
    163.     always @(posedge c0_sig or negedge rst_n) begin
    164.         if(~rst_n) 
    165.             rd_flag <= 1'b1 ;
    166.         else if(rd_fifo_num == rd_bust_len && rd_flag == 1'b1)
    167.             rd_flag <= 1'b0 ;
    168.         else 
    169.             rd_flag <= rd_flag ;
    170.     end
    171.     always @(posedge c0_sig or negedge rst_n) begin
    172.         if(~rst_n)
    173.             rd_fifo_rd_req <= 1'b0 ;
    174.         else if(rd_fifo_num == rd_bust_len && rd_flag)
    175.             rd_fifo_rd_req <= 1'b1 ;
    176.         else if(rd_fifo_num ==  2)
    177.             rd_fifo_rd_req <= 1'b0 ;
    178.         else 
    179.             rd_fifo_rd_req <= rd_fifo_rd_req ;
    180.     end
    181.     initial begin
    182.         sys_clk_50Mhz = 1'b1    ;
    183.         sys_rst_n    <= 1'b0    ;
    184.         rx           <= 1'b1    ;
    185.         #(CYCLE)                ;
    186.         sys_rst_n     <= 1'b1   ;
    187.         #( CYCLE * 100  )       ;
    188.         rx_bit(8'b1)            ;
    189.         rx_bit(8'd2)            ;
    190.         rx_bit(8'd3)            ;
    191.         rx_bit(8'd4)            ;
    192.         rx_bit(8'd5)            ;
    193.         rx_bit(8'd6)            ;
    194.         rx_bit(8'd7)            ;
    195.         rx_bit(8'd8)            ;
    196.         rx_bit(8'd9)            ;
    197.         rx_bit(8'd10)           ;
    198.     end
    199.     always #(CYCLE / 2) sys_clk_50Mhz = ~sys_clk_50Mhz ;
    200.  
    201. endmodule

    top: 

    对下列模块进行例化。

     代码：

    1. module top(
    2.     input       wire            sys_clk         ,
    3.     input       wire            sys_rst_n       ,
    4.     input       wire            rx              ,
    5.  
    6.     output      wire            tx              ,
    7.     output      wire            sdram_cke       ,
    8.     output      wire            sdram_sck       ,
    9.     output      wire            sdram_csn       ,
    10.     output      wire            sdram_ras       ,
    11.     output      wire            sdram_cas       ,
    12.     output      wire            sdram_wen       ,
    13.     output      wire    [1:0]   sdram_bank      ,
    14.     output      wire    [12:0]  sdram_addr      ,
    15.  
    16.     inout       wire    [15:0]  sdram_dq        ,
    17.  
    18.     output      wire    [1:0]   sdram_dqm        
    19. );
    20.  
    21.     // 例化间连线
    22.     wire            clk_50Mhz       ;        
    23.     wire            clk_100Mhz      ;       
    24.     wire            clk_100Mhz_shift; 
    25.     wire            rst_n           ;
    26.     wire            po_flag         ;
    27.     wire    [7:0]   po_data         ;
    28.     wire            read_en         ; 
    29.     wire    [7:0]   tx_data         ;
    30.     wire            tx_flag         ;
    31.     wire    [15:0]  rd_fifo_rd_data ;
    32.     wire    [9:0]   rd_fifo_num     ;
    33.     wire            data_over       ;
    34.     //  例化
    35. clk_gen clk_gen_inst(
    36. 	.areset             ( ~sys_rst_n            ) ,
    37. 	.inclk0             ( sys_clk               ) ,
    38. 	.c0                 ( clk_50Mhz             ) ,
    39. 	.c1                 ( clk_100Mhz            ) ,
    40. 	.c2                 ( clk_100Mhz_shift      ) ,
    41. 	.locked             ( rst_n                 ) 
    42. );
    43. uart_rx uart_rx_inst(
    44.     .sys_clk            ( clk_50Mhz             ) ,
    45.     .sys_rst_n          ( rst_n                 ) ,
    46.     .rx                 ( rx                    ) ,
    47.  
    48.     .po_flag            ( po_flag               ) ,
    49.     .po_data            ( po_data               )  
    50. );
    51.  
    52. sdram_top sdram_top_inst(
    53.     .clk_50Mhz          ( clk_50Mhz             ) ,
    54.     .clk_100Mhz         ( clk_100Mhz            ) ,
    55.     .clk_shift          ( clk_100Mhz_shift      ) ,
    56.     .sys_rst_n          ( rst_n                 ) ,
    57.     .wr_fifo_wr_req     ( po_flag               ) ,
    58.     .wr_fifo_wr_data    ( {8'd0,po_data}        ) ,
    59.     .sdram_wr_b_addr    ( 24'd0                 ) ,
    60.     .sdram_wr_e_addr    ( 24'd10                ) ,
    61.     .wr_rst             ( ~rst_n                ) ,
    62.     .wr_bust_len        ( 10'd10                ) ,
    63.     .rd_fifo_b_addr     ( 24'd0                 ) ,
    64.     .rd_fifo_e_addr     ( 24'd10                ) ,
    65.     .rd_rst             ( ~rst_n                ) ,
    66.     .rd_bust_len        ( 10'd10                ) ,
    67.     .rd_valid           ( 1'b1                  ) , 
    68.     .rd_fifo_rd_req     ( read_en               ) ,
    69.  
    70.     .rd_fifo_rd_data    ( rd_fifo_rd_data       ) ,
    71.     .rd_fifo_num        ( rd_fifo_num           ) ,
    72.     .sdram_cke          ( sdram_cke             ) , 
    73.     .sdram_sck          ( sdram_sck             ) , 
    74.     .sdram_csn          ( sdram_csn             ) ,
    75.     .sdram_ras          ( sdram_ras             ) ,
    76.     .sdram_cas          ( sdram_cas             ) ,
    77.     .sdram_wen          ( sdram_wen             ) , 
    78.     .sdram_bank         ( sdram_bank            ) ,
    79.     .sdram_addr         ( sdram_addr            ) ,
    80.  
    81.     .sdram_dq           ( sdram_dq              ) ,
    82.  
    83.     .sdram_dqm          ( sdram_dqm             )
    84. );
    85. fifo_read fifo_read_inst(
    86.     .sys_clk            ( clk_50Mhz             ) , 
    87.     .sys_rst_n          ( rst_n                 ) ,
    88.     .rd_fifo_rd_data    ( rd_fifo_rd_data[7:0]  ) ,
    89.     .rd_fifo_num        ( rd_fifo_num           ) ,
    90.     .bust_num           ( 10'd10                ) , 
    91.     .data_over          ( data_over             ) ,
    93.     .read_en            ( read_en               ) , 
    94.     .tx_data            ( tx_data               ) ,
    95.     .tx_flag            ( tx_flag               ) 
    96. );
    97. uart_tx uart_tx_inst(
    98.     .sys_clk            ( clk_50Mhz             ) ,
    99.     .sys_rst_n          ( rst_n                 ) ,
    100.     .pi_data            ( tx_data               ) ,
    101.     .pi_flag            ( tx_flag               ) ,
    103.     .data_over          ( data_over             ) ,
    104.     .tx                 ( tx                    )          
    105. );
    106. endmodule

    仿真：

    1. `timescale 1ns/1ns
    2. module test_top();
    3.     reg             sys_clk_50Mhz   ;
    4.     reg             sys_rst_n       ;
    5.     reg             rx              ;
    6.  
    7.     wire            tx              ;
    8.     wire            sdram_cke       ;
    9.     wire            sdram_sck       ;
    10.     wire            sdram_csn       ;
    11.     wire            sdram_ras       ;
    12.     wire            sdram_cas       ;
    13.     wire            sdram_wen       ;
    14.     wire    [1:0]   sdram_bank      ;
    15.     wire    [12:0]  sdram_addr      ;
    16.     wire    [15:0]  sdram_dq        ;
    17.     wire    [1:0]   sdram_dqm       ;
    18.  
    19. top top_inst(
    20.     .sys_clk         ( sys_clk_50Mhz    ) ,
    21.     .sys_rst_n       ( sys_rst_n        ) ,
    22.     .rx              ( rx               ) ,
    23.  
    24.     .tx              ( tx               ) ,
    25.     .sdram_cke       ( sdram_cke        ) ,
    26.     .sdram_sck       ( sdram_sck        ) ,
    27.     .sdram_csn       ( sdram_csn        ) ,
    28.     .sdram_ras       ( sdram_ras        ) ,
    29.     .sdram_cas       ( sdram_cas        ) ,
    30.     .sdram_wen       ( sdram_wen        ) ,
    31.     .sdram_bank      ( sdram_bank       ) ,
    32.     .sdram_addr      ( sdram_addr       ) ,
    33.  
    34.     .sdram_dq        ( sdram_dq         ) ,
    35.  
    36.     .sdram_dqm       ( sdram_dqm        )  
    37. );
    38. sdram_model_plus sdram_model_plus_inst(
    39.     .Dq                 ( sdram_dq      ) , 
    40.     .Addr               ( sdram_addr    ) , 
    41.     .Ba                 ( sdram_bank    ) , 
    42.     .Clk                ( sdram_sck     ) , 
    43.     .Cke                ( sdram_cke     ) , 
    44.     .Cs_n               ( sdram_csn     ) , 
    45.     .Ras_n              ( sdram_ras     ) , 
    46.     .Cas_n              ( sdram_cas     ) , 
    47.     .We_n               ( sdram_wen     ) , 
    48.     .Dqm                ( {2'b00,sdram_dqm}     ) ,
    49.     .Debug              ( 1'b1          )  
    50. );
    51.     /******************************************************/
    52.     parameter   CYCLE = 20 ;
    53.     defparam    top_inst.uart_rx_inst.CLK_UART = 50_000_0 ;
    54.     defparam    top_inst.uart_tx_inst.CLK_UART = 50_000_0 ;
    55.     defparam    top_inst.uart_tx_inst.SUB_1K   = 100      ;
    56.     defparam    top_inst.sdram_top_inst.sdram_ctrl_inst.sdram_aref_inst.MAX_CNT_750US = 200 ;
    57.     defparam    sdram_model_plus_inst.addr_bits = 13 ;
    58.     defparam    sdram_model_plus_inst.data_bits = 16 ;
    59.     defparam    sdram_model_plus_inst.col_bits  = 9  ;
    60.     defparam    sdram_model_plus_inst.mem_sizes = 2*1024*1024  ;
    61.     // rx
    62.     task rx_bit ;
    63.         input   [7:0]   data ;
    64.         integer i ;
    65.         for (i = 0;i <= 9 ;i = i  + 1 ) begin
    66.             case (i)
    67.                 0: rx <= 1'b0 ;
    68.                 1: rx <= data[i - 1];
    69.                 2: rx <= data[i - 1];
    70.                 3: rx <= data[i - 1];
    71.                 4: rx <= data[i - 1];
    72.                 5: rx <= data[i - 1];
    73.                 6: rx <= data[i - 1];
    74.                 7: rx <= data[i - 1];
    75.                 8: rx <= data[i - 1];
    76.                 9: rx <= 1'b1 ;
    77.                 default: rx <= 1'b1 ;
    78.             endcase
    79.             #(CYCLE * 52) ;
    80.         end
    81.     endtask
    82.     initial begin
    83.         sys_clk_50Mhz = 1'b1    ;
    84.         sys_rst_n    <= 1'b0    ;
    85.         rx           <= 1'b1    ;
    86.         #(CYCLE)                ;
    87.         sys_rst_n     <= 1'b1   ;
    88.         #( CYCLE * 100  )       ;
    89.         rx_bit(8'b1)            ;
    90.         rx_bit(8'd2)            ;
    91.         rx_bit(8'd3)            ;
    92.         rx_bit(8'd4)            ;
    93.         rx_bit(8'd5)            ;
    94.         rx_bit(8'd6)            ;
    95.         rx_bit(8'd7)            ;
    96.         rx_bit(8'd8)            ;
    97.         rx_bit(8'd9)            ;
    98.         rx_bit(8'd10)           ;
    99.     end
    100.     always #(CYCLE / 2) sys_clk_50Mhz = ~sys_clk_50Mhz ;
    102. endmodule

    上板验证： 

  • 相关阅读:
    【语音识别入门】My-Voice-Analysis
    3D游戏角色动画
    vue的双向绑定的原理，和angular的对比
    springboot使用mybatis
    ubuntu上安装edge浏览器
    机房环境监控什么意思？机房环境监控系统作用
    mediakit 源码 轻微微 学习总结
    vue3 事件 emit 使用
    非零基础自学Java (老师：韩顺平) 第4章 运算符 4.21 二进制转八进制等 && 4.27 原码、反码、补码 && 4.28 位运算符
    【Java】如何将二进制转换成MultipartFile
  • 原文地址：https://blog.csdn.net/Meng_long2022/article/details/133965524