devbox
黑客灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Xilinx FPGA:vivado关于真双端口的串口传输数据的实验_xilinx 真双端口ram 读数据

作者：黑客灵魂 | 2024-07-31 06:39:08

赞

踩

xilinx 真双端口ram 读数据

一、实验内容

      用一个真双端RAM，端口A和端口B同时向RAM里写入数据0-99，A端口读出单数并存入单端口RAM1中，B端口读出双数并存入但端口RAM2中，当检测到按键1到来时将RAM1中的单数读出显示到PC端，当检测到按键2到来时，将RAM2中的双数显示到pc端。

二、信号流向图

TIPS：这里我本来想将single_ram_1和single_ram_2分成两个单独的模块，但是经过实验后发现，如果分成两个单独的模块的话会导致：

       ①两个单端RAM模块的tx_start（0或1）都会有值给uart_tx模块，即使是RAM1给【1】，RAM2中没有值【0】，uart_tx模块是无法判断 tx_start 到底来自于哪个模块，所以此时uart_tx模块只是能接收到一个tx_start的脉冲信号，但是无法判断信号来自哪个RAM模块，无法获取到相应的uart_data ,最终导致tx_flag都无法变成高电平，那就更不会返回给RAM模块tx_done信号了。

       ②如果单独为了正确信号能赋值给tx_start而重新去写一个ctrl模块的话，那么在ctrl模块中将无法使用判断条件，因为我们将状态作为了赋值条件而不仅仅是key_flag信号。

       那么我的解决方法就是把single_ram_2例化到single_ram_1当中，将single_ram_2输出的数据（uart_data_b及tx_start_b）和single_ram_1输出的数据（douta即tx_start_a）全部放在一个模块即single_ram_1中去做判断，但是我们仍然无法将single_ram_2的状态作为赋值的条件，所以只能采用这种比较粗暴的方式，也就是除了（ cur_state == REG || cur_state == READ ）时候tx_start <= tx_start_a ;那么其他情况就是tx_start <= tx_start_b ; uart_data的处理也是同样。详见后面程序。

       其实最好的方式是将single_ram_2和single_ram_1写在同一个模块中，程序放在文章最后了。

三、程序设计

（1）按键消抖模块：

