No hay salida con for loop

2

He estado trabajando en este problema durante un par de días y todavía no puedo resolverlo. Me pregunto si alguien me puede ayudar con esto.
Solo puedes enfocarte en el proceso de video en la parte inferior del código a continuación. En cada línea de asignación en este proceso, tengo un comentario "--input" o "--output" al final.

Aquí está el problema:
- si moví alguna línea con el comentario "--input" dentro del "bucle de 0 a 2" y usé el índice como lo hice en la línea "vid_fifos (i) .clear_async < = aclear; --input", la salida del FIFO siempre está indefinida.

Pero si pongo todas las asignaciones de entrada (todas las líneas con el comentario "--input") fuera del bucle for como hice en esas líneas sobre el bucle for, funciona bien, es decir, los datos válidos de salida FIFO. Esto parece ser un problema con Modelsim solo porque el diseño funciona bien cuando lo probé en la placa de desarrollo Intel FPGA.
Aprecio si alguien tiene alguna explicación para esto.

El diseño es escalable y necesito colocar todas las líneas con el comentario "--input" dentro del bucle for y cambiar el tamaño del bucle. Gracias,

library ieee;
use ieee.std_logic_1164.all ;
use ieee.numeric_std.all;
ENTITY TEST1 is 
    port (  clk                 : in    std_logic;  
        reset                   : in    std_logic;                      
        pixels_in                   : in    std_logic_vector (0 to 47);
        pixels_out              : out   std_logic_vector (0 to 47);
        test_read               : in    std_logic;
        test_write              : in    std_logic;
        aclear                  : in    std_logic;
        sclear                  : in    std_logic;
        full                    : out   std_logic_vector(2 downto 0);
        empty                   : out   std_logic_vector(2 downto 0);
        words                   : out   std_logic_vector(29 downto 0)
        );
END;
ARCHITECTURE rtl of TEST1 is
type VID_FIFO is record
        data_in         : unsigned(15 downto 0);
        write           : std_logic;
        read            : std_logic;
        clear_async     : std_logic; 
        clock           : std_logic;  
        clear_sync      : std_logic;
        data_out        : std_logic_vector (15 downto 0);
        num_words       : std_logic_vector (9 downto 0);
        full            : std_logic ;
        empty           : std_logic;
    end record;
    type VID_FIFO_ARRAY is array (natural range <>) of VID_FIFO;
    signal      vid_fifos               : VID_FIFO_ARRAY(0 to 2);
    signal  test1 : std_logic :='0';
    --signal    cnt : unsigned(3 downto 0);
BEGIN
        G1: for i in 0 to 2 generate
          VIDEO_BUFFER: entity work.Fifo_x16_fifo_181_cdbx3jq port map (
            data    => std_logic_vector(vid_fifos(i).data_in), 
            wrreq   => vid_fifos(i).write,
            rdreq   => vid_fifos(i).read,
            clock   => vid_fifos(i).clock,
            aclr    => vid_fifos(i).clear_async,
            sclr    => vid_fifos(i).clear_sync,
            q   => vid_fifos(i).data_out,
            usedw   => vid_fifos(i).num_words,
            full    => vid_fifos(i).full,
            empty   => vid_fifos(i).empty
        );
    end generate;
VIDEO: PROCESS (all)  -- at least the clock changes, so this process shoudl be evaluate every clock
    Begin
            --vid_fifos(0).clear_async <= aclear; --input
            vid_fifos(0).clear_sync <= sclear;  --input
            --vid_fifos(1).clear_async <= aclear; --input
            vid_fifos(1).clear_sync <= sclear;  --input
            --vid_fifos(2).clear_async <= aclear;  --input
            vid_fifos(2).clear_sync <= sclear;  --input
            vid_fifos(0).clock <= clk;  --input
            vid_fifos(1).clock <= clk;  --input
            vid_fifos(2).clock <= clk;  --input
            vid_fifos(0).write <= test_write;  --input
            vid_fifos(1).write <= test_write;  --input
            vid_fifos(2).write <= test_write;  --input
            vid_fifos(0).read <= test_read;  --input
            vid_fifos(1).read <= test_read;  --input
            vid_fifos(2).read <= test_read;  --input
            vid_fifos(0).data_in <= unsigned(pixels_in(0 to 15));  --input
            vid_fifos(1).data_in <= unsigned(pixels_in(16 to 31));  --input
            vid_fifos(2).data_in <= unsigned(pixels_in(32 to 47));  --input
        for i in 0 to 2 loop   
            vid_fifos(i).clear_async <= aclear; --input
            full(i)     <= vid_fifos(i).full;  --output 
            empty(i)    <= vid_fifos(i).empty;  --output 
            words((i*10 +9) downto i*10) <= vid_fifos(i).num_words;  --output 
            pixels_out(i*16 to (i*16 + 15)) <= vid_fifos(i).data_out;  --output 
        end loop;   
    END PROCESS VIDEO;
END ARCHITECTURE;
    
pregunta Dinh Nguyen

0 respuestas

Lea otras preguntas en las etiquetas