RAM + 串口的简单应用

news2024/9/9 7:49:41

REVIEW

之前已经学习过：

RAM： RAM IP核配置_ip核 ram配置-CSDN博客

串口接收：Vivado 串口接收优化-CSDN博客

串口发送：Vivado 串口通信(UART)------串口发送_vivado串口收发实验-CSDN博客

按键：基于状态机的按键消抖实现-CSDN博客

按键+串口发送实验_串口发按键值-CSDN博客

1.  今日摸鱼任务

小梅哥教材：02_【逻辑教程】基于HDL的FPGA逻辑设计与验证教程V3.4.pdf

                        15 搭建串口收发与存储双口 RAM 简易应用系统
实现：串口写入RAM，按键控制串口发送RAM中的数据

2.  系统框图

系统框图如下图：

（其中baud_set[2:0]，摸鱼怪是直接改的波特率）

（俺下载的这版还有小错误嘎嘎嘎~右下角应该是串口发送tx）

分析：

        绿色：已封装好的模块

        黄色：添加RAM IP核

        红色ctrl：编写ctrl模块

        总：写顶层

3.  RAM配置

 RAM： RAM IP核配置_ip核 ram配置-CSDN博客

使用的是无ena 、enb第一版

4.  RX + RAM

uartrx.v

区别于之前的程序，使rx_data提前于rx_done一个clk

module uartrx(
                 input clk ,
                 input reset_n ,
                 input uart_rx ,
                 output reg [7:0]rx_data,
                 output reg rx_done    );
    //默认使用波特率BAUD 115200  时钟频率 CLK_FREQ  50MHz
//    parameter start_bit = 0 ;
//    parameter stop_bit  = 1 ;
    parameter BAUD = 9600;
    parameter CLK_FREQ = 50_000_000;
    parameter bps_c = CLK_FREQ / BAUD ;    
    reg rx_en ;   
    reg[3:0] rx_flag;
        // bps 
        reg [30:0] counter_bps ;        
      always@(posedge clk or negedge reset_n)
        if(! reset_n) 
            counter_bps <= 0 ;
        else if (rx_en)
            if(counter_bps == bps_c - 1)
                counter_bps <= 0 ;
            else
                counter_bps <= counter_bps + 1'b1 ;
        else
            counter_bps <= 0 ;
        reg dff_rx_0 , dff_rx_1 ;
        reg r_uart_rx; 
        wire neg_rx_go ;
        always@(posedge clk )    
            dff_rx_0 <= uart_rx ;
        always@(posedge clk )    
            dff_rx_1 <= dff_rx_0 ;
        always@(posedge clk )    
            r_uart_rx <= dff_rx_1 ;
            
        assign neg_rx_go = (dff_rx_1 == 0)&&(r_uart_rx == 1);
        
      // rx_en 
        always@(posedge clk or negedge reset_n)
        if(! reset_n) 
            rx_en <= 0 ;
        else if(neg_rx_go) 
            rx_en <= 1 ;
        else if((rx_flag==9)&&(counter_bps == bps_c / 2))
            rx_en <= 0 ;
        else if((rx_flag==0)&&(counter_bps == bps_c/2 )&&(dff_rx_1==1)) 
            rx_en <= 0 ;
               
     // rx_flag
        always@(posedge clk or negedge reset_n)
        if(!reset_n) rx_flag <= 4'b0000 ;
        else if((rx_flag == 9)&&(counter_bps == bps_c /2)) rx_flag <= 4'b0000 ;
        else if(counter_bps == bps_c - 1)  rx_flag <= rx_flag + 1'b1 ;
         
     // [7:0]r_rx_data   
     reg [7:0] r_rx_data;
     always@(posedge clk )
       if(!rx_en) r_rx_data <= r_rx_data;
       else if(counter_bps == bps_c / 2)
        begin 
            case(rx_flag)
            1 : r_rx_data[0] <= dff_rx_1;
            2 : r_rx_data[1] <= dff_rx_1;
            3 : r_rx_data[2] <= dff_rx_1;
            4 : r_rx_data[3] <= dff_rx_1;
            5 : r_rx_data[4] <= dff_rx_1;
            6 : r_rx_data[5] <= dff_rx_1;
            7 : r_rx_data[6] <= dff_rx_1;
            8 : r_rx_data[7] <= dff_rx_1;
            default : r_rx_data <= r_rx_data;
            endcase
            
        end      
    // rx_done
     always@(posedge clk)
            rx_done <= (rx_flag==9)&&(counter_bps == bps_c /2);
    // rx_data ;
       always@(posedge clk)
           if((rx_flag==9)&&(counter_bps == bps_c /2 -1))

                 rx_data <= r_rx_data;  
