Salut !
J'ai écrit un programme simulant un registre à décalage programmable. Le tout compile mais lorsque je lance la simulation je n'ai aucun signal qui s'affiche. Je ne trouve pas d'où ca pourrait venir et je déséspère un peu. Si quelqu'un pourrait m'aider ca serait super ^_^. Je vous file le code. (J'utilise Sonata comme éditeur)
 
package pack is
 type commande is (LOAD, SHLL, SHRL, SHLA, SHRA, ROTL, ROTR);
end package pack;
 
 
-- les 7 commandes
-- LOAD chargement de DIN dans le registre
-- SHLL décalage logique à gauche
-- SHRL décalage logique à droite
-- SHLA décalage arithmétique à gauche
-- SHRA décalage arithmétique à droite
-- ROTL rotation à gauche
-- ROTR rotation à droite
 
-- importation du package
use work.pack.all;
 
 
entity regprog is
 
generic(
 N : natural := 8; -- nb de bits donc nb de registre
 TP : time := 0 ns -- temps de propagation dans le registre
);
port(
 signal CLK   : in bit; -- horloge
 signal RST_B : in bit; -- reset actif au niveau bas
 signal CMD   : in commande; -- type d'opération
 signal NSR   : in natural; -- nb de bit affecté par une opération => nb de bit qui va tourner,... par coup d'horloge
 signal DIN   : in bit_vector(N-1 downto 0);  -- entrée, bus de N bit
 signal DOUT  : out bit_vector(N-1 downto 0) -- sortie, bus de N bit
);
end entity regprog;
 
 
 
architecture bhv of regprog is
 
 shared variable reg_vect: bit_vector(N-1 downto 0) := (others => '0');  -- vecteur contenant les bits (contenu) du registre initialisé à 0
begin
 
process (CLK, RST_B, CMD, NSR, DIN)
 
 -- procédure pour définir les opération p81 cours
 
 procedure pshll is  -- décalage logique à gauche
 begin
  for i in 1 to NSR loop -- p16 VHDL instant
   reg_vect := reg_vect(N-2 downto 0) & '0';   -- p36 cours  équivalent à: reg_vect sll NSR
  end loop;
 end procedure pshll;
 
 procedure pshrl is
 begin
  for i in 1 to NSR loop  
   reg_vect := '0' & reg_vect(N-1 downto 1);  -- décalage logique à droite
  end loop;
 end procedure pshrl;
 
 procedure pshla is
 begin
  for i in 1 to NSR loop
   reg_vect := reg_vect(N-2 downto 0) & reg_vect(0); -- décalage arithm. à gauche
  end loop;
 end procedure pshla;
 
 procedure pshra is
 begin
  for i in 1 to NSR loop
   reg_vect := reg_vect(N-1) & reg_vect(N-1 downto 1); -- décalage arithm. à droite
  end loop;
 end procedure pshra;
 
 procedure protl is
 begin
  for i in 1 to NSR loop
   reg_vect := reg_vect(N-2 downto 0) & reg_vect(N-1);  -- rotation à gauche
  end loop;
 end procedure protl;
 
 procedure protr is
 begin
  for i in 1 to NSR loop
   reg_vect := reg_vect(0) & reg_vect(N-1 downto 1);  -- rotation à droite
  end loop;
 end procedure protr;
 
 
 
 
 
begin
 if RST_B = '0' then
  reg_vect := (others => '0');  -- si reset on met les registres à 0
 elsif CLK = '1' and CLK'event then   -- vérifie d'avoir un flanc montant
  case CMD is    -- p33 cours
   when LOAD => reg_vect := DIN;  -- chargement de DIN ds les registres
   -- effectue les procédures
   when SHLL => pshll;
   when SHRL => pshrl;
   when SHLA => pshla;
   when SHRA => pshra;
   when ROTL => protl;
   when ROTR => protr;
  end case;
 end if;
 
 DOUT <= reg_vect after TP;   -- affecte les valeur du registre à la sortie
end process;
 
end architecture bhv;
 
 
 
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use work.pack.all;
 
entity tb_regprog is
end entity tb_regprog;
 
 
architecture bench of tb_regprog is
 
 constant N_tb: positive:=8;  -- nb de bascule par défaut
 constant TP_tb: time:= 0 ns; -- retard
 constant duree: time:= 2 ns;    -- durée de la période de CLK à choix
 
 signal CLK_tb: bit := '0'; -- initialise l'horloge à 0
 signal RST_B_tb: bit := '1'; --  "  le reset à 1
 signal CMD_tb: commande;
 signal NSR_tb: natural := 2;  -- nb de décalage, à choix
 signal DIN_tb: bit_vector(N_tb-1 downto 0) := "10010110";  -- affecte une valeur à l'entrée pour le test
 signal DOUT_tb: bit_vector(N_tb-1 downto 0);
 shared variable reg_vect_tb: bit_vector(N_tb-1 downto 0);
begin
 UUT: entity work.regprog(bhv)
 generic map (N => N_tb)
 port map
 (
  CLK => CLK_tb, RST_B => RST_B_tb, CMD => CMD_tb,
  NSR => NSR_tb, DIN => DIN_tb, DOUT => DOUT_tb
 );
 
 horloge : process(CLK_tb)
 begin
  CLK_tb <= not CLK_tb after duree;
 end process horloge;
 
 --CLK_tb <= not CLK_tb after duree; -- horloge
 RST_B_tb <= '1', '0' after 2*duree, '1' after 8*duree;  -- test le reset
 
 
test: process  -- vérification des opération
begin
 -- vérifie le load
 if CLK_tb= '0' and CLK_tb'event then     -- affecte l'entrée dans les registre au flanc descendant
  CMD_tb <= LOAD;                              
  reg_vect_tb := DIN_tb; wait for 3*duree;  
  if RST_B_tb = '1' then                 -- vérifie qu'on ne fasse pas reset (pas forcément nécessaire)
   assert DOUT_tb = reg_vect_tb report "erreur sur LOAD" severity ERROR; -- p 57 cours
  end if;       -- si DOUT_tb est diff de reg_vect_tb on signal une erreur
 end if;
 
 -- vérifie le shll
 if CLK_tb= '0' and CLK_tb'event then
  CMD_tb <= SHLL;
  reg_vect_tb := DOUT_tb; wait for 3*duree;
  if RST_B_tb = '1' then
   assert DOUT_tb = reg_vect_tb sll NSR_tb report "erreur sur SHLL" severity ERROR;
  end if;
 end if;
 
 if CLK_tb= '0' and CLK_tb'event then
  CMD_tb <= SHRL;
  reg_vect_tb := DOUT_tb; wait for 3*duree;
  if RST_B_tb = '1' then
   assert DOUT_tb = reg_vect_tb srl NSR_tb report "erreur sur SHRL" severity ERROR;
  end if;
 end if;
 
 if CLK_tb= '0' and CLK_tb'event then
  CMD_tb <= SHLA;
  reg_vect_tb := DOUT_tb; wait for 3*duree;
  if RST_B_tb = '1' then
   assert DOUT_tb = reg_vect_tb sla NSR_tb report "erreur sur SHLA" severity ERROR;
  end if;
 end if;
 
 if CLK_tb= '0' and CLK_tb'event then
  CMD_tb <= SHRA;
  reg_vect_tb := DOUT_tb; wait for 3*duree;
  if RST_B_tb = '1' then
   assert DOUT_tb = reg_vect_tb sra NSR_tb report "erreur sur SHRA" severity ERROR;
  end if;
 end if;
 
 if CLK_tb= '0' and CLK_tb'event then
  CMD_tb <= ROTL;
  reg_vect_tb := DOUT_tb; wait for 3*duree;
  if RST_B_tb = '1' then
   assert DOUT_tb = reg_vect_tb rol NSR_tb report "erreur sur ROTL" severity ERROR;
  end if;
 end if;
 
 if CLK_tb= '0' and CLK_tb'event then
  CMD_tb <= ROTR;
  reg_vect_tb := DOUT_tb; wait for 3*duree;
  if RST_B_tb = '1' then
   assert DOUT_tb = reg_vect_tb ror NSR_tb report "erreur sur ROTR" severity ERROR;
  end if;
 end if;
 
end process test;
 
 
 NSR_test : process  -- teste diff valeur de NSR
 begin
  wait for 2*duree; NSR_tb <= 2;
  wait for 4*duree; NSR_tb <= 1;
 end process NSR_test;
 
end architecture bench;
 
 
Voilà j'espère que c'est compréhensible...
 
Merci !