// Self-checking testbench for uart_tx, uart_rx and uart_echo_top. // Run with Icarus Verilog: // $ iverilog -g2012 -o sim tb_uart.sv uart_tx.sv uart_rx.sv uart_echo_top.sv // $ vvp sim // Tests: // 1. Loopback: uart_tx -> uart_rx, directed and random bytes, back to back. // 2. A frame with a bad stop bit must raise rx_frame_err and no rx_valid. // 3. A short glitch on an idle line must be ignored. // 4. Frames sent 3 % fast and 3 % slow must still be received. // 5. Echo: bytes sent to uart_echo_top must come back unchanged. `timescale 1ns / 1ps module tb_uart; localparam int CLK_FREQ = 100_000_000; localparam int BAUD = 115_200; localparam real BIT_NS = 1.0e9 / BAUD; // ideal bit time: 8680.56 ns localparam real FAST_NS = BIT_NS * 0.97; // sender clock 3 % fast localparam real SLOW_NS = BIT_NS * 1.03; // sender clock 3 % slow localparam int N_RANDOM = 100; // --------------------------------------------------------------- // Clock and signals // --------------------------------------------------------------- logic clk; logic rst; logic [7:0] tx_data; logic tx_valid; logic tx_ready; logic tx_line; // uart_tx output logic bfm_line; // line driven by the testbench "PC" logic use_bfm; // 0: rx listens to uart_tx, 1: to the testbench logic rx_line; logic [7:0] rx_data; logic rx_valid; logic rx_frame_err; logic rst_n; // echo top: reset button logic pc_line; // echo top: PC -> FPGA logic top_txd; // echo top: FPGA -> PC logic led_err; logic [7:0] mon_data; logic mon_valid; logic mon_frame_err; initial begin clk = 1'b0; forever #5 clk = ~clk; // 100 MHz end // --------------------------------------------------------------- // Devices under test // --------------------------------------------------------------- uart_tx #(.CLK_FREQ(CLK_FREQ), .BAUD(BAUD)) u_tx ( .clk(clk), .rst(rst), .tx_data(tx_data), .tx_valid(tx_valid), .tx_ready(tx_ready), .txd(tx_line) ); assign rx_line = use_bfm ? bfm_line : tx_line; uart_rx #(.CLK_FREQ(CLK_FREQ), .BAUD(BAUD)) u_rx ( .clk(clk), .rst(rst), .rxd(rx_line), .rx_data(rx_data), .rx_valid(rx_valid), .rx_frame_err(rx_frame_err) ); uart_echo_top #(.CLK_FREQ(CLK_FREQ), .BAUD(BAUD)) u_top ( .clk(clk), .rst_n(rst_n), .uart_rxd(pc_line), .uart_txd(top_txd), .led_err(led_err) ); // A second receiver plays the PC side and decodes what the echo top sends. uart_rx #(.CLK_FREQ(CLK_FREQ), .BAUD(BAUD)) u_mon ( .clk(clk), .rst(rst), .rxd(top_txd), .rx_data(mon_data), .rx_valid(mon_valid), .rx_frame_err(mon_frame_err) ); // --------------------------------------------------------------- // Scoreboards: expected bytes, in order, for each receiver // --------------------------------------------------------------- logic [7:0] exp_rx [0:255]; logic [7:0] exp_mon [0:255]; int exp_rx_n, rx_n, frame_errs; int exp_mon_n, mon_n; int errors; initial begin exp_rx_n = 0; rx_n = 0; frame_errs = 0; forever begin @(negedge clk); if (rx_valid) begin if (rx_n >= exp_rx_n) begin errors++; $error("u_rx: unexpected byte %h", rx_data); end else if (rx_data !== exp_rx[rx_n]) begin errors++; $error("u_rx: got %h, expected %h", rx_data, exp_rx[rx_n]); end rx_n++; end if (rx_frame_err) frame_errs++; end end initial begin exp_mon_n = 0; mon_n = 0; forever begin @(negedge clk); if (mon_valid) begin if (mon_n >= exp_mon_n) begin errors++; $error("echo: unexpected byte %h", mon_data); end else if (mon_data !== exp_mon[mon_n]) begin errors++; $error("echo: got %h, expected %h", mon_data, exp_mon[mon_n]); end mon_n++; end if (mon_frame_err) begin errors++; $error("echo: framing error on uart_txd"); end end end // --------------------------------------------------------------- // Tasks // --------------------------------------------------------------- // Hand one byte to uart_tx using the valid/ready handshake. task automatic tx_send(input logic [7:0] b); exp_rx[exp_rx_n] = b; exp_rx_n++; do @(negedge clk); while (!tx_ready); tx_data = b; tx_valid = 1'b1; @(negedge clk); // the rising edge in between accepted it tx_valid = 1'b0; endtask // Drive one 8N1 frame on a testbench line, the way a PC would. // port 0: bfm_line (to u_rx), port 1: pc_line (to the echo top). // speed 0: nominal bit time, 1: 3 % fast, 2: 3 % slow. task automatic set_line(input int port, input logic v); if (port == 0) bfm_line = v; else pc_line = v; endtask task automatic bit_delay(input int speed); case (speed) 1: #(FAST_NS); 2: #(SLOW_NS); default: #(BIT_NS); endcase endtask task automatic pc_send(input int port, input logic [7:0] b, input int speed, input logic stop_bit); set_line(port, 1'b0); // start bit bit_delay(speed); for (int i = 0; i < 8; i++) begin // data, LSB first set_line(port, b[i]); bit_delay(speed); end set_line(port, stop_bit); // stop bit bit_delay(speed); set_line(port, 1'b1); // idle endtask // Wait until u_rx has produced n bytes, or give up after a timeout. task automatic wait_rx(input int n); int cycles; cycles = 0; while (rx_n < n && cycles < 2_000_000) begin @(negedge clk); cycles++; end if (rx_n < n) begin errors++; $error("timeout: %0d of %0d bytes received", rx_n, n); end endtask // --------------------------------------------------------------- // Test sequence // --------------------------------------------------------------- integer seed; logic [7:0] b; string msg; initial begin errors = 0; seed = 13; rst = 1'b1; rst_n = 1'b0; tx_data = 8'h00; tx_valid = 1'b0; use_bfm = 1'b0; bfm_line = 1'b1; pc_line = 1'b1; if ($test$plusargs("dump")) begin $dumpfile("tb_uart.vcd"); $dumpvars(0, tb_uart); end repeat (4) @(negedge clk); rst = 1'b0; rst_n = 1'b1; repeat (4) @(negedge clk); // 1. Loopback tx_send(8'h00); tx_send(8'hFF); tx_send(8'h55); tx_send(8'hAA); for (int i = 0; i < N_RANDOM; i++) tx_send(8'($random(seed))); wait_rx(exp_rx_n); $display("Test 1 loopback: %0d of %0d bytes received", rx_n, exp_rx_n); // 2. Framing error: stop bit sent as 0 use_bfm = 1'b1; #(2 * BIT_NS); pc_send(0, 8'hA5, 0, 1'b0); #(2 * BIT_NS); if (frame_errs != 1 || rx_n != exp_rx_n) begin errors++; $error("framing error not detected correctly"); end $display("Test 2 framing error: %0d error flagged, no byte output", frame_errs); // 3. A 1 us low glitch on an idle line bfm_line = 1'b0; #1000; bfm_line = 1'b1; #(12 * BIT_NS); if (frame_errs != 1 || rx_n != exp_rx_n) begin errors++; $error("glitch was not ignored"); end $display("Test 3 glitch: ignored"); // 4. Baud rate offset: the PC clock is 3 % fast, then 3 % slow for (int i = 0; i < 20; i++) begin b = 8'($random(seed)); exp_rx[exp_rx_n] = b; exp_rx_n++; pc_send(0, b, (i < 10) ? 1 : 2, 1'b1); end wait_rx(exp_rx_n); $display("Test 4 baud +/-3 %%: %0d of %0d bytes received", rx_n, exp_rx_n); // 5. Echo through the top level msg = "Hello\r\n"; for (int i = 0; i < msg.len(); i++) begin exp_mon[exp_mon_n] = msg[i]; exp_mon_n++; pc_send(1, msg[i], 0, 1'b1); end #(12 * BIT_NS); if (mon_n != exp_mon_n || led_err) begin errors++; $error("echo: %0d of %0d bytes came back, led_err=%b", mon_n, exp_mon_n, led_err); end $display("Test 5 echo: %0d of %0d bytes echoed", mon_n, exp_mon_n); if (errors == 0 && frame_errs == 1) begin $display("PASS"); $finish; end else begin $fatal(1, "FAIL: %0d errors", errors); end end endmodule