Palabras clave: testbench, simulación, lectura y escritura de archivos

Una vez completado el diseño del código Verilog, todavía se necesita un paso importante, es decir, la simulación de la función lógica. El archivo de estímulo de simulación se llama testbench y se coloca en la capa superior de cada módulo de diseño, para poder realizar una simulación mediante la instanciación y llamada sistemática de los módulos.

Sin exagerar, para diseños Verilog un poco complejos, si no se realiza una simulación, incluso para veteranos con mucha experiencia, más del 99.9999% de los diseños no funcionarán correctamente. No se puede decir que la simulación sea más importante que el diseño, pero en general, el tiempo dedicado a la simulación suele ser mayor que el dedicado al diseño. A veces, considerando diversos escenarios de aplicación, la escritura del testbench puede ser incluso más compleja que el diseño Verilog. Por lo tanto, la industria de circuitos digitales divide específicamente a los ingenieros de diseño y a los ingenieros de verificación.

A continuación, hagamos un estudio sencillo del testbench.

División de la estructura del testbench

La estructura general del testbench es la siguiente:

En realidad, la estructura más básica del testbench incluye la declaración de señales, la excitación y la instanciación de módulos.

Según la complejidad del diseño, se deben introducir las partes de reloj y reinicio. Por supuesto, para diseños más complejos, la parte de excitación también será más compleja. Según sus necesidades de verificación, elija si se requiere la parte de autocomprobación y de detención de la simulación.

Por supuesto, las partes de generación de reinicio y reloj también pueden considerarse como excitación, por lo que todas pueden implementarse en un bloque de declaraciones. También se puede usar el resultado de la autocomprobación como condición para finalizar la simulación.

En la simulación real, se puede escribir el testbench según los hábitos personales; aquí solo se hace un resumen personal.

Ejemplo de simulación de testbench

En los capítulos anteriores, ya se han escrito muchos testbenches. En realidad, sus estructuras son más o menos las mismas.

A continuación, tomemos un ejemplo sencillo de concatenación de datos para hacer un análisis específico del testbench.

La descripción de un módulo funcional que concatena datos de 2 bits en datos de 8 bits es la siguiente:

Ejemplo

