RAM + 串口的简单应用

已于 2024-06-20 09:28:27 修改
阅读量1k 收藏 9
点赞数 9
分类专栏： zynq vivado摸鱼记录 # FPGA Verilog 文章标签： 单片机 嵌入式硬件 fpga开发
于 2024-06-19 16:40:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhh123987_/article/details/139632730
版权

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_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'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

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

摸鱼怪跑路~

hhh123987_
关注
  • 9
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
搭建串口收发与存储双口RAM简易应用系统
小柚子的博客
09-17 342
搭建串口收发与存储双口RAM简易应用系统 为了实现通过串口发送数据到 FPGA 中， FPGA 接收到数据后将数据存储在双口 ram 的 一段连续空间中，当需要时，按下按键 S0，则 FPGA 将 RAM 中存储的数据通过串口发送出 去。先进行功能划分：串口接收模块、按键消抖模块、 RAM 模块、串口发送模块以及控制模 块。 串口接收模块参考：串口接收模块 按键消抖模块参考：按键消抖模块 RAM模块参考：RAM模块描述 现在编写本系统的控制模块 CTRL.v，模块的接口可参照系统结构图写出。为
小梅哥13.2——串口收发与存取双口RAM系统
wyhllhsbs的博客
10-30 223
串口接收PC机发送的数据（每次一个字节，1Byte，8bit）到FPGA，FPGA接收数据后将数据存储在双口RAM的一段连续空间中（地址0地址1...），通过In-System Memory Cotent Editor内存查看工具，查看对应地址RAM中存储的数据。按下按键0，FPGA将RAM中存储的数据读出来，通过串口发送回PC机，与RAM中数据进行比对。当 按键按下后启动一次发送，然后判断上一字节是否发送结束，是则进行下一字节发送否则不 进行下一次发送。
串口rx + RAM + LCD
hhh123987_的博客
06-20 384
UART_RX + RAM + LCD 结论：串口接收，高两位有bug
FPGA学习笔记_串口收发与存取双口ram简易应用
GloriaHuo's Blogs
11-22 2194
FPGA学习笔记 串口收发与存取双口ram简易应用 1 原理图 2 Verilog 代码 3 Modelsim仿真 4. FPGA板级验证 串口收发与存取双口ram简易应用 实验现象：在pc机上通过串口发送数据到FPGA中，FPGA收到的数据后，将数据存储在双口ram的一段连续空间中，当需要时，按下按键0，FPGA将ram中存储的数据通过串口发送出去。 知识点： cyclone iv系列器件的内部结构 存储器IP核的使用 串口收发+按键+双口ram组成建议系统设计 1. 原理图 模块组成：
FPGA学习项目——串口收发与伪双口RAM简易应用系统
qq_51535126的博客
12-07 1144
将数据通过串口发送到FPGA中，当需要时，按下按键key0，则FPGA 将RAM中存储的数据通过串口发送出去。根据功能实现要求进行功能划分：串口接收发送模块、按键消抖模块、RAM 模块以及控制模块。以下详细介绍一下各个模块工作原理和代码编写。
FPGA 20 串口收发与存储双口RAM 简易应用系统设计
lj1986817902的博客
08-04 908
FPGA 20 串口收发与存储双口RAM 简易应用系统设计 主要功能： FPGA 接收到数据后将数据存储在双口 ram 的一段连续空间中，当需要时，按下按键 Key_in，则 FPGA 将 RAM 中存储的数据通过串口发送出去. 另外，使用ROM 以后，即使系统复位，dprom中的数据仍然存在，而不会被清除. 实现（设计）流程：本实验属于系统设计，在基于之前的模块进行模块化设计上，调用了 key_filter、uart_tx、uart_rx、dpram的模块，新加入设计了ctrl 信号控制模块，最.
uart_dpram:搭建串口收发与存储双口RAM简易应用系统
杰之行的博客
11-26 1223
搭建串口收发与存储双口RAM简易应用系统 实验目的： 以模块化设计为基础利用已编写的串口收发模块、按键模块以及RAM的IP模块来设计一个简易应用系统。通过串口发送数据到FPGA中，FPGA接收到数据后将数据存储在双口RAM的一段连续空间中，当需要时，按下按键0，则FPGA将RAM中存储的数据通过串口发送出去。 00.功能模块： 1.串口接收模块:uart_tybe_rx.v 2.按键消抖模块:key_fliter.v 3.RAM模块:dpram.v 4.串口发送模块:uart_tybe_tx.v 5.控制模
FPGA实现串口通信（接收+发送）
流浪的猫c的博客
03-20 1500
fpga实现串口通信（接收+发送）
stm32应用-简单的串口接收与发送程序
热门推荐
积土成山
11-09 2万+
与上位机的串口通信是一个很常用的程序。碧海蓝天在刚刚接触stm32芯片时写的第一个简单程序就是串口通信，现在把程序代码甩出来与大家分享。完整的程序哦~一般人我不告诉他  库版本  ：ST3.0.0 文件：mian.c //功能：串口初始化、打开定时器中断，然后一直接收数据状态就好了。发送在中断中实现 #include "stm32f10x.h" #include "usa
ROM 、RAM和FLASH 的区别
DataH
03-27 1万+
ROM和RAM指的都是半导体存储器，ROM是Read Only Memory的缩写，RAM是Random Access Memory的缩写。ROM在系统停止供电的时候仍然可以保持数据，而RAM通常都是在掉电之后就丢失数据，典型的RAM就是计算机的内存。 RAM 有两大类，一种称为静态RAM（Static RAM/SRAM），SRAM速度非常快，是目前读写最快的存储设备了，但是它也非常昂贵，所以只在...
基于ram的简易串口数据收发系统
09-21
本项目"基于RAM的简易串口数据收发系统"就是这样一个利用Verilog语言实现的例子，它专注于通过串行接口进行数据的接收与发送，并将数据存储在内部的RAM中。 串口通信是数字系统中常见的一种通信方式，通常使用UART...
FPGA学习之-串口+ram ip核存储数据
04-25
在本文中，我们将深入探讨"FPGA学习之-串口+ram IP核存储数据"这一主题，结合小梅哥7a35t开发板的实践应用。FPGA（Field-Programmable Gate Array）是一种可编程逻辑器件，允许设计者根据需要自定义硬件电路。在FPGA...
dpram_ram_ramIP_串口ram收发_fpga_dpram_
09-30
"串口RAM收发"指的是通过串行接口进行数据的读写操作。相比于并行接口，串行接口占用更少的I/O资源，适合于传输速率要求不那么高但需要节省硬件资源的情况。在FPGA中实现串口RAM收发，可以构建一个简单的通信系统，...
51单片机LCD显示温度+串口接收温度.rar
07-17
这个“51单片机LCD显示温度+串口接收温度.rar”项目显然是一个利用51单片机实现温度监测并显示在LCD（液晶显示器）上的实例，同时还具备通过串行接口接收温度数据的功能。下面我们将详细讨论相关的知识点。 1. **51...
51单片机RAM程序串口下载
06-27
"串口下载"是将程序通过串行通信接口传输到单片机的过程。串口，也称为UART（通用异步收发传输器），是一种简单但实用的通信协议，它使用较少的引脚实现数据传输。在51单片机中，串口可以用于通信、调试以及程序下载...
一、GD32F407VET6点亮一个LED灯
qq_42704573的博客
07-16 720
自己外部焊的啥就把哪一个打开。5.1 如果最开始的时候修改过工程名 则需要重新配置一下下载器 这也是我不爱修改工程名的原因。2.1 编写BSP_LED.h 所有自己写的.c和.h 记得多敲两行空行 不然会报警告。2.2 编写BSP_LED.c 所有自己写的.c和.h 记得多敲两行空行 不然会报警告。2.3 将BSP_LED.c文件添加至工程 点那个三个颜色的品字形图标。5.2 选择下载器没j-link 自己是啥选择自己的下载器。1.1 将新建好的工程模版复制一份并改一个自己喜欢的名字。
基于STC8H4K64TL单片机的触摸功能调试
CWQLTYH的博客
07-15 756
main.c#define uchar unsigned char//自定义无符号字符型为uchar#define uint unsigned int//自定义无符号整数型为uint#define ul unsigned long int//自定义无符号长整数型为ul//位定义LED灯的单片机引脚void PortModeSet()//单片机端口模式设置函数//设置P0.0~P0.3为高阻输入//设置P0.4为准双向口 P0.5~P0.7为推挽输出//设置P1.0~P1.3为高阻输入。
Android车载MCU控制音量和ARM控制音量的区别和优缺点—TEF6686 FM/AM芯片
最新发布
阿德的博客
07-19 744
Android车载系统开发定制晚于Android手机，但是也有10多年的时间，到8.0版本Android专门为车载添加AAOS（CarOS）分支。多年的从业经验也见证了行业的各种技术更新变化，这篇博客讲讲我个人理解的MCU控制音量和ARM控制音量的区别和优缺点。Android车载音频设计是最复杂、最难做、最重要的一部分，把音频部分做好这个系统基本上大差不差可以说做好了。
【STM32】按键控制LED&光敏传感器控制蜂鸣器（江科大）
2302_80796399的博客
07-16 334
【代码】【STM32】按键控制LED&光敏传感器控制蜂鸣器（江科大）
fpga 双口ram
07-28
双口RAM是一种用于数据存储和读取的内存核。它有两个独立的读写端口，可以在没有干扰的情况下同时进行读写操作，彼此互不干扰。\[1\]双口RAM与伪双口RAM的区别在于，伪双口RAM一个端口只读，另一个端口只写，而双口RAM两个端口都可以进行读写操作。\[1\]在FPGA中，生成双口RAM时可以选择简单双口RAM和真正双口RAM。简单双口RAM有一个读端口和一个写端口，写端口只能写不能读，读端口只能读不能写。而真正双口RAM有两个读/写端口，可以同时进行读写操作。\[3\]双口RAM在FPGA中的应用可以用于数据传输和存储等方面。 #### 引用[.reference_title] - *1* *2* [FPGA 基于双端口RAM的串口通信系统](https://blog.csdn.net/qq_46303613/article/details/117289707)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [【小月电子】ALTERA FPGA开发板系统学习教程-LESSON14 IPCORE之双口RAM详细教程](https://blog.csdn.net/Moon_3181961725/article/details/126693294)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值