endmodule

rx_ram_00.v

module rx_ram_00(
                input clk ,
                input reset_n ,
                input uart_rx ,
                input clkb ,
                input[7 : 0]addrb ,
                output  [7 : 0] doutb
                );
    
    wire rx_done;
    wire [7:0]rx_data;
    reg [7:0]addra;

    ram ram_ (
                 .clka(clk), // input wire clka
                 .wea(rx_done), // input wire [0 : 0] wea
                 .addra(addra), // input wire [7 : 0] addra
                 .dina(rx_data), // input wire [7 : 0] dina
                 .clkb(clkb), // input wire clkb
                 .addrb(addrb), // input wire [7 : 0] addrb
                 .doutb(doutb) // output wire [7 : 0] doutb
                                    );
    
    uartrx uart_rx_(
                 . clk(clk) ,
                 . reset_n(reset_n) ,
                 . uart_rx(uart_rx) ,
                 . rx_data(rx_data),
                 . rx_done(rx_done)    );
    
    
    always@(posedge clk or negedge reset_n)
    if(!reset_n)
        addra <= 8'B0000_0000;
    else  if(rx_done)
         addra <= addra + 1'b1;

endmodule

rx_tb.v

`timescale 1ns / 1ns
module rx_tb();
    reg clk , reset_n ;
    reg uart_rx;
    reg clkb;
    reg [7:0]addrb;
    wire [7:0]doutb;
      integer i;
    rx_ram_00 rx_ram_00_(
                        . clk(clk) ,
                        . reset_n(reset_n) ,
                        . uart_rx(uart_rx) ,
                        . clkb(clkb) ,
                        . addrb(addrb) ,
                        . doutb(doutb)
                        );
    initial clk = 1 ;
    always #10 clk = ~clk ;
    initial clkb = 1 ;
    always #20 clkb = ~clkb ;
    initial
    begin
        
        reset_n = 0 ;
        uart_rx = 1 ;
        addrb = 255;
        i = 0 ;
        #201;
        reset_n = 1 ;  #2000;     
        //   F0   1111_0000
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000;
     //   55   0101_0101
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000;
       //   55   0101_0101
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000; 
        //   F0   1111_0000
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000;
         //   F0   1111_0000
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000;
     //   55   0101_0101
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000;
       //   55   0101_0101
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000; 
        //   F0   1111_0000
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);        uart_rx = 0 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);        #200000; 
        
                    for (i = 0 ; i < 8 ; i = i+1)
                    begin
                        addrb = i;
                        #40;
                    end
                   addrb = 255; 
            #2000;
        $stop;
    end
    
    
endmodule

测试了向RAM中写入8个数据，并读出
由图可以看出串口写入模块正常

摸鱼怪碎碎念：之前

  always@(posedge clk or negedge reset_n)
    if(!reset_n)
        addra <= 8'B0000_0000;
    else  if(rx_done)
         addra <= addra + 1'b1;

 always@(posedge clk)
           if((rx_flag==9)&&(counter_bps == bps_c /2 -1))

                 rx_data <= r_rx_data;  

这两部分调试出来滴，之前没有连续传输过，so没注意到这个问题，嘿嘿嘿~

5.  RX + RAM +Key + TX

key_one.v

module key_one(
                 input clk , 
                 input reset_n,
                 input key,
                 output reg key_flag,
                 output reg key_state);
                 
        // nedge_key pedge_key
        reg dff_k_0 , dff_k_1 ;
        reg r_key; 
        wire  nedge_key, pedge_key;
        always@(posedge clk )    
            dff_k_0 <= key ;
        always@(posedge clk )    
            dff_k_1 <= dff_k_0 ;
        always@(posedge clk )    
            r_key <= dff_k_1 ;
            
        assign nedge_key = (r_key == 1)&&(dff_k_1 == 0);
        assign pedge_key = (r_key == 0)&&(dff_k_1 == 1);
   
        // key_now   0:IDLE   1:FILTER0   2:DOWN   3:FILTER1
        // cnt 20ms/20ns = 1000000 ;
        reg [1:0]key_now;
        reg [19:0] cnt;
        parameter cnt_N = 1000;   

        //测试的时候为了速度快一点调成这个，当然之前参数化有学习过应该咋做

        //摸鱼怪是这样的(确信

        //上板记得改回6个0
        always@(posedge clk or negedge reset_n ) 
            if(!reset_n) 
                begin
                    key_now <= 0 ;
                    cnt <= 0;
                    key_flag <= 0;
                    key_state <= 1;
                end
            else 
                begin
                    key_flag <= 0;
                    case(key_now)
                        0:
                           if(!nedge_key) key_now <= 0;
                           else 
                               begin 
                                 cnt <= 0 ;
                                 key_now <= 1; 
                               end
                               
                        1:
                            if(pedge_key) key_now <= 0;
                            else if(cnt >= cnt_N - 1) 
                                begin
                                    cnt <= 0 ;
                                    key_now <= 2;
                                    key_flag <= 1;
                                    key_state <= 0;
                                end
                            else cnt <= cnt + 1'b1;
                            
                        2:
                            if(!pedge_key) key_now <= 2;
                            else
                                begin
                                    cnt <= 0 ;
                                    key_now <= 3;
                                end
                        
                        3:
                            if(nedge_key) key_now <= 2;
                            else if(cnt >= cnt_N - 1)
                                 begin
                                    cnt <= 0 ;
                                    key_now <= 0;
                                    key_flag <= 1;
                                    key_state <= 1;
                                end
                            else cnt <= cnt + 1'b1;    
                        
                    endcase
                end

endmodule

uarttx.v

module uarttx(input clk , 
                input reset_n , 
                input [7:0]data , 
                input Send_Go ,
                output reg uart_tx , 
                output reg tx_done  );
        //默认使用波特率BAUD 9600  时钟频率 CLK_FREQ  50MHz
    parameter start_bit = 0 ;
    parameter stop_bit  = 1 ;
    parameter BAUD = 9600;
    parameter CLK_FREQ = 50_000_000;
    parameter bps_c = CLK_FREQ / BAUD ;    
    
        reg Send_en ; 
        always@(posedge clk or negedge reset_n )
        if(! reset_n) 
            Send_en <= 0 ;
        else if(Send_Go)
            Send_en <= 1 ; 
        else if((tx_flag==9)&&(counter_bps == bps_c - 1)) 
            Send_en <= 0 ;
        
      // bps
      reg [30:0] counter_bps ;        
      always@(posedge clk or negedge reset_n)
        if(! reset_n) 
            counter_bps <= 0 ;
        else if (Send_en)
            if(counter_bps == bps_c - 1)
                counter_bps <= 0 ;
            else
                counter_bps <= counter_bps + 1'b1 ;
        else
            counter_bps <= 0 ;
            
      // 发送状态
      reg [3:0] tx_flag;
      always@(posedge clk or negedge reset_n)
        if(! reset_n) 
            tx_flag <= 0 ;
        else if (!Send_en) tx_flag <= 0 ;
        else if ((tx_flag==9)&&(counter_bps == bps_c - 1))
             tx_flag <= 0 ;
        else
             if(counter_bps == bps_c - 1)
                tx_flag <= tx_flag + 1'b1 ;
                
//       Send_Go改变发送信号         
        reg [7:0]r_data;
        always@(posedge clk)
        if(Send_Go)
         r_data <= data;
        else
         r_data <= r_data;                    
         
    //  tx_flag          
       always@(*)
       if(!Send_en) uart_tx <= 1'b1;
       else
        begin 
            case(tx_flag)
            4'b0000 : uart_tx <= start_bit;
            4'b0001 : uart_tx <= r_data[0];
            4'b0010 : uart_tx <= r_data[1];
            4'b0011 : uart_tx <= r_data[2];
            4'b0100 : uart_tx <= r_data[3];
            4'b0101 : uart_tx <= r_data[4];
            4'b0110 : uart_tx <= r_data[5];
            4'b0111 : uart_tx <= r_data[6];
            4'b1000 : uart_tx <= r_data[7];
            4'b1001 : uart_tx <= stop_bit;
            default : uart_tx <= uart_tx;
            endcase
            
        end      
        
        
        always@(posedge clk )        
        tx_done <= (tx_flag==9)&&(counter_bps == bps_c - 1);
     
endmodule

rx_ram_tx.v

module rx_ram_tx(
                     input clk ,
                     input reset_n ,
                     input uart_rx ,
                     input key ,
                     output uart_tx
                    );
        
    wire rx_done;
    wire [7:0]rx_data;
    reg [7:0]addra;
    reg [7:0]addrb;
    wire [7:0]doutb;
    wire key_flag;
    wire key_state;
    
    wire tx_done;
    ram ram_ (
                 .clka(clk), // input wire clka
                 .wea(rx_done), // input wire [0 : 0] wea
                 .addra(addra), // input wire [7 : 0] addra
                 .dina(rx_data), // input wire [7 : 0] dina
                 .clkb(clk), // input wire clkb
                 .addrb(addrb), // input wire [7 : 0] addrb
                 .doutb(doutb) // output wire [7 : 0] doutb
                                    );
    
    uartrx uart_rx_(
                 . clk(clk) ,
                 . reset_n(reset_n) ,
                 . uart_rx(uart_rx) ,
                 . rx_data(rx_data),
                 . rx_done(rx_done)    );
    
    
    always@(posedge clk or negedge reset_n)
    if(!reset_n)
        addra <= 8'b0000_0000;
    else  if(rx_done)
         addra <= addra + 1'b1;
        
    key_one key_(
                 . clk(clk) , 
                 . reset_n(reset_n),
                 . key(key),
                 . key_flag(key_flag),
                 . key_state(key_state)
                 );   
                 
    always@(posedge clk or negedge reset_n)
    if(!reset_n)
        addrb <= 8'b0000_0000;
    else  if(tx_done)
         addrb <= addrb + 1'b1;  
         //这其实是是有问题滴！！！
     reg tx_en ;  
     always@(posedge clk or negedge reset_n)
     if(!reset_n)    
         tx_en <= 1'b0 ;
     else  if((key_flag)&&(key_state==0))
         tx_en <= 1'b1;   
     else  if(addrb == 11)  //这里也是因为测试才这样写滴
         tx_en <= 1'b0 ;
         
     reg Send_Go ;
     always@(posedge clk or negedge reset_n)
     if(!reset_n)    
         Send_Go <= 1'b0 ;
     else  if((key_flag)&&(key_state==0))
         Send_Go <= 1'b1;   
     else  if(tx_en && tx_done)
         Send_Go <= 1'b1 ;   
     else      
         Send_Go <= 1'b0 ;

            //为什么跟addrb 同样的颜色捏~
    uarttx uart_tx_(
                . clk(clk) , 
                . reset_n(reset_n) , 
                . data(doutb) , 
                . Send_Go(Send_Go) ,
                . uart_tx(uart_tx) , 
                . tx_done(tx_done)  
                );    
endmodule

rx_ram_key_tx_tb.v（第一版）

`timescale 1ns / 1ns