这里注意key1和key2不能使用同一个计数器，不然在同一个模块中也会判断出问题。

  1. `timescale 1ns / 1ps
  2. module key_debounce(
  3.   input           sys_clk    ,
  4.   input           rst_n      ,
  5.   input           key1        ,
  6.   input           key2        ,
  7.   output          key_flag_1   ,
  8.   output          key_flag_2
  9.     );
  10. //    parameter              delay = 100_000_0   ; //20ms
  11.     parameter              delay = 100;// 测试用
  12.     reg[19:0]               cnt1   ;
  13.     reg[19:0]               cnt2   ;
  14.   
  15.   key_flag_1  
  16.     always@(posedge sys_clk )
  17.          if(!rst_n)
  18.             cnt1 <= 0 ;
  19.          else if ( key1 == 0 )begin
  20.               if ( cnt1 == delay -1 )
  21.                    cnt1 <= cnt1 ;
  22.               else 
  23.                    cnt1 <= cnt1 +1 ;
  24.          end
  25.          else
  26.          cnt1 <= 0 ;
  27.      
  28.      assign  key_flag_1 = ( cnt1 == delay -2 )?1:0 ;
  29.    
  30.    ///key_flag_2
  31.      always@(posedge sys_clk )
  32.          if(!rst_n)
  33.             cnt2 <= 0 ;
  34.          else if ( key2 == 0 )begin
  35.               if ( cnt2 == delay -1 )
  36.                    cnt2 <= cnt2 ;
  37.               else 
  38.                    cnt2 <= cnt2 +1 ;
  39.          end
  40.          else
  41.          cnt2 <= 0 ;
  42.      
  43.      assign  key_flag_2 = ( cnt2 == delay -2 )?1:0 ;  
  44.     
  45.  
  46.     
  47.     
  48. endmodule

（2）真双端模块：

IP参数：

  1. `timescale 1ns / 1ps
  2. module the_true_ram(
  3.      input                 sys_clk     ,
  4.      input                 rst_n       ,
  5.      output  [7:0]         ram_odd_data  ,
  6.      output  [7:0]         ram_even_data
  7.     );
  8.     A端口
  9.     reg          wea     ;
  10.     reg  [6 : 0] addra   ;
  11.     reg  [7 : 0] dina    ;
  12.     wire [7 : 0] douta   ;
  13.     
  14.     always@(posedge sys_clk )
  15.          if(!rst_n)
  16.             wea <= 0 ;
  17.          else if ( addra >= 99 )
  18.             wea <= 0 ;
  19.          else
  20.             wea <= 1 ;
  21.     
  22.     always@(posedge sys_clk )
  23.          if(!rst_n)
  24.             addra <= 0 ;
  25.          else if ( addra >= 99 )
  26.             addra <= 99 ;
  27.          else
  28.             addra <= addra +1 ;
  29.     
  30.     always@(posedge sys_clk )
  31.          if(!rst_n)
  32.             dina <= 0 ;
  33.          else if (dina >= 99)
  34.             dina <= 99 ;
  35.          else
  36.             dina <= dina +1 ;
  37.     
  38.     wire [7:0]        data_a  ;
  39.     assign       data_a = douta ;
  40.     assign       ram_odd_data = (data_a%2 == 1)?data_a : ram_odd_data ;
  41.       
  42.     ///b端口
  43.      reg          web    ; 
  44.      reg  [6 : 0] addrb  ;
  45.      reg  [7 : 0] dinb   ;
  46.      wire [7 : 0] doutb  ;
  47.      
  48.      always@(posedge sys_clk )
  49.           if(!rst_n)
  50.              web <= 0 ;
  51.           else if ( addrb >= 99 )
  52.              web <= 0 ;
  53.           else
  54.              web <= 1 ;
  55.    
  56.    always@(posedge sys_clk )
  57.         if(!rst_n)
  58.            addrb <= 0 ;
  59.         else if ( addrb >= 99 )
  60.            addrb <= 99 ;
  61.         else
  62.            addrb <= addrb +1 ;
  63.     
  64.     always@(posedge sys_clk )
  65.          if(!rst_n)
  66.             dinb <= 0 ;
  67.          else if ( dinb >= 99 )
  68.             dinb <= 99 ;
  69.          else
  70.             dinb <= dinb +1 ;
  71.   
  72.     wire[7:0]   data_b  ;
  73.     assign      data_b = doutb ;
  74.     assign      ram_even_data = (data_b %2 == 0 )? data_b : ram_even_data ;
  75.     
  76.     
  77.     
  78. //----------- Begin Cut here for INSTANTIATION Template ---// INST_TAG
  79. true_ram your_instance_name (
  80.   .clka(sys_clk ),    // input wire clka
  81.   .ena(1),      // input wire ena
  82.   .wea(wea),      // input wire [0 : 0] wea
  83.   .addra(addra),  // input wire [6 : 0] addra
  84.   .dina(dina),    // input wire [7 : 0] dina
  85.   .douta(douta),  // output wire [7 : 0] douta
  86.   .clkb(sys_clk ),    // input wire clkb
  87.   .enb(1),      // input wire enb
  88.   .web(web),      // input wire [0 : 0] web
  89.   .addrb(addrb),  // input wire [6 : 0] addrb
  90.   .dinb(dinb),    // input wire [7 : 0] dinb
  91.   .doutb(doutb)  // output wire [7 : 0] doutb
  92. );
  93. // INST_TAG_END ------ End INSTANTIATION Template ---------
  94.  
  95.  
  96.  
  97.  
  98.  
  99. endmodule

（3）单端RAM2模块：

