• FPGA project : fifo_sum

    实验目标：

    col(列) = 4 ；line(行) = 5。相邻三行，按列求和。输出新的数据流。

    实现方法：

    通过rs232通信协议，输入数据流。第一行存进fifo1，第二行存进fifo2.当输入第三行第一个数据的时候，从fifo1和ffo2中读数据，并于当前输入数据相加，并输出结果与标志信号。

    设计中注意的事情：

    1，这个fifo，读写信号同时拉高，我进行功能仿真时，它是写满后，同时拉高，写不进数据。我放一张仿真图：

     所以我设计的时序图，fifo1和fifo2都是先读出数据，然后再写数据。

    2，数据与标志信号在设计的时候，要注意时序上的对齐。这种小工程，仿真时，时序没问题没问题，上板子后出错，我觉得应该不是时序上的问题（亚稳态）。应该是代码的问题。

    因为我在调用之前的uart_rs232模块，修改了参数，结果上板子出错了。就是这个uart模块的问题。苦恼了很久，一开始以为是fifo_sum的问题。我的写法和野火教程里是不完全一样的。

    3，大于2的数字，尽量用参数parameter定义。在这方面，吃了大亏（uart模块又花了一个晚上重新写的）。

    模块框图：

    时序图：

     

    代码： 

    1. module uart_rx(
    2.     input       wire            sys_clk   ,
    3.     input       wire            sys_rst_n ,
    4.     input       wire            rx        ,
    5.  
    6.     output      reg             po_flag   ,
    7.     output      reg     [7:0]   po_data    
    8. );
    9.  
    10.     // parameter
    11.     parameter   CLK_UART = 50_000_000     ,
    12.                 BPS      = 9600           ;
    13.     localparam  MAX_BPS  = CLK_UART / BPS ;
    14.  
    15.     // reg signal define
    16.     reg             rx_reg1 ;
    17.     reg             rx_reg2 ;
    18.     reg             rx_reg3 ;
    19.     wire            start   ;
    20.     reg             work_en ;
    21.     reg     [12:0]  cnt_bps ;
    22.     reg     [ 3:0]  cnt_bit ;
    23.     reg             bit_flag;
    24.     reg     [ 7:0]  rx_data ; // 对rx_reg3采样，把串行数据转化为8bit并行数据。
    25.     reg             rx_flag ; // 转化完拉高一个时钟周期。
    26.  
    27.  
    28. /********************************************************/
    29.     // reg             rx_reg1 ;
    30.     // reg             rx_reg2 ;
    31.     // reg             rx_reg3 ;
    32.     always @(posedge sys_clk or negedge sys_rst_n) begin
    33.         if(~sys_rst_n) begin
    34.             rx_reg1 <= 1'b1 ; // 由于空闲状态，rx是高电平。
    35.             rx_reg2 <= 1'b1 ;
    36.             rx_reg3 <= 1'b1 ;
    37.         end else begin
    38.             rx_reg1 <= rx      ;
    39.             rx_reg2 <= rx_reg1 ;
    40.             rx_reg3 <= rx_reg2 ;
    41.         end
    42.     end
    43.     // reg             start   ; // 检测到下降沿，拉高一个sys_clk.
    44.     assign start = ~rx_reg2 && rx_reg3 ;
    45.     // reg             work_en ;
    46.     always @(posedge sys_clk or negedge sys_rst_n) begin
    47.         if(~sys_rst_n) 
    48.             work_en <= 1'b0 ;
    49.         else if((cnt_bit == 4'd0 && start) || (cnt_bit == 4'd8 && bit_flag)) // 正常来讲,这个两个条件应该是交替出现的。
    50.             work_en <= ~work_en ;
    51.         else 
    52.             work_en <= work_en ;
    53.     end
    54.     // reg     [12:0]  cnt_bps ;
    55.     always @(posedge sys_clk or negedge sys_rst_n) begin
    56.         if(~sys_rst_n) 
    57.             cnt_bps <= 13'd0 ;
    58.         else if(work_en && cnt_bps == (MAX_BPS - 1))
    59.             cnt_bps <= 13'd0 ;
    60.         else if(work_en)
    61.             cnt_bps <= cnt_bps + 1'b1 ;
    62.         else 
    63.             cnt_bps <= 13'd0 ;
    64.     end
    65.     // reg             bit_flag;
    66.     always @(posedge sys_clk or negedge sys_rst_n) begin
    67.         if(~sys_rst_n)
    68.             bit_flag <= 1'b0 ;
    69.         else if(cnt_bps == MAX_BPS - 1) // 波特率计数器的最大值
    70.             bit_flag <= 1'b1 ;
    71.         else 
    72.             bit_flag <= 1'b0 ;
    73.     end
    74.     // reg     [ 3:0]  cnt_bit ;
    75.     always @(posedge sys_clk or negedge sys_rst_n) begin
    76.         if(~sys_rst_n)
    77.             cnt_bit <= 4'd0 ;
    78.         else if(bit_flag && cnt_bit == 4'd8)
    79.             cnt_bit <= 4'd0 ;
    80.         else if(bit_flag)
    81.             cnt_bit <= cnt_bit + 1'b1 ;
    82.         else 
    83.             cnt_bit <= cnt_bit ;
    84.     end
    85.     // reg     [ 7:0]  rx_data ; // 对rx_reg3采样，把串行数据转化为8bit并行数据。
    86.     // always @(posedge sys_clk or negedge sys_rst_n) begin
    87.     //     if(~sys_rst_n)
    88.     //         rx_data <= 8'd0 ;
    89.     //     else if(work_en == 1'b1 && (cnt_bit >= 1) && (cnt_bps == MAX_BPS/2))
    90.     //             rx_data <= {rx_reg3,rx_data[7:1]} ; // 由于rx是先发低位，所以rx_reg3放在前面.右移。
    91.     //     else if(work_en == 1'b1 && (cnt_bit >= 1))
    92.     //             rx_data <= rx_data ;
    93.     //     else 
    94.     //         rx_data <= rx_data ;
    95.     // end
    96.     always @(posedge sys_clk or negedge sys_rst_n) begin
    97.         if(~sys_rst_n)
    98.             rx_data <= 8'd0 ;
    99.         else if(work_en == 1'b1 && (cnt_bit >= 1)) begin
    100.             if(cnt_bps == MAX_BPS/2)
    101.                 rx_data <= {rx_reg3,rx_data[7:1]} ;
    102.             else 
    103.                 rx_data <= rx_data ;
    104.         end else begin
    105.             rx_data <= rx_data ;
    106.         end 
    107.     end
    108.     // reg             rx_flag ; // 转化完拉高一个时钟周期。
    109.     always @(posedge sys_clk or negedge sys_rst_n) begin
    110.         if(~sys_rst_n) 
    111.             rx_flag <= 1'b0 ;
    112.         else if(cnt_bit == 4'd8 && bit_flag)
    113.             rx_flag <= 1'b1 ;
    114.         else 
    115.             rx_flag <= 1'b0 ; 
    116.     end
    117.  
    118. /***********************************************************/
    119.     // output signal
    120.     // po_falg   ,
    121.     always @(posedge sys_clk or negedge sys_rst_n) begin
    122.         if(~sys_rst_n) 
    123.             po_flag <= 1'b0 ;
    124.         else if(rx_flag) // 可以理解为打一拍子或者使用时序逻辑采样
    125.             po_flag <= 1'b1 ;
    126.         else
    127.             po_flag <= 1'b0 ;
    128.     end
    129.     // po_data    
    130.     always @(posedge sys_clk or negedge sys_rst_n) begin
    131.         if(~sys_rst_n) 
    132.             po_data <= 8'd0 ;
    133.         else if(rx_flag) // 可以理解为打一拍子或者使用时序逻辑采样
    134.             po_data <= rx_data ;
    135.         else
    136.             po_data <= po_data ; // 可以归零，也可以保持。
    137.     end
    138. endmodule
    1. module uart_tx (
    2.     input       wire            sys_clk     ,
    3.     input       wire            sys_rst_n   ,
    4.     input       wire            pi_flag     ,
    5.     input       wire    [7:0]   pi_data     ,
    6.  
    7.     output      reg             tx          
    8. );
    9.     // parameter
    10.     parameter   SUB_1K   = 1000           , // 缩减第十位，空闲位的时间。
    11.                 CLK_UART = 50_000_000     ,
    12.                 BPS      = 9600           ;
    13.     localparam  MAX_BPS  = CLK_UART / BPS ;
    14.  
    15.     // reg signal define
    16.     reg             pi_flag_reg1 ;
    17.     reg     [ 7:0]  pi_data_reg1 ;
    18.     reg             work_en      ;
    19.     reg     [12:0]  cnt_bps      ;
    20.     reg     [ 3:0]  cnt_bit      ;
    21.     reg             bit_flag     ;
    22.  
    23. /**********************************************/
    24.     // reg             pi_flag_reg1 ;
    25.     always @(posedge sys_clk or negedge sys_rst_n) begin
    26.         if(~sys_rst_n)
    27.             pi_flag_reg1 <= 1'b0 ;
    28.         else 
    29.             pi_flag_reg1 <= pi_flag ;
    30.     end
    31.     // reg             pi_data_reg1 ;
    32.     always @(posedge sys_clk or negedge sys_rst_n) begin
    33.         if(~sys_rst_n)
    34.             pi_data_reg1 <= 8'd0 ;
    35.         else 
    36.             pi_data_reg1 <= pi_data ;
    37.     end
    38.     // reg             work_en      ;
    39.     always @(posedge sys_clk or negedge sys_rst_n) begin
    40.         if(~sys_rst_n) 
    41.             work_en <= 1'b0 ;
    42.         else if(((cnt_bit == 4'd0) && pi_flag_reg1) || (cnt_bit == 4'd9) && (bit_flag))
    43.             work_en <= ~work_en ;
    44.         else 
    45.             work_en <= work_en ;
    46.     end
    47.     // reg     [12:0]  cnt_bps      ;
    48.     always @(posedge sys_clk or negedge sys_rst_n) begin
    49.         if(~sys_rst_n)
    50.             cnt_bps <= 13'd0 ;
    51.         else if(work_en && cnt_bps == MAX_BPS - 1) // 波特率计数器计数到最大值。
    52.             cnt_bps <= 13'd0 ;
    53.         else if(work_en)
    54.             cnt_bps <= cnt_bps + 1'b1 ;
    55.         else 
    56.             cnt_bps <= 13'd0 ;
    57.     end
    58.     // reg             bit_flag     ;
    59.     always @(posedge sys_clk or negedge sys_rst_n) begin
    60.         if(~sys_rst_n)
    61.             bit_flag <= 1'b0 ;
    62.         else if((work_en && cnt_bps == MAX_BPS - 1) || (work_en && cnt_bps == MAX_BPS - SUB_1K && cnt_bit == 9))
    63.             bit_flag <= 1'b1 ;
    64.         else 
    65.             bit_flag <= 1'b0 ;
    66.     end
    67.     // reg     [ 3:0]  cnt_bit      ;
    68.     always @(posedge sys_clk or negedge sys_rst_n) begin
    69.         if(~sys_rst_n)
    70.             cnt_bit <= 4'd0 ;
    71.         else if(work_en && bit_flag && cnt_bit == 4'd9) // 传递完第十位，位计数器要归零。
    72.             cnt_bit <= 4'd0 ;
    73.         else if(work_en && bit_flag)
    74.             cnt_bit <= cnt_bit + 1'b1 ;
    75.         else if(work_en)
    76.             cnt_bit <= cnt_bit ;
    77.         else 
    78.             cnt_bit <= 4'd0 ;
    79.     end
    81. /****************************************/
    82.     // output signal
    83.     // tx
    84.     always @(posedge sys_clk or negedge sys_rst_n) begin
    85.         if(~sys_rst_n) 
    86.             tx <= 1'b1 ;
    87.         else if(work_en) begin
    88.             case (cnt_bit)
    89.                 0  : tx <= 1'b0 ;
    90.                 1  : tx <= pi_data_reg1[0] ; // 先发最低位。
    91.                 2  : tx <= pi_data_reg1[1] ;
    92.                 3  : tx <= pi_data_reg1[2] ;
    93.                 4  : tx <= pi_data_reg1[3] ;
    94.                 5  : tx <= pi_data_reg1[4] ;
    95.                 6  : tx <= pi_data_reg1[5] ;
    96.                 7  : tx <= pi_data_reg1[6] ;
    97.                 8  : tx <= pi_data_reg1[7] ;
    98.                 9  : tx <= 1'b1 ;
    99.             default: tx <= 1'b1 ;
    100.             endcase   
    101.         end else begin
    102.             tx <= 1'b1 ;
    103.         end
    104.     end
    105. endmodule
    1. module fifo_sum(
    2.     input       wire            sys_clk     ,
    3.     input       wire            sys_rst_n   ,
    4.     input       wire    [7:0]   data_in     ,
    5.     input       wire            data_flag   ,
    6.  
    7.     output      reg     [7:0]   po_data     ,
    8.     output      reg             po_data_falg
    9. );
    10.  
    11.     // parameter 
    12.     parameter 	XLINE_SUM = 3 ,
    13.                 MAX_LINE  = 5 ,
    14.                 MAX_COL   = 4 ;
    15.  
    16.     // reg signal define
    17.     reg		[7:0]	cnt_line 	;
    18.     reg  	[7:0]	cnt_col  	;
    19.     reg   			rdreq_r    	; // fifo1 fifo2 公用一个读使能。
    20.     reg    			wrreq1_r 	;
    21.     reg     [7:0]	dataF1_in_r ;
    22.     reg    			wrreq2_r    ;
    23.     reg     [7:0]	dataF2_in_r ;
    24.     reg     [7:0]	data_in_reg1;
    25.     reg     [7:0]	data_in_reg2;
    26.     reg   			flag_sum_r  ;
    27.  
    28.     // 例化连线
    29.     wire   			rdreq       ;
    30.     wire    [7:0]	dataF1_in   ;
    31.     wire  			wrreq1 		;
    32.     wire			empty1 		;
    33.     wire  			full1  		;
    34.     wire    [7:0]   dataF1_out  ;
    35.     wire  	[2:0]	usedw1 		;
    36.     wire    [7:0]	dataF2_in   ;
    37.     wire  			wrreq2 		;
    38.     wire			empty2 		;
    39.     wire  			full2  		;
    40.     wire    [7:0]   dataF2_out  ;
    41.     wire  	[2:0]	usedw2 		;
    42. /*************************************************************/
    43.     // reg [7:0] cnt_line
    44.     always @(posedge sys_clk or negedge sys_rst_n) begin
    45.         if(~sys_rst_n)
    46.             cnt_line <= 8'd0 ;
    47.         else if(data_flag && cnt_col == MAX_COL - 1 && cnt_line == MAX_LINE - 1)
    48.             cnt_line <= 8'd0 ;
    49.         else if(data_flag && cnt_col == MAX_COL - 1)
    50.             cnt_line <= cnt_line + 1'b1 ;
    51.         else 
    52.             cnt_line <= cnt_line ;
    53.     end
    54.     // reg [7:0] cnt_col
    55.     always @(posedge sys_clk or negedge sys_rst_n) begin
    56.         if(~sys_rst_n)
    57.             cnt_col <= 8'd0 ;
    58.         else if(data_flag && cnt_col == MAX_COL - 1)
    59.             cnt_col <= 8'd0 ;
    60.         else if(data_flag)
    61.             cnt_col <= cnt_col + 1'b1 ;
    62.         else 
    63.             cnt_col <= cnt_col ;
    64.     end
    65.     // reg   			rdreq_r    	; // fifo1 fifo2 公用一个读使能。
    66.     always @(posedge sys_clk or negedge sys_rst_n) begin
    67.         if(~sys_rst_n)
    68.             rdreq_r <= 1'b0 ;
    69.         else if(cnt_line >= XLINE_SUM - 1)
    70.             rdreq_r <= data_flag ;
    71.         else 
    72.             rdreq_r <= 1'b0 ;
    73.     end
    74.     // reg    			wrreq1_r 	;
    75.     always @(posedge sys_clk or negedge sys_rst_n) begin
    76.         if(~sys_rst_n)
    77.             wrreq1_r <= 1'b0 ;
    78.         else if(cnt_line == 0)
    79.             wrreq1_r <= data_flag ;
    80.         else if((cnt_line == (XLINE_SUM - 1) && cnt_col != 0) || (cnt_line > (XLINE_SUM - 1) && cnt_line <= (MAX_LINE - 2)) || (cnt_line == (MAX_LINE - 1) && cnt_col == 0))
    81.             wrreq1_r <= wrreq2_r ;
    82.         else 
    83.             wrreq1_r <= 1'b0 ;
    84.     end
    85.     // reg     [7:0]	dataF1_in_r ;
    86.     always @(posedge sys_clk or negedge sys_rst_n) begin
    87.         if(~sys_rst_n)
    88.             dataF1_in_r <= 8'd0 ;
    89.         else if(cnt_line == 0)
    90.             dataF1_in_r <= data_in ;
    91.         else if((cnt_line >= (XLINE_SUM - 1) && cnt_line <= (MAX_LINE - 2)) || (cnt_line == (MAX_LINE - 1) && cnt_col == 0))
    92.             dataF1_in_r <= dataF2_out ;
    93.         else 
    94.             dataF1_in_r <= dataF1_in_r ;
    95.     end
    96.     // reg    			wrreq2_r    ;
    97.     always @(posedge sys_clk or negedge sys_rst_n) begin
    98.         if(~sys_rst_n)
    99.             wrreq2_r <= 1'b0 ;
    100.         else if(cnt_line == 1)
    101.             wrreq2_r <= data_flag ;
    102.         else if((cnt_line >= (XLINE_SUM - 1) && cnt_line <= (MAX_LINE - 2)) || (cnt_line == (MAX_LINE - 1) && cnt_col == 0))
    103.             wrreq2_r <= rdreq_r ;
    104.     end
    105.     // reg     [7:0]	dataF2_in_r ;
    106.     always @(posedge sys_clk or negedge sys_rst_n) begin
    107.         if(~sys_rst_n)
    108.             dataF2_in_r <= 8'd0 ;
    109.         else if(cnt_line == 1)
    110.             dataF2_in_r <= data_in ;
    111.         else if((cnt_line >= (XLINE_SUM - 1) && cnt_line <= (MAX_LINE - 2)) || (cnt_line == (MAX_LINE - 1) && cnt_col == 0))
    112.             dataF2_in_r <= data_in_reg1 ;
    113.         else 
    114.             dataF2_in_r <= dataF2_in_r ;
    115.     end
    116.     // reg flag_sum_r ;
    117.     always @(posedge sys_clk or negedge sys_rst_n) begin
    118.         if(~sys_rst_n) 
    119.             flag_sum_r <= 1'b0 ;
    120.         else
    121.             flag_sum_r <= rdreq_r ;
    122.     end
    123. /**********************************************************/
    124.     // reg     [7:0]   po_data      ;
    125.     always @(posedge sys_clk or negedge sys_rst_n) begin
    126.         if(~sys_rst_n)
    127.             po_data <= 8'd0 ;
    128.         else if(flag_sum_r) 
    129.             po_data <= dataF1_out + dataF2_out + data_in_reg2 ;
    130.         else 
    131.             po_data <= po_data ;
    132.     end
    133.     // reg             po_data_falg ;
    134.     always @(posedge sys_clk or negedge sys_rst_n) begin
    135.         if(~sys_rst_n)
    136.             po_data_falg <= 1'b0 ;
    137.         else if(flag_sum_r) 
    138.             po_data_falg <=1'b1 ;
    139.         else 
    140.             po_data_falg <= 1'b0 ;
    141.     end
    142.     // reg     [7:0]	data_in_reg1;
    143.     // reg     [7:0]	data_in_reg2;
    144.     always @(posedge sys_clk or negedge sys_rst_n) begin
    145.         if(~sys_rst_n) begin
    146.             data_in_reg1 <= 8'd0 ;
    147.             data_in_reg2 <= 8'd0 ;
    148.         end else begin
    149.             data_in_reg1 <= data_in      ;
    150.             data_in_reg2 <= data_in_reg1 ;
    151.         end
    152.     end
    153. /*************************************************************/
    154.     assign	dataF1_in	= dataF1_in_r ;
    155.     assign	wrreq1		= wrreq1_r	  ;
    156.     assign	rdreq		= rdreq_r     ;
    157.     assign	dataF2_in	= dataF2_in_r ;
    158.     assign	wrreq2		= wrreq2_r	  ;
    159.  
    160. fifo_8x8 fifo_8x8_inst1( // 我测试了一下这个fifo 写满了之后读写信号同时拉高，要写的数据不会被写进去。除非有余量才能同时拉高，并且写入数据。
    161.     .clock				( sys_clk    ) ,
    162.     .data				( dataF1_in  ) ,
    163.     .rdreq				( rdreq      ) ,
    164.     .wrreq				( wrreq1     ) ,
    165.     .empty				( empty1     ) ,
    166.     .full				( full1      ) ,
    167.     .q					( dataF1_out ) ,
    168.     .usedw				( usedw1 	 )
    169. );
    170. fifo_8x8 fifo_8x8_inst2(  
    171.     .clock				( sys_clk    ) ,
    172.     .data				( dataF2_in  ) ,
    173.     .rdreq				( rdreq      ) ,
    174.     .wrreq				( wrreq2     ) ,
    175.     .empty				( empty2     ) ,
    176.     .full				( full2      ) ,
    177.     .q					( dataF2_out ) ,
    178.     .usedw				( usedw2 	 )
    179. );
    180.  
    181. endmodule
    1. module top(
    2.     input       wire            sys_clk   ,
    3.     input       wire            sys_rst_n ,
    4.     input       wire            rx        ,
    5.  
    6.     output      wire            tx        
    7. );
    8.  
    9.     // 例化间连线
    10.     wire            po_flag   ;
    11.     wire    [7:0]   po_data   ; 
    12.     wire            sum_flag  ;
    13.     wire    [7:0]   sum_data  ; 
    14.     
    15. uart_rx uart_rx_inst(
    16.     .sys_clk                    ( sys_clk   ) ,
    17.     .sys_rst_n                  ( sys_rst_n ) ,
    18.     .rx                         ( rx        ) ,
    19.  
    20.     .po_flag                    ( po_flag   ) ,
    21.     .po_data                    ( po_data   )    
    22. );
    23.  
    24. fifo_sum fifo_sum_inst(
    25.     .sys_clk                    ( sys_clk   ) ,
    26.     .sys_rst_n                  ( sys_rst_n ) ,
    27.     .data_in                    ( po_data   ) ,
    28.     .data_flag                  ( po_flag   ) ,
    29.  
    30.     .po_data                    ( sum_data  ) ,
    31.     .po_data_falg               ( sum_flag  )
    32. );
    33.  
    34. uart_tx uart_tx_inst(
    35.     .sys_clk                    ( sys_clk   ) ,
    36.     .sys_rst_n                  ( sys_rst_n ) ,
    37.     .pi_flag                    ( sum_flag  ) ,
    38.     .pi_data                    ( sum_data  ) ,
    39.  
    40.     .tx                         ( tx        )          
    41. );
    42.  
    43.  
    44. endmodule

    1. `timescale 1ns/1ns
    2. module test_top();
    3.     reg             sys_clk   ;
    4.     reg             sys_rst_n ;
    5.     reg             rx        ;
    6.  
    7.     wire            tx        ;
    8. // Instantiation
    9. top top_inst(
    10.     .sys_clk            ( sys_clk   ) ,
    11.     .sys_rst_n          ( sys_rst_n ) ,
    12.     .rx                 ( rx        ) ,
    13.  
    14.     .tx                 ( tx        )          
    15. );
    16.     parameter CYCLE = 20 ;
    17.     defparam  top_inst.uart_rx_inst.CLK_UART = 50_000_0 ;
    18.     defparam  top_inst.uart_tx_inst.CLK_UART = 50_000_0 ;
    19.     defparam  top_inst.uart_tx_inst.SUB_1K   = 10       ;
    20.     
    21.     task rx_bit ;
    22.     input   [7:0]   data ;
    23.     integer i ;
    24.     for (i = 0;i <= 9 ;i = i  + 1 ) begin
    25.         case (i)
    26.             0: rx <= 1'b0 ;
    27.             1: rx <= data[i - 1];
    28.             2: rx <= data[i - 1];
    29.             3: rx <= data[i - 1];
    30.             4: rx <= data[i - 1];
    31.             5: rx <= data[i - 1];
    32.             6: rx <= data[i - 1];
    33.             7: rx <= data[i - 1];
    34.             8: rx <= data[i - 1];
    35.             9: rx <= 1'b1 ;
    36.             default: rx <= 1'b1 ;
    37.         endcase
    38.         #(CYCLE * 52) ;
    39.     end
    40.     endtask
    42.     initial begin
    43.         sys_clk    = 1'b1 ;
    44.         sys_rst_n <= 1'b0 ;
    45.         rx        <= 1'b1 ;
    46.         #( CYCLE * 10 )   ;
    47.         sys_rst_n <= 1'b1 ;
    48.         #( 210 )          ;
    49.         sys_rst_n <= 1'b0 ;
    50.         #( 10 )           ;
    51.         #( CYCLE * 10 )   ;
    52.         sys_rst_n <= 1'b1 ;
    53.         #( CYCLE * 100  ) ;
    54.         rx_bit(8'd1) ;
    55.         rx_bit(8'd1) ;
    56.         rx_bit(8'd2) ;
    57.         rx_bit(8'd2) ;
    58.         rx_bit(8'd3) ;
    59.         rx_bit(8'd3) ;
    60.         rx_bit(8'd4) ;
    61.         rx_bit(8'd4) ;
    62.         rx_bit(8'd5) ;
    63.         rx_bit(8'd5) ;
    64.         rx_bit(8'd6) ;
    65.         rx_bit(8'd6) ;
    66.         rx_bit(8'd7) ;
    67.         rx_bit(8'd7) ;
    68.         rx_bit(8'd8) ;
    69.         rx_bit(8'd8) ;
    70.         rx_bit(8'd9) ;
    71.         rx_bit(8'd9) ;
    72.         rx_bit(8'd1) ;
    73.         rx_bit(8'd1) ;
    75.         
    76.         rx_bit(8'd1) ;
    77.         rx_bit(8'd1) ;
    78.         rx_bit(8'd1) ;
    79.         rx_bit(8'd1) ;
    81.         rx_bit(8'd2) ;
    82.         rx_bit(8'd2) ;
    83.         rx_bit(8'd2) ;
    84.         rx_bit(8'd2) ;
    86.         rx_bit(8'd1) ;
    87.         rx_bit(8'd1) ;
    88.         rx_bit(8'd1) ;
    89.         rx_bit(8'd1) ;
    91.         rx_bit(8'd3) ;
    92.         rx_bit(8'd3) ;
    93.         rx_bit(8'd3) ;
    94.         rx_bit(8'd3) ;
    96.         rx_bit(8'd3) ;
    97.         rx_bit(8'd3) ;
    98.         rx_bit(8'd3) ;
    99.         rx_bit(8'd3) ;
    101.         $stop        ;
    102.     end
    104.     always #( CYCLE / 2 ) sys_clk = ~sys_clk ;
    106. endmodule

     仿真波形：

    忘记截图了。

    上板验证：

  • 相关阅读:
    APP安全测试详解
    supervisor的使用
    outsystems合集系列（二）
    13.LoadRunner内置参数和事务定义
    【THREEJS】如何使用THREEJS展示车辆效果
    【Mysql】——索引的深度理解
    yamot：一款功能强大的基于Web的服务器安全监控工具
    月薪12K，蝶变向新，勇往直前—她通过转行测试实现月薪翻倍~
    智能小车—PWM方式实现小车调速和转向
    VMware workstation 中centos7虚拟机在nat模式下怎么配置网卡，指定我想要的IP并且可以联网
  • 原文地址：https://blog.csdn.net/Meng_long2022/article/details/133623925