module rx_ram_key_tx_tb(  );
   
   reg clk ;
   reg reset_n ;
   reg uart_rx ;
   reg key ;
   wire uart_tx ;
  
        
   rx_ram_tx rx_ram_tx_(
                         . clk(clk) ,
                         . reset_n(reset_n) ,
                         . uart_rx(uart_rx) ,
                         . key(key) ,
                         . uart_tx(uart_tx)
                        );
        
       initial clk = 1 ;
       always#10 clk = ~clk ;     
        
       initial 
        begin
            reset_n = 0 ;
            uart_rx = 1 ;
            key = 1'b1 ;
            #201;
            reset_n = 1 ;  #2000;     
        //   0F   0000_1111
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000;
     //   55   0101_0101
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000;
       //   55   0101_0101
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000; 
        //   0F   0000_1111
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000;
         //   0F   0000_1111
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000;
     //   55   0101_0101
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000;
       //   55   0101_0101
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000; 
        //   0F   0000_1111
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 0 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        uart_rx = 1 ; #(5208*20);
        #200000; 
        
        key_press(2);
        #(5208*20*8*20); 
        
        
        
        
        $stop;
        end
       
 reg [13:0] rand;
 task key_press;
    input[3:0]seed;
    begin
        key =  1'b1 ;
        #1000;
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key=~key;
            end
        key = 1'b0 ;
        #100000; 
        key =  1'b1 ;   
   end