但其实深度在50就够用了。（100里面的奇数和偶数50）

  1. `timescale 1ns / 1ps
  2. module single_ram_2_FMS(
  3.    input               sys_clk        ,
  4.    input               rst_n          ,
  5.    input               key_flag_2     ,
  6.    input               tx_done        ,
  7.    input    [7:0]      ram_even_data  ,
  8.    output   reg        tx_start_b       ,
  9.    output   reg[7:0]   uart_data_b
  10.  
  11.     );
  12.     存双数的RAM
  13.     reg          ena           ;
  14.     reg  [0 : 0] wea           ;
  15.     reg  [6 : 0] addra         ;
  16.     reg  [7 : 0] dina          ;
  17.     wire [7 : 0] douta         ;
  18.  
  19.     //先写再读出
  20.     localparam         IDLE  = 3'd0 ;
  21.     localparam         WRITE = 3'd1 ;
  22.     localparam         REG   = 3'd2 ;
  23.     localparam         READ  = 3'd3 ;
  24.     
  25.     reg[2:0]           cur_state    ;
  26.     reg[2:0]           next_state   ;
  27.  
  28.     
  29.     //state1
  30.     always@(posedge sys_clk )
  31.          if(!rst_n)
  32.             cur_state <= IDLE ;
  33.          else 
  34.             cur_state <= next_state ;
  35.     
  36.     //state2
  37.     always@(*)
  38.           case(cur_state)
  39.               IDLE  :
  40.                      begin
  41.                          next_state = WRITE ;
  42.                      end
  43.               WRITE :
  44.                      begin
  45.                         if ( key_flag_2 )
  46.                             next_state = REG ;
  47.                         else
  48.                             next_state = cur_state ;
  49.                      end
  50.               REG   :
  51.                      begin
  52.                          next_state = READ ;
  53.                      end
  54.               READ  :
  55.                      begin
  56.                          if(addra == 49)
  57.                             next_state = IDLE ;
  58.                          else
  59.                             next_state <= cur_state ;
  60.                      end
  61.           default:;
  62.           endcase
  63.    
  64.    //state3
  65.    always@(posedge sys_clk )
  66.         if(!rst_n)begin
  67.            ena   <= 0 ;
  68.            wea   <= 0 ;
  69.            addra <= 0 ;
  70.            dina  <= 0 ;
  71.            tx_start_b <= 0 ;
  72.         end
  73.         else
  74.             case(cur_state)
  75.                   IDLE   :
  76.                           begin
  77.                                ena   <= 0 ;
  78.                                wea   <= 0 ;
  79.                                addra <= 0 ;
  80.                                dina  <= ram_even_data ;
  81.                           end
  82.                   WRITE  :
  83.                           begin
  84.                               ena <= 1 ;
  85.                               wea <= 1 ;
  86.                               if(addra == 49)
  87.                                  addra <= 49 ;
  88.                               else
  89.                                  addra <= addra +1 ;
  90.                               dina <= ram_even_data ;
  91.                           end
  92.                   REG    :
  93.                           begin
  94.                               addra <= 0 ;
  95.                               ena   <= 0 ;
  96.                               wea   <= 0 ;
  97.                               dina  <= 0 ;
  98.                               tx_start_b <= 1 ;
  99.                           end
  100.                   READ   :
  101.                           begin
  102.                               ena <= 1 ;
  103.                               wea <= 0 ;
  104.                               dina<= 0 ;
  105.                               if(tx_done)begin
  106.                                  tx_start_b <= 1 ;
  107.                                  addra <= addra +1 ;
  108.                               end
  109.                               else begin
  110.                                  tx_start_b <= 0 ;
  111.                                  addra <= addra ;
  112.                                  end
  113.                           end
  114.             default:;
  115.             endcase
  116.            
  117.     
  118.     
  119. //----------- Begin Cut here for INSTANTIATION Template ---// INST_TAG
  120. single_ram ram2 (
  121.   .clka(sys_clk ),    // input wire clka
  122.   .ena(ena),      // input wire ena
  123.   .wea(wea),      // input wire [0 : 0] wea
  124.   .addra(addra),  // input wire [6 : 0] addra
  125.   .dina(dina),    // input wire [7 : 0] dina 
  126.   .douta(douta)  // output wire [7 : 0] douta
  127. );
  128. // INST_TAG_END ------ End INSTANTIATION Template ---------
  129.     
  130.     always@(posedge sys_clk )
  131.          if(!rst_n)
  132.             uart_data_b <= 0 ;
  133.          else if ( cur_state == READ )
  134.             uart_data_b <= douta ;
  135.          else
  136.             uart_data_b <= uart_data_b ;
  137.     
  138.  
  139.   always@(posedge sys_clk )
  140.        if(!rst_n)
  141.           tx_start_b <= 0 ;
  142.        else if ( cur_state == REG || cur_state == READ  )
  143.            tx_start_b <= 1 ;
  144.        else
  145.           tx_start_b <= tx_start_b ;  
  146.     
  147.     
  148. endmodule

（4）单端RAM1模块

配置和前面一样

  1. `timescale 1ns / 1ps
  2. module single_ram_1_FMS(
  3.     input                 sys_clk      ,
  4.     input                 rst_n        ,
  5.     input                 key_flag_1   ,
  6.     input                 key_flag_2   ,
  7.     input                 tx_done      ,
  8.     input[7:0]            ram_odd_data ,
  9.     input[7:0]            ram_even_data,
  10.     output      reg       tx_start     ,
  11.     output   reg[7:0]     uart_data        
  12.  
  13.     );
  14.     /读单数的RAM
  15.     reg          ena     ;       
  16.     reg          wea     ;
  17.     reg  [6 : 0] addra   ;
  18.     reg  [7 : 0] dina    ;
  19.     wire [7 : 0] douta   ;
  20.     
  21.     reg           tx_start_a  ;
  22.    wire           tx_start_b     ; 
  23.    wire[7:0]      uart_data_b    ; 
  24.  
  25.     
  26.    先写再读出
  27.    localparam             IDLE   = 3'd0 ;
  28.    localparam             ERITE  = 3'd1 ;
  29.    localparam             REG    = 3'd2 ;
  30.    localparam             READ   = 3'd3 ;
  31.    
  32.    reg[2:0]        cur_state    ;
  33.    reg[2:0]        next_state   ;
  34.  
  35.    
  36.    //state1
  37.    always@(posedge sys_clk )
  38.         if(!rst_n)
  39.            cur_state <= IDLE  ;
  40.         else
  41.            cur_state <= next_state ;
  42.    
  43.    //state2
  44.    always@(*)
  45.         case(cur_state)
  46.             IDLE  :
  47.                    begin
  48.                        next_state = ERITE ;
  49.                    end
  50.             ERITE :
  51.                    begin
  52.                        if(key_flag_1)
  53.                           next_state = REG ;
  54.                        else
  55.                           next_state <= cur_state ;
  56.                    end
  57.             REG   :
  58.                    begin
  59.                        next_state = READ ;//用来发送tx_start
  60.                    end
  61.             READ  :
  62.                    begin
  63.                        if(addra == 49)//100内的单数是50
  64.                          next_state = IDLE ;
  65.                        else
  66.                          next_state = cur_state ;
  67.                    end
  68.         default:;
  69.         endcase
  70.     
  71.     //state3
  72.     always@(posedge sys_clk )
  73.          if(!rst_n)begin
  74.                ena  <= 0 ;
  75.                wea  <= 0 ;
  76.                addra<= 127 ;
  77.                dina <= 0 ;
  78.                tx_start_a <= 0 ;
  79.          end
  80.          else
  81.              case(cur_state)
  82.                      IDLE  :
  83.                             begin
  84.                                  ena  <= 0 ;
  85.                                  wea  <= 0 ;
  86.                                  addra<= 7'd127 ;
  87.                                  dina <= ram_odd_data ;
  88.                             end
  89.                      ERITE :
  90.                             begin
  91.                                 ena <= ~ena ;
  92.                                 wea <= ~wea ;
  93.                                 if( addra == 49 && wea)
  94.                                     addra <= 49 ;
  95.                                 else if(wea)
  96.                                     addra <= addra +1 ;
  97.                                     dina <= ram_odd_data ;
  98.                             end
  99.                      REG   :
  100.                             begin
  101.                                 ena  <= 0 ;         
  102.                                 wea  <= 0 ;         
  103.                                 addra<= 0 ;         
  104.                                 dina <= 0 ;   
  105.                                 tx_start_a <= 1 ;                            
  106.                             end
  107.                      READ  :
  108.                             begin
  109.                                  ena <= 1 ;
  110.                                  wea <= 0 ;
  111.                                  dina<= 0 ;
  112.                                  if(tx_done)begin
  113.                                     tx_start_a <= 1 ;
  114.                                     addra <= addra +1 ;
  115.                                  end
  116.                                  else begin
  117.                                     tx_start_a <= 0 ;
  118.                                     addra <= addra ;
  119.                                     end
  120.                             end
  121.              default:;
  122.              endcase
  123.  
  124.     
  125. //----------- Begin Cut here for INSTANTIATION Template ---// INST_TAG
  126. single_ram ram1 (
  127.   .clka(sys_clk ),    // input wire clka
  128.   .ena(ena),      // input wire ena
  129.   .wea(wea),      // input wire [0 : 0] wea
  130.   .addra(addra),  // input wire [6 : 0] addra
  131.   .dina(dina),    // input wire [7 : 0] dina
  132.   .douta(douta)  // output wire [7 : 0] douta
  133. );
  134. // INST_TAG_END ------ End INSTANTIATION Template ---------
  135.     
  136.  
  137.   always@(posedge sys_clk )
  138.        if(!rst_n)
  139.           uart_data <= 0;
  140.        else if ( cur_state == READ )
  141.           uart_data <= douta ;
  142.        else
  143.           uart_data <= uart_data_b ;
  144.           
  145.   
  146.  
  147.   always@(posedge sys_clk )
  148.        if(!rst_n)
  149.           tx_start <= 0 ;
  150.        else if ( cur_state == REG || cur_state == READ  )
  151.           tx_start <= tx_start_a ;
  152.        else
  153.           tx_start <= tx_start_b ; 
  154.   
  155.   
  156.   例化ram2 
  157.  
  158.  
  159.  
  160.    
  161.  single_ram_2_FMS  single_ram_2_FMS_u(
  162.                                  .  sys_clk       (sys_clk      )    ,
  163.                                  .  rst_n         (rst_n        )    ,
  164.                                  .  key_flag_2    (key_flag_2   )    ,
  165.                                  .  tx_done       (tx_done      )    ,
  166.                                  .  ram_even_data (ram_even_data)    ,
  167.                                  .  tx_start_b    (tx_start_b   )    ,
  168.                                  .  uart_data_b   (uart_data_b  )
  169.  
  170.     );   
  171.     
  172.     
  173.     
  174.     
  175.     
  176.     
  177.     
  178.     
  179. endmodule

