Discussion :

[ahmednaess]

Bonjour à tous,
j'ai plusieurs registres de type std_logic_vector de taille variable que je voudrais mettre dans un tableau,

par exemple "0001010000100010", "0010" et "001101" que je voudrais mettre sous forme de 0001010000100010
0010
001101
et rajouter une concaténation de 0 pour qu'ils soient tous de même taille.

0001010000100010
0010000000000000
0011010000000000

Pour la concaténation je sais que je peux utilisé par exemple
vec<= (reg_i, others => '0');
Mais je ne sais pas du tout comment écrire le contenu de mes registres dans un tableau.
Si quelqu'un à une idée je suis preneur.
Merci d'avance de votre aide les amis.

[mith06]

Bonjour,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
type myTab_type    is array(2 downto 0) of std_logic_vector(15 downto 0);
signal tab  :   myTab_type;
 
begin
 
    mon_process : process(RST,CLK)
        if(RST = '1')then
            --INITILAISE VALUE
           tab(0)   <= "0001010000100010";
           tab(1)   <= "0010000000000000";
           tab(2)   <= "0011010000000000";
        elsif(rising_edge(CLK))then
            --DO SOMETHING
        end if;
    end process mon_process;

J'espère aider

[ahmednaess]

Bonjour,
Je voudrais d'abord te remercier de ta réponse,
mais dans ton code on rentre le contenu du tableau à la main et moi ce que je voudrais faire c'est écrire le contenu de plusieurs registres qui sont de taille variable dans une matrice carré.
c'est à dire que je vais mettre le contenu de ces registres dans une matrice puis comparer la taille des registres avec le nombre de registres et concaténé le tout avec des zero pour obtenir une matrice carré.

[ahmednaess]

je pensais plus à un code de ce genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
entity tableau is
port ( clk : IN std_logic;
		 reset : IN std_logic);
end tableau;
 
architecture Behavioral of tableau is
 
 
type tab is array(15 downto 0) of std_logic_vector(15 downto 0);
signal tab:tab;
 
begin
 
    process_tab : process(reset,clk)
        if reset = '1' then
            --INITIALISE VALUE
				FOR i 0 to 15 loop
           tab(i)   := "0000000000000000";
			  end loop;
        elsif(rising_edge(clk))then
           tab(0)   <= RN16;
           tab(1)   <= Handle;
           tab(2)   <= (TRcal, others => '0');
			  tab(3)   <= (reset_counter, others => '0');
           tab(4)   <= (DR, others => '0');
           tab(5)   <= (M, others => '0');
			  tab(6)   <= (TRext, others => '0');
           tab(7)   <= (session, others => '0');
           tab(8)   <= (Q, others => '0');
			  tab(9)   <= (read_sequence, others => '0');
           tab(10)   <= (adresse_counter, others => '0');
           tab(11)   <= (TagState, others => '0');
			  tab(12)   := "0000000000000000";
           tab(13)   := "0000000000000000";
           tab(14)   := "0000000000000000";
			  tab(15)   := "0000000000000000";
        end if;
    end process process_tab;
 
end Behavioral;

[mith06]

Oui ça doit marcher.
Mais attention généralement on utilise les tableau pour forcer le synthétiseur à instancier un mémoire de type BRAM, cad accès a un élément (ou 2<=> dual port memory) du tableau par cycle horloge.
Ici tu accède à tous les éléments du tableau sur le même cycle horloge. Ce ne n'est pas une mémoire mais un banc de registres.

Utiliser un tableau ne sert à rien. Déclare directement 15 signaux avec des noms indicés de 0 à 15.

[ahmednaess]

En fait ce que je veux faire c'est différent contrôle de parité sur le contenu de ces registres,
un contrôle de parité horizontale donc chaque registre seul, un contrôle de parité verticale et un contrôle de parité diagonale donc tout les registres ensembles.
Donc mettre le contenu de tout les registres dans un tableau et les concaténé avec des '0' pour obtenir une matrice carré me semblé être la meilleure idée.