endtask 
        
        
endmodule

嘎嘎嘎~是不是觉得貌似没有问题~

那为什么要说存在问题捏！

自行调试一下：

always@(posedge clk or negedge reset_n)
    if(!reset_n)
        addrb <= 8'b1111_1111;
    else  if((key_flag)&&(key_state==0))
         addrb <= 8'b0000_0000;     
    else  if(tx_done)
         addrb <= addrb + 1'b1;  

（俺这里没有保存，就是之前学习RAM读取，配置中存在一个Latentcy

rx_ram_key_tx_tb.v（修改后）

module rx_ram_tx(
                     input clk ,
                     input reset_n ,
                     input uart_rx ,
                     input key ,
                     output uart_tx
                    );
        
    wire rx_done;
    wire [7:0]rx_data;
    reg [7:0]addra;
    reg [7:0]addrb;
    wire [7:0]doutb;
    wire key_flag;
    wire key_state;
    
    wire tx_done;
    ram ram_ (
                 .clka(clk), // input wire clka
                 .wea(rx_done), // input wire [0 : 0] wea
                 .addra(addra), // input wire [7 : 0] addra
                 .dina(rx_data), // input wire [7 : 0] dina
                 .clkb(clk), // input wire clkb
                 .addrb(addrb), // input wire [7 : 0] addrb
                 .doutb(doutb) // output wire [7 : 0] doutb
                                    );
    
    uartrx uart_rx_(
                 . clk(clk) ,
                 . reset_n(reset_n) ,
                 . uart_rx(uart_rx) ,
                 . rx_data(rx_data),
                 . rx_done(rx_done)    );
    
    
    always@(posedge clk or negedge reset_n)
    if(!reset_n)
        addra <= 8'b0000_0000;
    else  if(rx_done)
         addra <= addra + 1'b1;
        
    key_one key_(
                 . clk(clk) , 
                 . reset_n(reset_n),
                 . key(key),
                 . key_flag(key_flag),
                 . key_state(key_state)
                 );   
                 
    always@(posedge clk or negedge reset_n)
    if(!reset_n)
        addrb <= 8'b1111_1111;
    else  if((key_flag)&&(key_state==0))   //发送从首地址开始
         addrb <= 8'b0000_0000;     
    else  if(tx_done)
         addrb <= addrb + 1'b1;  
         
     reg tx_en ; 
     always@(posedge clk or negedge reset_n)
     if(!reset_n)    
         tx_en <= 1'b0 ;
     else  if((key_flag)&&(key_state==0))
         tx_en <= 1'b1;   
     else  if(addrb == 11)
         tx_en <= 1'b0 ;
         
     reg Send_Go_0 , Send_Go_1 ,Send_Go_2 ,Send_Go ;

       //这部分是之前的Send_Go
     always@(posedge clk or negedge reset_n)
     if(!reset_n)    
         Send_Go_0 <= 1'b0 ;
     else  if((key_flag)&&(key_state==0))    
         Send_Go_0 <= 1'b1;   
     else  if(tx_en && tx_done)
         Send_Go_0 <= 1'b1 ;   
     else      
         Send_Go_0 <= 1'b0 ;
         //这部分是Latentcy
    always@(posedge clk or negedge reset_n)
     if(!reset_n)  
        begin  
         Send_Go_1 <= 1'b0 ;
         Send_Go_2 <= 1'b0 ;
         Send_Go <= 1'b0 ;
       end 
     else
        begin  
         Send_Go_1 <= Send_Go_0 ;
         Send_Go_2 <= Send_Go_1 ;
         Send_Go <= Send_Go_2 ;
       end   
       
    uarttx uart_tx_(
                . clk(clk) , 
                . reset_n(reset_n) , 
                . data(doutb) , 
                . Send_Go(Send_Go) ,
                . uart_tx(uart_tx) , 
                . tx_done(tx_done)  
                );    