（5）uart_tx模块：

  1. `timescale 1ns / 1ps
  2. module uart_tx(
  3.      input               sys_clk   ,
  4.      input               rst_n     ,
  5.      input  wire[7:0]   uart_data ,
  6.      input               rx_done   ,        
  7.      output   reg        tx_data   , 
  8.      output   reg        tx_done
  9.     );
  10.     parameter         SYSCLK =   50_000_000  ;
  11.     parameter         Baud   =   115200      ;
  12.     parameter         COUNT  =   SYSCLK/Baud ;//434   传输1比特所需要的时钟周期
  13.     parameter         MID    =   COUNT/2     ;
  14.  
  15.     wire                 start_flag ;
  16.     reg                  tx_flag   ;
  17.  
  18.     reg                  tx_reg1   ;
  19.     reg                  tx_reg2   ;
  20.     
  21.     reg[4:0]             cnt_bit   ;
  22.     reg[10:0]            cnt       ;
  23.  
  24.  
  25.  
  26. //tx_start
  27.     always@(posedge sys_clk)
  28.           if(!rst_n)begin
  29.              tx_reg1 <= 0 ;
  30.              tx_reg2 <= 0 ;
  31.            end
  32.            else begin
  33.               tx_reg1 <= rx_done  ;
  34.               tx_reg2 <= tx_reg1  ;
  35.            end
  36.  
  37.    assign  start_flag = tx_reg1 & ~tx_reg2 ;
  38.  
  39.  ///tx_flag
  40.    always@(posedge sys_clk)
  41.          if(!rst_n)
  42.             tx_flag <= 0 ;
  43.          else if ( start_flag == 1 )
  44.             tx_flag <= 1 ;
  45.          else if ( cnt == COUNT -1 && cnt_bit == 10)
  46. //         else if ( cnt == MID -1 && cnt_bit == 10)
  47.             tx_flag <= 0 ;
  48.          else
  49.             tx_flag <= tx_flag ;
  50.  ///计时器
  51.   //    cnt 434  
  52.      always@(posedge sys_clk )
  53.            if(!rst_n)
  54.               cnt <= 0;
  55.            else if ( tx_flag == 1 )begin
  56.                 if ( cnt == COUNT -1) ///一定要减一，如果不减一，实际会计到435次，反算回去波特率就不是115200了
  57.                     cnt <= 0;
  58.                 else
  59.                     cnt <= cnt +1 ;
  60.            end
  61.            else
  62.                cnt <= 0 ;
  63.   
  64.    //  /计数器
  65.       always@(posedge sys_clk )
  66.            if(!rst_n)
  67.               cnt_bit <= 0 ;
  68.            else if ( tx_flag )begin
  69.                 if ( cnt == COUNT -1)begin
  70.                     if(cnt_bit == 10)///0123456789 10
  71.                     cnt_bit <= 0 ;
  72.                     else
  73.                     cnt_bit <= cnt_bit +1 ;
  74.                     end
  75.                 else
  76.                 cnt_bit <= cnt_bit     ;
  77.                 end
  78.            else
  79.            cnt_bit <= 0 ;
  80.            
  81.   parameter             MODE_CHECK = 0 ;
  82.  
  83.  
  84.      always@(posedge sys_clk )
  85.           if(!rst_n)
  86.           tx_data <= 1 ;   //表示没有数据
  87.           else if ( tx_flag )begin
  88.                 if (   cnt_bit > 0 && cnt_bit < 9 )
  89.                 ///cnt_bit 0 12345678 9 
  90.                 ///tx_data 0123456789
  91.                 ///uart_data 01234567
  92.                 tx_data <= uart_data [cnt_bit-1]; //这里uart_data是不断随着cnt_bit变化的，只有在第九位的时候才有正确的最终值
  93.                 else if(cnt_bit == 0)
  94.                 tx_data <= 0 ;
  95.                 else if(cnt_bit == 9)
  96.                 tx_data <= (MODE_CHECK == 0)? ^uart_data: ~^uart_data;
  97.               /*
  98.               MODE_CHECK == 0是偶校验，假如uart_data是1110_0000，其异或的结果
  99.               是1，将异或的结果作为校验位，让数据位和校验位异或的结果为0，满足偶校验。
  100.               假如uart_data是1110_1000，其异或的结果是0，将异或的结果作为校验位，
  101.               让数据位和校验位异或的结果为0，满足偶校验。奇校验则相反。
  102.               */
  103.                 else if (cnt_bit == 10)///停止位
  104.                 tx_data <= 1 ;
  105.                 else
  106.                 tx_data <= tx_data ;
  107.           end
  108.           else
  109.           tx_data <= 1 ;
  110.           
  111.           
  112.        always@(posedge sys_clk )
  113.           if(!rst_n)           
  114.             tx_done <= 0 ;
  115.           else if (tx_flag)begin
  116.                if ( cnt_bit == 10 && cnt == COUNT -1)
  117. //               if ( cnt_bit == 10 && cnt == MID/2 -1)
  118.                    tx_done <= 1 ;
  119.                else
  120.                    tx_done <= 0 ;       
  121.           end
  122.           else
  123.             tx_done <= 0 ;  
  124. endmodule

四、仿真模块

（1）仿真true_ram模块

代码：

  1. `timescale 1ns / 1ps
  2. module test_the_true_ram( );
  3.  
  4.      reg                 sys_clk       ;
  5.      reg                 rst_n         ;
  6.      wire  [7:0]         ram_odd_data  ;
  7.      wire  [7:0]         ram_even_data ;
  8.      
  9.      initial
  10.             begin
  11.                  sys_clk = 0 ;
  12.                  rst_n   = 0 ;
  13.                  #10  
  14.                  rst_n = 1 ;
  15.             end
  16.            
  17.      always #1 sys_clk = ~sys_clk ; 
  18.  
  19.     the_true_ram the_true_ram_1(
  20.                                  .   sys_clk       (sys_clk      )    ,
  21.                                  .   rst_n         (rst_n        )    ,
  22.                                  .   ram_odd_data  (ram_odd_data )    ,
  23.                                  .   ram_even_data (ram_even_data)
  24.     );
  25.     
  26.     
  27.     
  28.     
  29. endmodule