module  data_consolidation
    (
        input           clk ,
        input           rstn ,
        input [1:0]     din ,          //data in
        input           din_en ,
        output [7:0]    dout ,
        output          dout_en        //data out
     );

   // data shift and counter
    reg [7:0]            data_r ;
    reg [1:0]            state_cnt ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            state_cnt     <= 'b0 ;
            data_r        <= 'b0 ;
        end
        else if (din_en) begin
            state_cnt     <= state_cnt + 1'b1 ;    //conteo de datos
            data_r        <= {data_r[5:0], din} ;  //concatenación de datos
        end
        else begin
            state_cnt <= 'b0 ;
        end
    end
    assign dout          = data_r ;

    // data output en
    reg                  dout_en_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            dout_en_r       <= 'b0 ;
        end
        //cuando el contador es 3 y se introduce el cuarto dato, se emite sincrónicamente la señal de habilitación de salida de datos
        else if (state_cnt == 2'd3 & din_en) begin  
            dout_en_r       <= 1'b1 ;
        end
        else begin
            dout_en_r       <= 1'b0 ;
        end
    end
    //aquí no se declara dout_en directamente como variable reg, sino que se le asigna valor mediante assign con registros relacionados
    assign dout_en       = dout_en_r;

endmodule

La descripción del testbench correspondiente es la siguiente, con declaraciones adicionales de lectura y escritura de archivos:

Ejemplo

`timescale 1ns/1ps

   //============== (1) ==================
   //signals declaration
module test ;
    reg          clk;
    reg          rstn ;
    reg [1:0]    din ;
    reg          din_en ;
    wire [7:0]   dout ;
    wire         dout_en ;

    //============== (2) ==================
    //clock generating
    real         CYCLE_200MHz = 5 ; //
    always begin
        clk = 0 ; #(CYCLE_200MHz/2) ;
        clk = 1 ; #(CYCLE_200MHz/2) ;
    end

    //============== (3) ==================
    //reset generating
    initial begin
        rstn      = 1'b0 ;
        #8 rstn      = 1'b1 ;
    end

    //============== (4) ==================
    //motivation
    int          fd_rd ;
    reg [7:0]    data_in_temp ;  //for self check
    reg [15:0]   read_temp ;     //8bit ascii data, 8bit \n
    initial begin
        din_en    = 1'b0 ;        //(4.1)
        din       = 'b0 ;
        open_file("../tb/data_in.dat", "r", fd_rd); //(4.2)
        wait (rstn) ;    //(4.3)
        # CYCLE_200MHz ;

        //read data from file
        while (! $feof(fd_rd) ) begin  //(4.4)
            @(negedge clk) ;
            $fread(read_temp, fd_rd);
            din    = read_temp[9:8] ;
            data_in_temp = {data_in_temp[5:0], din} ;
            din_en = 1'b1 ;
        end

        //stop data
        @(posedge clk) ;  //(4.5)
        #2 din_en = 1'b0 ;
    end

    //open task
    task open_file;
        input string      file_dir_name ;
        input string      rw ;
        output int        fd ;

        fd = $fopen(file_dir_name, rw);
        if (! fd) begin
            $display("--- iii --- Failed to open file: %s", file_dir_name);
        end
        else begin
            $display("--- iii --- %s has been opened successfully.", file_dir_name);
        end
    endtask

    //============== (5) ==================
    //module instantiation
    data_consolidation    u_data_process
    (
      .clk              (clk),
      .rstn             (rstn),
      .din              (din),
      .din_en           (din_en),
      .dout             (dout),
      .dout_en          (dout_en)
     );

    //============== (6) ==================
    //auto check
    reg  [7:0]           err_cnt ;
    int                  fd_wr ;

    initial begin
        err_cnt   = 'b0 ;
        open_file("../tb/data_out.dat", "w", fd_wr);
        forever begin
            @(negedge clk) ;
            if (dout_en) begin
                $fdisplay(fd_wr, "%h", dout);
            end
        end
    end

    always @(posedge clk) begin
        #1 ;
        if (dout_en) begin
            if (data_in_temp != dout) begin
                err_cnt = err_cnt + 1'b1 ;
            end
        end
    end

    //============== (7) ==================
    //simulation finish
    always begin
        #100;
        if ($time >= 10000)  begin
            if (!err_cnt) begin
                $display("-------------------------------------");
                $display("Data process is OK!!!");
                $display("-------------------------------------");
            end
            else begin
                $display("-------------------------------------");
                $display("Error occurs in data process!!!");
                $display("-------------------------------------");
            end
            #1 ;
            $finish ;
        end
    end

endmodule // test

Los resultados de la simulación son los siguientes. Como se puede ver en la figura, el diseño de la función de integración de datos cumple con los requisitos:

Análisis específico del testbench

1) Declaración de señales

Al declarar el módulo testbench, generalmente no es necesario declarar puertos. Debido a que las señales de excitación generalmente están dentro del módulo testbench, no hay señales externas.

Las variables declaradas deben corresponder en su totalidad a los puertos del módulo bajo prueba. Por supuesto, las variables no tienen que tener el mismo nombre que los puertos del módulo bajo prueba. Pero las variables correspondientes a los puertos de entrada del módulo bajo prueba deben declararse de tipo reg, como clk, rstn, etc.; las variables correspondientes a los puertos de salida deben declararse de tipo wire, como dout, dout_en.

2) Generación del reloj

Hay muchas formas de generar el reloj; por ejemplo, los dos métodos de generación siguientes también se pueden tomar como referencia.

Ejemplo

initial clk = 0 ;
always #(CYCLE_200MHz/2) clk = ~clk;

initial begin
    clk = 0 ;
    forever begin
        #(CYCLE_200MHz/2) clk = ~clk;
    end
end      

Cabe señalar que al usar el método de inversión para generar el reloj, es imprescindible asignar un valor inicial al registro clk.

Al usar el método de parámetros para especificar el retardo temporal, si el parámetro de retardo es un número de punto flotante, ese parámetro no debe declararse como tipo parameter. Por ejemplo, en el ejemplo, el valor de la variable CYCLE_200MHz es 2.5. Si su tipo de variable es parameter, es muy probable que el periodo de reloj generado sea de 4 ns. Por supuesto, también es necesario aumentar la precisión de timescale; la unidad y la precisión no pueden ser iguales, de lo contrario, la asignación de retardo con parte fraccionaria tampoco funcionará.

3) Generación del reinicio

La lógica de reinicio es relativamente simple; generalmente se asigna un valor inicial de 0 y, después de un pequeño retardo, el reinicio se pone a 1.

Aquí la mayoría de las simulaciones utilizan reinicio activo por nivel bajo.

4) Parte de excitación

La señal de entrada que debe generar la parte de excitación se diseña según las necesidades del módulo bajo prueba.

En este ejemplo:

  • (4.1) Inicialice las señales de entrada del módulo bajo prueba para evitar la aparición de valores indeterminados X. Para generar los datos de excitación, necesitamos leerlos de un archivo de datos.
  • En (4.2) se utiliza una task para abrir un archivo; siempre que el archivo especificado exista, se puede obtener un identificador de señal fp_rd distinto de 0. fp_rd especifica la dirección inicial de los datos del archivo.
  • La operación en (4.3) es para esperar a que, después del reinicio, el sistema tenga un estado de prueba seguro y estable.
  • En (4.4) se comienza a leer datos y proporcionar excitación en un bucle. Enviar los datos en el flanco descendente del reloj es para que el módulo bajo prueba pueda muestrear mejor los datos en el flanco ascendente.

Utilizando la tarea del sistema $fread, a través del identificador de señal fd_rd, la variable de datos de 16 bits leída se envía al búfer read_temp.

La captura de pantalla de los primeros datos del archivo de entrada es la siguiente. Debido a que $fread solo puede leer archivos binarios, la primera línea del archivo de entrada corresponde al código ASCII 330a; por lo tanto, si queremos obtener el dato 3 en el archivo, debemos tomar los bits 9 a 8 de la variable read_temp.

La señal data_in_temp es una integración posterior de la señal de datos de entrada; más adelante, el módulo de verificación la tomará como referencia para juzgar si la simulación es correcta y si el diseño del módulo es correcto.

  • En (4.5) se elige detener los datos de entrada después de un retardo de 2 ciclos en el flanco ascendente del reloj, para que el módulo bajo prueba pueda muestrear normalmente la última señal de habilitación de datos y realizar la integración normal de los datos.

Cuando la cantidad de datos es relativamente pequeña, se puede utilizar la tarea del sistema $readmemh de Verilog para leer directamente datos hexadecimales línea por línea. Manteniendo sin cambios los datos y el formato del archivo data_in.dat, la parte de excitación puede describirse como:

Ejemplo

    reg [1:0]    data_mem [39:0] ;
    reg [7:0]    data_in_temp ;  //for self check
    integer      k1 ;
    initial begin
        din_en    = 1'b0 ;
        din       = 'b0 ;
        $readmemh("../tb/data_in.dat", data_mem);
        wait (rstn) ;
        # CYCLE_200MHz ;

        //read data from file
        for(k1=0; k1<40; k1=k1+1)  begin
            @(negedge clk) ;
            din    = data_mem[k1] ;
            data_in_temp = {data_in_temp[5:0], din} ;
            din_en = 1'b1 ;
        end

        //stop data
        @(posedge clk) ;
        #2 din_en = 1'b0 ;
     end

5) Instanciación del módulo

Aquí se utilizan las variables de señal declaradas al inicio del testbench para realizar la instanciación y conexión del módulo bajo prueba.

6) Autocomprobación

Si el diseño es relativamente simple, se puede determinar completamente si el diseño es correcto a través de las formas de onda de las señales de entrada y salida; esta parte se puede eliminar por completo. Si hay muchos datos, a veces la observación a simple vista no permite juzgar eficazmente la corrección del diseño. En ese caso, agregar un módulo de autocomprobación aumentará en gran medida la eficiencia de la simulación.

En el ejemplo, cuando la habilitación de salida de datos dout_en esté activa, compararemos el dato de salida dout con el dato de referencia read_temp (generado en la parte de excitación), y colocaremos el resultado de la comparación en la señal err_cnt. Finalmente, se puede juzgar de forma intuitiva la corrección del diseño observando si la señal err_cnt es 0.

Por supuesto, como se muestra en el ejemplo, también podemos escribir los datos en un archivo correspondiente y utilizar otras formas de comparación.

7) Finalización de la simulación

Si no agregamos la parte de finalización de la simulación, la simulación se ejecutará indefinidamente; una forma de onda demasiado larga no siempre es conveniente para el análisis. Verilog proporciona la tarea del sistema $finish para detener la simulación.

Antes de detener la simulación, el resultado de la autocomprobación puede mostrarse en la terminal mediante la tarea del sistema $display.

Opciones de lectura y escritura de archivos

El formato de la tarea del sistema $fopen para abrir archivos es el siguiente:

fd = $fopen("<name_of_file>", "mode")

Similar al lenguaje C, el significado de la opción de modo de apertura "mode" es el siguiente:

rAbrir un archivo de texto en modo solo lectura; solo permite leer datos.
wAbrir un archivo de texto en modo solo escritura; solo permite escribir datos. Si el archivo existe, el contenido original se elimina. Si el archivo no existe, se crea un archivo nuevo.
aAbrir un archivo de texto en modo añadir y escribir datos al final del archivo. Si el archivo no existe, se crea un archivo nuevo.
rbAbrir un archivo binario en modo solo lectura; solo permite leer datos.
wbAbrir o crear un archivo binario en modo solo escritura; solo permite escribir datos.
abAbrir un archivo binario en modo añadir y escribir datos al final del archivo.
r+Abrir un archivo de texto en modo lectura y escritura; permite leer y escribir.
w+Abrir o crear un archivo de texto en modo lectura y escritura; permite leer y escribir. Si el archivo existe, el contenido original se elimina. Si el archivo no existe, se crea un archivo nuevo.
a+Abrir un archivo de texto en modo lectura y escritura; permite leer y escribir. Si el archivo no existe, se crea un archivo nuevo. La lectura del archivo comienza desde la dirección inicial del archivo; la escritura solo puede ser en modo añadir.
rb+Abrir un archivo binario en modo lectura y escritura; la función es similar a "r+".
wb+Abrir o crear un archivo binario en modo lectura y escritura; la función es similar a "w+".
ab+Abrir un archivo binario en modo lectura y escritura; la función es similar a "a+".

Descarga del código fuente

Download