endmodule

6.  板级验证

.xdc

set_property IOSTANDARD LVCMOS33 [get_ports clk]
set_property IOSTANDARD LVCMOS33 [get_ports key]
set_property IOSTANDARD LVCMOS33 [get_ports reset_n]
set_property IOSTANDARD LVCMOS33 [get_ports uart_rx]
set_property IOSTANDARD LVCMOS33 [get_ports uart_tx]
set_property PACKAGE_PIN U18 [get_ports clk]
set_property PACKAGE_PIN H18 [get_ports key]
set_property PACKAGE_PIN H20 [get_ports reset_n]
set_property PACKAGE_PIN K16 [get_ports uart_rx]
set_property PACKAGE_PIN J16 [get_ports uart_tx]

依次向RAM中写入：0x10~0x1F(一开始把0忘记哩~)读取到的数值是正确的

但是写入：0x01~0xF1 可以看出，最高两位的数据一直为0

存在的小错误下次继续调试叭~

摸鱼怪跑路~

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1840907.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MTU 和 MSS 关系、 IP分片、TCP分段

MTU 和 MSS 关系、 IP分片、TCP分段

从四层模型&#xff1a;链路层&#xff0c;网络层&#xff0c;传输层&#xff0c;应用层说 一 、以太网V2格式数据帧 : 链路层 Destination Source Type DataAndPad FCS 6 6 2 46~1500 4 二、IP: 网络层 0 1 …
阅读更多...
MySQL8，Navicat能登陆成功，密码却忘记了