仿真结果：

（2）仿真TOP：

代码：

  1. `timescale 1ns / 1ps
  2. module test_TOP( );
  3.  
  4.   reg                sys_clk   ;
  5.   reg                rst_n     ;
  6.   reg                key_1     ;
  7.   reg                key_2     ;
  8.   wire               tx_data   ;
  9.   
  10.   initial
  11.         begin
  12.              sys_clk = 0 ;
  13.              rst_n   = 0 ;
  14.              key_1   = 1 ;
  15.              key_2   = 1 ;
  16.              #10
  17.              rst_n   = 1 ;
  18.              #10000
  19.              key_1   = 0 ;
  20.  
  21.         end
  22.   
  23.   always #1 sys_clk = ~sys_clk ;
  24.   
  25.   
  26. TOP TOP_1(
  27.   .    sys_clk  (sys_clk)   ,
  28.   .    rst_n    (rst_n  )   ,
  29.   .    key_1    (key_1  )   ,
  30.   .    key_2    (key_2  )   ,
  31.   .    tx_data  (tx_data)  
  32.     );
  33.  
  34.  
  35.  
  36. endmodule

 仿真结果：

TOP：

single_ram_1 :

五、需要注意的一些问题

（1）

（2）

（3）控制模块最好这么写

  1. `timescale 1ns / 1ps
  2. module single_ram_2(
  3.     input               sysclk          ,
  4.     input               rst_n           ,
  5.     input               key_flag1       ,
  6.     input               key_flag2       ,
  7.     input               tx_done         ,
  8.     input       [7:0]   ram_odd_data    , //单数
  9.     input       [7:0]   ram_even_data   , //双数
  10.     output  reg         tx_start        ,
  11.     output  reg [7:0]   uart_data            
  12.     );
  13. //存单数的RAM
  14. reg          wea    ;
  15. reg          ena    ;
  16. reg   [6:0] addra  ;
  17. reg   [7:0] dina   ;
  18. wire  [7:0] douta  ;
  19. ///先写再读出
  20. localparam      IDLE  = 3'd0;
  21. localparam      WRITE = 3'd1; 地址加1
  22. localparam      REG   = 3'd2;  ///缓冲状态   地址清零
  23. localparam      READ  = 3'd3;
  24. reg     [2:0]   cur_state,next_state;
  25. reg             tx_start_a  ;
  26. always@(posedge sysclk)
  27.     if(!rst_n)
  28.         cur_state <= IDLE;
  29.     else
  30.         cur_state <= next_state;
  31. always@(*)
  32.     case(cur_state)
  33.         IDLE  : begin
  34.             if(key_flag1)
  35.                 next_state = WRITE;
  36.             else
  37.                 next_state = cur_state;
  38.         end   
  39.         WRITE :begin
  40.             if(addra >= 49)
  41.                 next_state = REG;
  42.             else
  43.                 next_state = cur_state; 
  44.         end
  45.         REG   :begin
  46.             next_state = READ;
  47.         end
  48.         READ  :begin
  49.             if(addra >= 49)
  50.                 next_state = IDLE;
  51.             else
  52.                 next_state = cur_state;    
  53.         end
  54.         default:;
  55.     endcase
  56. always@(posedge sysclk)
  57.     if(!rst_n)begin
  58.         addra <= 0;
  59.         wea <= 0;
  60.         ena <= 0;
  61.         dina <= 0;
  62.         tx_start_a <= 0;
  63.     end
  64.     else
  65.         case(cur_state)
  66.             IDLE  :begin
  67.                 addra <= 0;
  68.                 wea <= 0;
  69.                 ena <= 0;
  70.                 dina <= ram_odd_data;  维持2个
  71.             end
  72.             WRITE :begin   ///99/48
  73.                 ena <= ~ena;     ///
  74.                 wea <= ~wea;     ///
  75.                 if(addra >= 49)
  76.                     addra <= 49;
  77.                 else if(wea)
  78.                     addra <= addra + 1; 
  79.                 dina <= ram_odd_data;
  80.             end
  81.             REG   :begin
  82.                 addra <= 0;
  83.                 ena <= 0;
  84.                 wea <= 0;
  85.                 dina <= 0;
  86.                 tx_start_a <= 1;   ///发送第一个数据
  87.             end
  88.             READ  :begin  
  89.                 ena <= 1;
  90.                 wea <= 0;
  91.                 dina <= 0;
  92.                 if(tx_done)begin
  93.                     tx_start_a <= 1;
  94.                     addra <= addra + 1;
  95.                 end
  96.                 else begin
  97.                     tx_start_a <= 0;
  98.                     addra <= addra;
  99.                 end     
  100.             end
  101.             default:; 
  102.         endcase
  103.  
  104. blk_mem_gen_2 ram_a (
  105.   .clka(sysclk),    // input wire clka
  106.   .ena(ena),      // input wire ena
  107.   .wea(wea),      // input wire [0 : 0] wea
  108.   .addra(addra),  // input wire [6 : 0] addra
  109.   .dina(dina),    // input wire [7 : 0] dina
  110.   .douta(douta)  // output wire [7 : 0] douta
  111. );
  112. /b端口    存双数
  113. reg             web   ;
  114. reg             enb    ;
  115. reg  [6:0]      addrb ;
  116. reg  [7:0]      dinb  ;
  117. wire [7:0]      doutb;
  118. //状态机
  119. ///先写再读出
  120. localparam      RD_IDLE  = 3'd4;
  121. localparam      RD_WRITE = 3'd5;
  122. localparam      RD_REG   = 3'd6;  ///缓冲状态
  123. localparam      RD_READ  = 3'd7;
  124. reg     [2:0]   rd_cur_state,rd_next_state;
  125. reg             tx_start_b      ;
  126. always@(posedge sysclk)
  127.     if(!rst_n)
  128.         rd_cur_state <= RD_IDLE;
  129.     else
  130.         rd_cur_state <= rd_next_state;
  131. always@(*)
  132.     case(rd_cur_state)
  133.         RD_IDLE  : begin
  134.             if(key_flag2)
  135.                 rd_next_state = RD_WRITE;
  136.             else
  137.                 rd_next_state = rd_cur_state;
  138.         end   
  139.         RD_WRITE :begin
  140.             if(addrb >= 49)
  141.                 rd_next_state = RD_REG;
  142.             else
  143.                 rd_next_state = rd_cur_state; 
  144.         end
  145.         RD_REG   :begin
  146.             rd_next_state = RD_READ;
  147.         end
  148.         RD_READ  :begin
  149.             if(addrb >= 49)
  150.                 rd_next_state = RD_IDLE;
  151.             else
  152.                 rd_next_state = rd_cur_state;    
  153.         end
  154.         default:;
  155.     endcase
  156. always@(posedge sysclk)
  157.     if(!rst_n)begin
  158.         addrb <= 0;
  159.         web <= 0;
  160.         enb <= 0;
  161.         dinb <= 0;
  162.         tx_start_b <= 0;
  163.     end
  164.     else
  165.         case(rd_cur_state)
  166.             RD_IDLE  :begin
  167.                 addrb <= 0;
  168.                 web <= 0;
  169.                 enb <= 0;
  170.                 dinb <= ram_even_data;  ///020406
  171.             end
  172.             RD_WRITE :begin
  173.                 enb <= ~enb;  
  174.                 web <= ~web;
  175.                 if(addrb >= 49)
  176.                     addrb <= 49;
  177.                 else if(web)
  178.                     addrb <= addrb + 1; 
  179.                 dinb <= ram_even_data;
  180.             end
  181.             RD_REG   :begin
  182.                 addrb <= 0;
  183.                 enb <= 0;
  184.                 web <= 0;
  185.                 dinb <= 0;
  186.                 tx_start_b <= 1;
  187.             end
  188.             RD_READ  :begin  
  189.                 enb <= 1;
  190.                 web <= 0;
  191.                 dinb <= 0;
  192.                 if(tx_done)begin
  193.                     tx_start_b <= 1;
  194.                     addrb <= addrb + 1;
  195.                 end
  196.                 else begin
  197.                     tx_start_b <= 0;
  198.                     addrb <= addrb;
  199.                 end     
  200.             end
  201.             default:; 
  202.         endcase
  203. blk_mem_gen_2 ram_b (
  204.   .clka(sysclk),    // input wire clka
  205.   .ena(enb),      // input wire ena
  206.   .wea(web),      // input wire [0 : 0] wea
  207.   .addra(addrb),  // input wire [6 : 0] addra
  208.   .dina(dinb),    // input wire [7 : 0] dina
  209.   .douta(doutb)  // output wire [7 : 0] douta
  210. );
  211. always@(posedge sysclk)
  212.     if(!rst_n)
  213.         uart_data <= 0;
  214.     else if(cur_state == READ )
  215.         uart_data <= douta  ;
  216.     else if(rd_cur_state == RD_READ )
  217.         uart_data <= doutb  ;
  218.     else
  219.         uart_data <= uart_data;
  220.      
  221. always@(posedge sysclk)
  222.     if(!rst_n)
  223.         tx_start <= 0;
  224.     else if(cur_state == REG || cur_state == READ)
  225.         tx_start <= tx_start_a;
  226.     else if(rd_cur_state == RD_REG || rd_cur_state == RD_READ)
  227.         tx_start <= tx_start_b;
  228.     else
  229.         tx_start <= tx_start;
  230.            
  231. endmodule

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/黑客灵魂/article/detail/907447
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号