Banco de pruebas con archivo IO vhdl

0

¿Es correcto el siguiente banco de pruebas? Intenté usar un archivo de texto con el contenido

00
01
10
11

para probar una arquitectura de un puerto y.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.std_logic_misc.all;
use std.textio.all;

entity my_and_tb is
end entity my_and_tb;

architecture tb_arch of my_and_tb is
    component my_and is
    port  ( x, y : in std_ulogic;
           z : out std_ulogic);
end component;
signal x_tb, y_tb, z_tb : std_ulogic;
begin
my_and_inst : my_and port map( x => x_tb, y => y_tb, z => z_tb);

tb_process : process
    file my_input : TEXT open READ_MODE is "my_input.txt";
    file my_output : TEXT open WRITE_MODE is "my_output.txt";
    variable my_line : LINE;
    variable my_input_line : LINE;
    variable my_output_line : LINE;
    variable x_bit : bit;
    variable y_bit : bit;
    variable z_bit : bit;
begin
    while not endfile(my_input) loop
        readline(my_input,my_line);
        read(my_line,x_bit);
        read(my_line,y_bit);
        x_tb <= to_stdulogic(x_bit) after 5 ns;
        y_tb <= to_stdulogic(y_bit) after 5 ns;
        z_bit := to_bit(z_tb);
        write(my_output_line,z_bit);
        writeline(my_output,my_output_line);
        wait for 10 ns;
    end loop;
end process;
end architecture tb_arch;

Básicamente la simulación con ncsim está bloqueada ... Actualizar ...

El mismo problema para este ejemplo (es un flip flop d, y básicamente el reloj me confunde, pensé que estaba bien pero no lo es ... ¿podrías ayudarme?)

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_misc.all;
use ieee.numeric_std.all;
use ieee.std_logic_textio.all;
use std.textio.all;

entity ff_d_tb is
end entity ff_d_tb;

architecture ff_d_tb_arch of ff_d_tb is
component ff_d is
port(clk, d : in std_logic;
     q : out std_logic);
end component;

signal clk_tb, d_tb, q_tb : std_logic;
begin

ff_d_comp : ff_d
port map(clk => clk_tb, d => d_tb, q => q_tb);  

clk_process : process
begin
    clk_tb <= '0','1' after 5 ns;
    wait for 10 ns;
end process;

ff_process : process
    file in_file : text open READ_MODE is "input.txt";
    file out_file : text open WRITE_MODE is "output.txt";
    variable l_in : line;
    variable l_out : line;
    variable q_loc, d_loc : std_logic;
begin
    while not endfile(in_file) loop
        readline(in_file,l_in);
        read(l_in,d_loc);
        d_tb <= d_loc after 5 ns;
        wait until falling_edge(clk_tb);
        q_loc := q_tb;
        write(l_out,q_loc);
        writeline(out_file,l_out);
    end loop;
    wait;
end process;
end architecture ff_d_tb_arch;
    
pregunta user8469759

1 respuesta

0

No. Tu banco de pruebas no es correcto.

Tienes dos cláusulas de uso superfluo:

-- use ieee.numeric_std.all;
-- use ieee.std_logic_misc.all;

Tu proceso tb_process debería tener wait; end loop; permitiendo que la simulación se complete cuando hayas terminado de procesar el estímulo de entrada de my_input.txt .

Acerca de entonces notará que todos sus resultados en my_output.txt son todos 0 , lo cual es causado por el retardo del ciclo delta en la asignación a la señal z_tb en la entidad my_and . Su proceso también ha retrasado las asignaciones a x_tb y y_tb que deben tenerse en cuenta.

No se produce ninguna actualización de señal durante la ejecución de ningún proceso (y todas las actualizaciones de señal se producen dentro de los procesos, las declaraciones concurrentes se elaboran en declaraciones de proceso o declaraciones de proceso y declaraciones de bloque). Esencialmente, debe suspender el proceso antes de que cualquiera de estas asignaciones surta efecto.

La cura es una o más sentencias de espera que suspenderán la ejecución. A continuación se muestran dos, un wait for 5 ns; y un wait for 0 ns; . Se pueden contraer en una sentencia de espera. El propósito es mostrar que necesita al menos un retraso de ciclo delta después de las asignaciones a x_tb y y_tb que tienen efecto para que z_tb se actualice. Si hubiera una asignación de señal retrasada para z ( z_tb ) en la entidad my_and , ese retraso también se agregaría a la primera declaración de espera.

tb_process:  
    process
        file my_input:  TEXT open READ_MODE is "my_input.txt";
        file my_output:  TEXT open WRITE_MODE is "my_output.txt";
        variable my_line:  LINE;
        variable my_input_line:  LINE;
        variable my_output_line:  LINE;
        variable x_bit:  bit;
        variable y_bit:  bit;
        variable z_bit:  bit;
    begin
        while not endfile(my_input) loop
            readline(my_input,my_line);
            read(my_line,x_bit);
            read(my_line,y_bit);
            x_tb <= to_stdulogic(x_bit) after 5 ns;
            y_tb <= to_stdulogic(y_bit) after 5 ns;
            wait for 5 ns;  -- added
            wait for 0 ns;  -- added
            z_bit := to_bit(z_tb);
            -- report "x_bit = " & bit'image(x_bit);
            -- report "y_bit = " & bit'image(y_bit);
            -- report "z_tb = "  & std_ulogic'image(z_tb);
            write(my_output_line,z_bit);
            writeline(my_output,my_output_line);
            -- wait for 10 ns;  -- removed
        end loop;
        wait;
    end process;

Tenga en cuenta que wait for 10 ns; está comentado, no es necesario cuando su proceso tiene un modelo lineal de tiempo que permite que las asignaciones de señales tengan efecto (tiene una o más declaraciones de espera).

La modificación anterior a su declaración de proceso con un modelo de retraso cero para my_and da:

  

más my_output.txt
  0
  0
  0
  1

Cuál es el resultado esperado.

Observe las declaraciones de informe comentadas que se pueden usar para depurar la declaración de proceso. Si no tiene suficiente retraso, el primer informe para z_tb mostrará un 'U' .

    
respondido por el user8352

Lea otras preguntas en las etiquetas