MySQL8，Navicat能登陆成功，密码却忘记了

执行成功的图&#xff1a; 以下为步骤&#xff1a;本文一共8个简单步骤。 环境&#xff1a;mysql8、window10、navicat11 1、打开本地电脑window10的命令窗&#xff08;俗称黑窗口&#xff09;&#xff0c;windowR 2、输入regegit&#xff0c;回车&#xff0c;打开注册表 3、…
阅读更多...
哪里可以姓名设计免费签名？6个软件帮助你轻松设计签名

哪里可以姓名设计免费签名？6个软件帮助你轻松设计签名

哪里可以姓名设计免费签名&#xff1f;6个软件帮助你轻松设计签名 这里有六个免费的软件和在线工具可以帮助您设计个性化的签名&#xff1a; 1.一键logo设计&#xff1a;这是一个功能强大且易于使用的设计工具&#xff0c;提供了丰富的签名设计模板和各种字体效果供选择。您可…
阅读更多...
Kubernetes入门-Kubernetes集群构成

Kubernetes入门-Kubernetes集群构成

目录 前言 控制面板节点与工作节点 控制面板节点 工作节点 被托管的Kubernetes 用kubectl命令行工具管理Kubernetes 前言 前面说过&#xff0c;Kubernetes是云的操作系统顾名思义&#xff0c;它位于应用和基础设施之间Kubernetes运行在基础设施上&#xff0c;而应用运行…
阅读更多...
手机录屏声音怎么录？2个小妙招教会你

手机录屏声音怎么录？2个小妙招教会你

手机录制好的视频怎么没有声音&#xff1f;你是否也遇到了这个难题&#xff1f;在日常生活中&#xff0c;手机录屏功能已经成为我们生活和工作中的得力助手。而录屏的声音&#xff0c;作为录屏功能的重要组成部分&#xff0c;更是为我们的录制体验增添了不少色彩。那么&#xf…
阅读更多...
一文带你搞定Linux开发环境配置

一文带你搞定Linux开发环境配置

Linux开发必备 万事先更新 sudo apt update && sudo apt upgrade安装gcc工具链 sudo apt install build-essential像mysql、nacos等等建议装docker里&#xff0c;数据挂载到宿主机&#xff0c;日志别挂&#xff0c;直接装本机哪天日志塞满了就要开始重装系统了 以下…
阅读更多...
B端系统的UI框架选择，不要输在了起跑线，如何破？

B端系统的UI框架选择，不要输在了起跑线，如何破？

所谓成也框架、败也框架&#xff0c;框架就是这么的优点和缺点鲜明&#xff0c;市面上的框架多如牛毛&#xff0c;谁家的最优秀呢&#xff1f;为何框架搞出来的UI界面同质化呢&#xff0c;如何避免这种情况&#xff0c;如何在框架的基础上进一步提升颜值和体验呢&#xff0c;本…
阅读更多...
Go语言day1

Go语言day1

下载go语言的安装程序&#xff1a; All releases - The Go Programming Language 配置go语言的环境变量&#xff1a; 写第一个go语言 在E:\go_workspace当前窗口使用cmd命令: 输入 go run test.go
阅读更多...
茂名石油行业：可燃气体报警器校准检测守护安全新防线

茂名石油行业：可燃气体报警器校准检测守护安全新防线

茂名&#xff0c;作为广东省的重要石化基地&#xff0c;其石油行业的发展一直备受关注。 随着石油产业的蓬勃发展&#xff0c;气体泄露的风险也日渐突出&#xff0c;给企业的生产安全和员工的生命安全带来了不小的挑战。 在这一背景下&#xff0c;可燃气体报警器的重要性日益…
阅读更多...
6月19日作业

6月19日作业

思维导图 实现服务器连接多个客户端局域网 #include "widget.h" #include "ui_widget.h"Widget::Widget(QWidget *parent): QWidget(parent), ui(new Ui::Widget),sever(new QTcpServer(this)) {ui->setupUi(this); }Widget::~Widget() {delete ui; }v…
阅读更多...
Java 开发面试题精选：RocketMQ 一篇全搞定

Java 开发面试题精选：RocketMQ 一篇全搞定

前言 RocketMQ作为一个高性能、高可用的分布式消息和流处理平台&#xff0c;广泛应用于分布式系统中的解耦、异步通信和数据流处理场景。这篇文章我精选了一些关于RockerMQ面试题目&#xff0c;这些问题涵盖了RocketMQ的所有关键知识点&#xff0c;从基本概念到高级应用&#…
阅读更多...
使用Flink接受kafka中的数据并对数据进行ETL

使用Flink接受kafka中的数据并对数据进行ETL

做这个开发是因为&#xff1a;在实际开发操作中&#xff0c;你的kafka主题中会有大量的数据但是需求并不需要所有数据&#xff0c;所有我们要对数据进行清洗&#xff0c;把需要的数据保存在flink流中&#xff0c;为下流的开发做好数据保障&#xff01; 首先创建工具类 再写一…
阅读更多...
类注释规范

类注释规范

类注释规范 1.1.1 模板配置 模板路径&#xff1a;File–>settings–>Editor–>File and Code Templates–>Includes–>File Header  N A M E &#xff1a;设置类名&#xff0c;与下面的 {NAME}&#xff1a;设置类名&#xff0c;与下面的 NAME&#xff1a;设…
阅读更多...
Java语法糖写法

Java语法糖写法

一、函数式接口 1、Function函数式接口&#xff1a;有一个输入参数&#xff0c;有一个输出 2、断定型接口&#xff1a;有一个输入参数&#xff0c;返回值只能是布尔值&#xff01; 3、Consumer 消费型接口&#xff1a;只有输入&#xff0c;没有返回值 4、Supplier供给型接口&a…
阅读更多...
电影美学复古胶片特效视频转场模板 | Premiere Pro 项目工程文件

电影美学复古胶片特效视频转场模板 | Premiere Pro 项目工程文件

这个Premiere Pro项目工程文件是一个电影美学胶片特效视频转场模板&#xff0c;每个过渡效果都散发出一种有机的怀旧魅力&#xff0c;让人回忆起经典电影卷轴和模拟摄影的独特美感。 项目特点&#xff1a; 胶片烧伤过渡效果&#xff1a;包括从微妙的闪烁到大胆的爆发&#xff…
阅读更多...
Redis 主从同步

Redis 主从同步

主从同步 很多企业没有使用Redis的集群&#xff0c;但是至少都做了主从。有了主从&#xff0c;当master挂掉的时候&#xff0c;运维让从库过来接管&#xff0c;服务就可以继续&#xff0c;否则master需要经过数据恢复和重启的过程&#xff0c;可能会拖很长时间&#xff0c;影响…
阅读更多...
Ubuntu 24.04安装zabbix7.0.0图形中文乱码

Ubuntu 24.04安装zabbix7.0.0图形中文乱码

当zabbix安装完成后&#xff0c;设置中文界面时&#xff0c;打开图形&#xff0c;中文内容会显示方框乱码&#xff0c;是因为服务器字体中没有相关的中文字体&#xff0c;需要更换。 1、找到中文字体&#xff0c;可以在网络上下载《得意黑》开源字体&#xff0c;也可以在windo…
阅读更多...
AI人工智能产品经理，就该这么学！

AI人工智能产品经理，就该这么学！

前言 想入行AI人工智能产品经理&#xff0c;该如何学习呢&#xff1f; 随时AI的兴起&#xff0c;AI产品经理开始爆火&#xff0c;很多功能性产品经理想转行做AI产品经理。转行的原因&#xff0c;这个仁者见仁智者见智。唯一的共同点就是&#xff0c;大家都看好AI行业的发展前景…
阅读更多...
【Spine学习14】之 人物死亡动作 思路总结

【Spine学习14】之 人物死亡动作 思路总结

其实大致过程跟攻击那个流程一样了 没什么特别的 就只是K帧不一样&#xff1a; 记录一下&#xff0c;姿势参考就好 0s还是跟攻击一样的站立姿势 10s帧 22s帧 40s帧 不同的是把角色倒地时间延长了许多 这样看起来更合适一点 剑和盾在人物死亡的时候或脱离手心 移动开一些距离…
阅读更多...
【Linux安装Conda环境的详细教程】

【Linux安装Conda环境的详细教程】

&#x1f308;个人主页: 程序员不想敲代码啊 &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023