République Tunisienne
Ministère de l’enseignement Supérieur, Et la Recherche Scientifique
4 éme génie Electrique et Automatique
Conception des circuit et système numérique sur
plateforme reconfigurable
Élaboré par :
BACEM ZAGOUB
Enseignante :
SABER JEMMALI
Année universitaire : 2024 / 2025
Port logique OR :
Code VHDL - Implémentation de la fonction OR :
Code VHDL - Banc de Test (Testbench) :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity OR_Gate_TB is
-- Pas de ports pour le testbench
end OR_Gate_TB;
architecture Behavioral of OR_Gate_TB is
-- Signaux pour simuler les entrées et la sortie
signal A : STD_LOGIC := '0';
signal B : STD_LOGIC := '0';
signal Y : STD_LOGIC;
begin
-- Instanciation de l'entité à tester
UUT: entity work.OR_Gate
Port map (
A => A,
B => B,
Y => Y
);
-- Processus de simulation
process
begin
-- Cas 1 : A = 0, B = 0
A <= '0'; B <= '0';
wait for 100 ns;
-- Cas 2 : A = 0, B = 1
A <= '0'; B <= '1';
wait for 100 ns;
-- Cas 3 : A = 1, B = 0
A <= '1'; B <= '0';
wait for 100 ns;
-- Cas 4 : A = 1, B = 1
A <= '1'; B <= '1';
wait for 100 ns;
-- Fin de la simulation
wait;
end process;
end Behavioral;
Explications :
1. Entity OR_Gate :
o Implémente une porte logique OR avec deux entrées (A et B) et une sortie (Y).
o L'expression Y <= A or B; applique la fonction logique OR.
2. Testbench OR_Gate_TB :
o Génère toutes les combinaisons possibles pour les entrées A et B.
o Vérifie que la sortie Y correspond bien à la table de vérité de la fonction OR.
Table de Vérité de OR :
A B Y (A OR B)
0 0 0
0 1 1
1 0 1
1 1 1
Simulation :
1. Compilation : Compilez les fichiers OR_Gate.vhd et OR_Gate_TB.vhd dans un
simulateur VHDL (par exemple, ModelSim ou GHDL).
2. Exécution : Lancez la simulation pour observer les résultats de la sortie Y pour chaque
combinaison des entrées A et B.
Cela garantit que la porte logique OR fonctionne correctement.
Résultat :
Port logique AND :
Code VHDL - Implémentation de la fonction AND :
Code VHDL - Banc de Test (Testbench) :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity AND_Gate_TB is
-- Pas de ports dans un testbench
end AND_Gate_TB;
architecture Behavioral of AND_Gate_TB is
-- Signaux pour simuler les entrées et la sortie
signal A : STD_LOGIC := '0';
signal B : STD_LOGIC := '0';
signal Y : STD_LOGIC;
begin
-- Instanciation de l'entité à tester
UUT: entity work.AND_Gate
Port map (
A => A,
B => B,
Y => Y
);
-- Processus de simulation
process
begin
-- Cas 1 : A = 0, B = 0
A <= '0'; B <= '0';
wait for 100 ns;
-- Cas 2 : A = 0, B = 1
A <= '0'; B <= '1';
wait for 100 ns;
-- Cas 3 : A = 1, B = 0
A <= '1'; B <= '0';
wait for 100 ns;
-- Cas 4 : A = 1, B = 1
A <= '1'; B <= '1';
wait for 100 ns;
-- Fin de la simulation
end process;
end Behavioral;
Explications :
1. Entity AND_Gate :
o L'entité AND_Gate représente une porte logique AND simple.
o Les entrées sont A et B, et la sortie est Y.
2. Testbench AND_Gate_TB :
o Instancie l'entité AND_Gate pour effectuer les tests.
o Simule toutes les combinaisons possibles des entrées A et B pour valider que la
sortie Y correspond à la table de vérité de la porte AND.
Table de Vérité de AND :
A B Y (A AND B)
0 0 0
0 1 0
1 0 0
1 1 1
Simulation :
1. Compilation : Compilez les fichiers AND_Gate.vhd et AND_Gate_TB.vhd dans un
simulateur VHDL comme ModelSim ou GHDL.
2. Exécution : Lancez la simulation pour visualiser les résultats de la sortie Y
correspondant à chaque combinaison des entrées.
Cela permet de valider que la porte AND fonctionne comme prévu.
Résultat :
Port logique XOR :
Code VHDL - Implémentation de la fonction XOR :
Code VHDL - Banc de Test (Testbench) :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity XOR_Gate_TB is
-- Pas de ports dans un testbench.
end XOR_Gate_TB;
architecture Behavioral of XOR_Gate_TB is
-- Signaux pour simuler les entrées et la sortie
signal A : STD_LOGIC := '0';
signal B : STD_LOGIC := '0';
signal Y : STD_LOGIC;
begin
-- Instanciation de l'entité à tester
UUT: entity work.XOR_Gate
Port map (
A => A,
B => B,
Y => Y
);
-- Processus de simulation
process
begin
-- Cas 1 : A = 0, B = 0
A <= '0'; B <= '0';
wait for 100 ns;
-- Cas 2 : A = 0, B = 1
A <= '0'; B <= '1';
wait for 100 ns;
-- Cas 3 : A = 1, B = 0
A <= '1'; B <= '0';
wait for 100 ns;
-- Cas 4 : A = 1, B = 1
A <= '1'; B <= '1';
wait for 100 ns;
-- Fin du test
end process;
end Behavioral;
Explications :
1. Entity XOR_Gate :
o L'entité XOR_Gate implémente une fonction XOR simple avec deux entrées A et B
et une sortie Y.
2. Testbench XOR_Gate_TB :
o Ce banc de test génère toutes les combinaisons possibles des entrées (A et B).
o Les résultats sont évalués pour vérifier que la sortie Y correspond à la table de
vérité de la porte XOR.
Table de Vérité de XOR :
A B Y (A XOR B)
0 0 0
0 1 1
1 0 1
1 1 0
Simulation :
1. Compilation : Compilez les deux fichiers (XOR_Gate.vhd et XOR_Gate_TB.vhd) dans un
simulateur VHDL comme ModelSim ou GHDL.
2. Exécution : Simulez le testbench pour observer les valeurs de sortie Y correspondant
aux différentes combinaisons de A et B.
Cela permet de vérifier si le composant XOR fonctionne correctement.
Résultat :
Circuit - Demi-Additionneur :
Code VHDL - Demi-Additionneur :
Code VHDL - Banc de Test (Testbench) :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity Half_Adder_TB is
-- Pas de ports dans le testbench
end Half_Adder_TB;
architecture Behavioral of Half_Adder_TB is
-- Déclaration des signaux pour les entrées et sorties
signal A : STD_LOGIC := '0';
signal B : STD_LOGIC := '0';
signal SUM : STD_LOGIC;
signal CARRY : STD_LOGIC;
begin
-- Instanciation de l'entité à tester
UUT: entity work.Half_Adder
Port map (
A => A,
B => B,
SUM => SUM,
CARRY => CARRY
);
-- Processus de simulation
process
begin
-- Cas 1 : A = 0, B = 0
A <= '0'; B <= '0';
wait for 100 ns;
-- Cas 2 : A = 0, B = 1
A <= '0'; B <= '1';
wait for 100 ns;
-- Cas 3 : A = 1, B = 0
A <= '1'; B <= '0';
wait for 100 ns;
-- Cas 4 : A = 1, B = 1
A <= '1'; B <= '1';
wait for 100 ns;
end process;
end Behavioral;
Explications :
1. Entity Half_Adder :
o L'entité Half_Adder implémente la logique d'un demi-additionneur.
o La sortie SUM correspond à A XOR B (somme sans retenue).
o La sortie CARRY correspond à A AND B (retenue générée).
2. Testbench Half_Adder_TB :
o Simule toutes les combinaisons possibles des entrées A et B.
o Vérifie que les sorties SUM et CARRY correspondent à la table de vérité d'un
demi-additionneur.
Table de Vérité - Demi-Additionneur :
A B SUM (A XOR B) CARRY (A AND B)
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1
Simulation :
1. Compilation : Compilez les fichiers Half_Adder.vhd et Half_Adder_TB.vhd dans un
simulateur VHDL comme ModelSim ou GHDL.
2. Exécution : Lancez la simulation pour visualiser les valeurs de SUM et CARRY
correspondant à chaque combinaison de A et B.
Ce test garantit que le demi-additionneur fonctionne correctement.
Résultat :
Circuit - Additionneur Complet :
Code VHDL - Additionneur Complet :
Code VHDL - Banc de Test (Testbench) :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity Full_Adder_TB is
-- Pas de ports pour le testbench
end Full_Adder_TB;
architecture Behavioral of Full_Adder_TB is
-- Signaux pour les entrées et sorties
signal A : STD_LOGIC := '0';
signal B : STD_LOGIC := '0';
signal Cin : STD_LOGIC := '0';
signal Sum : STD_LOGIC;
signal Cout : STD_LOGIC;
begin
-- Instanciation de l'entité à tester
UUT: entity work.Full_Adder
Port map (
A => A,
B => B,
Cin => Cin,
Sum => Sum,
Cout => Cout
);
-- Processus de simulation
process
begin
-- Cas 1 : A = 0, B = 0, Cin = 0
A <= '0'; B <= '0'; Cin <= '0';
wait for 100 ns;
-- Cas 2 : A = 0, B = 0, Cin = 1
A <= '0'; B <= '0'; Cin <= '1';
wait for 100 ns;
-- Cas 3 : A = 0, B = 1, Cin = 0
A <= '0'; B <= '1'; Cin <= '0';
wait for 100 ns;
-- Cas 4 : A = 0, B = 1, Cin = 1
A <= '0'; B <= '1'; Cin <= '1';
wait for 100 ns;
-- Cas 5 : A = 1, B = 0, Cin = 0
A <= '1'; B <= '0'; Cin <= '0';
wait for 100 ns;
-- Cas 6 : A = 1, B = 0, Cin = 1
A <= '1'; B <= '0'; Cin <= '1';
wait for 100 ns;
-- Cas 7 : A = 1, B = 1, Cin = 0
A <= '1'; B <= '1'; Cin <= '0';
wait for 100 ns;
-- Cas 8 : A = 1, B = 1, Cin = 1
A <= '1'; B <= '1'; Cin <= '1';
wait for 100 ns;
-- Fin de la simulation
end process;
end Behavioral;
Explications :
1. Entity Full_Adder :
o Implémente un additionneur complet avec :
▪ Entrées A, B, et Cin (Carry In).
▪ Sorties Sum (somme) et Cout (Carry Out).
2. Testbench Full_Adder_TB :
o Simule toutes les combinaisons possibles des entrées A, B, et Cin.
o Vérifie que les sorties Sum et Cout correspondent aux attentes.
Table de Vérité - Additionneur Complet :
A B Cin Sum Cout
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1
Simulation :
1. Compilation : Compilez les fichiers Full_Adder.vhd et Full_Adder_TB.vhd dans un
simulateur VHDL comme ModelSim ou GHDL.
2. Exécution : Lancez la simulation pour observer les résultats des sorties Sum et Cout
pour chaque combinaison des entrées.
Cela garantit que l'additionneur complet fonctionne comme prévu
Bascule D :
Code VHDL - Bascule D :
Code VHDL - Banc de Test (Testbench) :
library ieee;
use ieee.std_logic_1164.all;
entity testbench is
end entity testbench;
architecture arch_test of testbench is
-- Déclaration du composant
component bascule_d is
port (
clk : in std_logic;
rest : in std_logic;
D : in std_logic;
q : out std_logic;
q_bar : out std_logic
);
end component;
-- Signaux pour connecter au composant
signal t_clk : std_logic := '0';
signal t_rest : std_logic := '1';
signal t_D : std_logic := '0';
signal t_q : std_logic;
signal t_q_bar : std_logic;
begin
-- Instanciation de la bascule D
UUT: bascule_d
port map (
clk => t_clk,
rest => t_rest,
D => t_D,
q => t_q,
q_bar => t_q_bar
);
-- Génération de l'horloge (10 ns de période, 50% duty cycle)
t_clk_process: process
begin
while true loop
t_clk <= '0';
wait for 5 ns;
t_clk <= '1';
wait for 5 ns;
end loop;
end process t_clk_process;
-- Génération du signal de réinitialisation
rest_process: process
begin
t_rest <= '1'; -- Réinitialisation active
wait for 12 ns;
t_rest <= '0'; -- Réinitialisation désactivée
wait for 2 ns;
t_rest <= '1'; -- Réinitialisation active à nouveau
wait for 50 ns; -- Attendre avant la fin
wait; -- Fin de simulation
end process rest_process;
-- Génération des stimuli pour D
stim_process: process
begin
t_D <= '0';
wait for 20 ns;
t_D <= '1';
wait for 20 ns;
t_D <= '0';
wait for 20 ns;
t_D <= '1';
wait for 20 ns;
wait; -- Fin de simulation
end process stim_process;
end architecture arch_test;
Points importants :
1. Horloge : La génération de l'horloge est définie dans un processus dédié avec
une période de 10 ns (par défaut 50% duty cycle).
2. Stimuli des entrées : Les processus rest_process et stim_process génèrent des
scénarios pour tester la réponse de la bascule à différentes combinaisons de D
et rest.
3. Portabilité : Ce testbench est générique et peut être utilisé pour tester n'importe
quelle implémentation de la bascule D compatible avec la déclaration de ports.
Compteur :
Code VHDL – compteur :
Code VHDL - Banc de Test (Testbench) :
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity testbench_compteur_4 is
end entity testbench_compteur_4;
architecture tb_arch of testbench_compteur_4 is
-- Déclaration du composant compteur_4
component compteur_4 is
generic (
Count_taille : integer := 5; -- Taille du compteur
Count_max : integer := 32 -- Valeur maximale du compteur
);
port (
clk : in std_logic;
reset : in std_logic;
en_in : in std_logic;
reset_count : in std_logic;
end_pulse_Count_out : out std_logic;
Count_out : out std_logic_vector((Count_taille - 1) downto 0)
);
end component;
-- Déclaration des signaux de test
signal t_clk : std_logic := '0';
signal t_reset : std_logic := '0';
signal t_en_in : std_logic := '0';
signal t_reset_count : std_logic := '0';
signal t_pulse : std_logic;
signal t_count_out : std_logic_vector(4 downto 0); -- Taille 5 bits
begin
-- Instanciation du compteur
UUT: compteur_4
generic map (
Count_taille => 5,
Count_max => 32
)
port map (
clk => t_clk,
reset => t_reset,
en_in => t_en_in,
reset_count => t_reset_count,
end_pulse_Count_out => t_pulse,
Count_out => t_count_out
);
-- Génération de l'horloge
clk_process: process
begin
while true loop
t_clk <= '0';
wait for 10 ns; -- Période basse
t_clk <= '1';
wait for 10 ns; -- Période haute
end loop;
end process;
-- Génération du signal reset
reset_process: process
begin
t_reset <= '1'; -- Activation du reset
wait for 25 ns;
t_reset <= '0'; -- Désactivation
end process;
-- Génération du signal enable (en_in)
enable_process: process
begin
wait for 50 ns;
t_en_in <= '1'; -- Activation de l'incrémentation
wait for 300 ns;
t_en_in <= '0'; -- Désactivation
wait;
end process;
-- Génération du signal reset_count
reset_count_process: process
begin
wait for 150 ns;
t_reset_count <= '1'; -- Remise à zéro du compteur
wait for 20 ns;
t_reset_count <= '0';
wait;
end process;
end architecture tb_arch;
Description du Testbench
➢ Horloge (t_clk) :
o Une horloge avec une période de 20 ns est générée dans un processus
dédié.
➢ Reset (t_reset) :
o Active le signal reset au début de la simulation pendant 25 ns pour
réinitialiser le compteur.
➢ Enable (t_en_in) :
o Active le signal en_in après 50 ns pour permettre l'incrémentation du
compteur.
➢ Reset spécifique (t_reset_count) :
o Active le signal reset_count à 150 ns pour tester la remise à zéro partielle
du compteur.
➢ Simulation des sorties :
o t_count_out affiche la valeur actuelle du compteur.
o t_pulse vérifie que l'impulsion de fin est générée correctement lorsque le
compteur atteint sa valeur maximale.
Instructions pour la simulation
➢ Compilation :
o Compilez le fichier contenant le design du compteur suivi de ce testbench
dans un simulateur VHDL.
➢ Simulation :
o Lancez la simulation et observez les signaux dans une fenêtre d'ondes
(waveform).
➢ Vérifications :
o Le compteur doit s'incrémenter correctement lorsque en_in est actif.
o Les signaux reset et reset_count doivent remettre le compteur à zéro.
o end_pulse_Count_out doit être activé à la dernière valeur du compteur.
Multiplexeur 4 vers 1 :
Code VHDL Multiplexeur 4 vers 1 :
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity mux4to1 is
port (
a, b, c, d : in std_logic_vector(3 downto 0);
sel : in std_logic_vector(1 downto 0);
s : out std_logic_vector(3 downto 0)
);
end entity mux4to1;
architecture arch of mux4to1 is
begin
process(a, b, c, d, sel)
begin
case sel is
when "00" =>
s <= a;
when "01" =>
s <= b;
when "10" =>
s <= c;
when "11" =>
s <= d;
when others =>
s <= (others => '0');
end case;
end process;
end architecture arch;
Code VHDL - Banc de Test (Testbench) :
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity ts_mux4to1 is
end entity ts_mux4to1;
architecture test_bench of ts_mux4to1 is
-- Composant du multiplexeur
component mux4to1 is
port (
a, b, c, d : in std_logic_vector(3 downto 0);
sel : in std_logic_vector(1 downto 0);
s : out std_logic_vector(3 downto 0)
);
end component;
-- Signaux pour le test
signal t_a, t_b, t_c, t_d : std_logic_vector(3 downto 0);
signal t_sel : std_logic_vector(1 downto 0);
signal t_s : std_logic_vector(3 downto 0);
begin
-- Instanciation du multiplexeur
UUT: mux4to1
port map (
a => t_a,
b => t_b,
c => t_c,
d => t_d,
sel => t_sel,
s => t_s
);
-- Génération des stimuli pour le test
process
begin
-- Initialisation des entrées
t_a <= "0001";
t_b <= "0010";
t_c <= "0100";
t_d <= "1000";
-- Sélection des différentes entrées
t_sel <= "00";
wait for 100 ns;
t_sel <= "01";
wait for 100 ns;
t_sel <= "10";
wait for 100 ns;
t_sel <= "11";
wait for 100 ns;
-- Fin de simulation
wait;
end process;
end architecture test_bench;
Explications :
1. Entité mux4to1 :
o Le multiplexeur a 4 entrées (a, b, c, d) de 4 bits chacune.
o Une entrée de sélection (sel) à 2 bits pour choisir l'une des 4 entrées.
o Une sortie (s) qui correspond à l'entrée sélectionnée.
2. Testbench :
o Les signaux t_a, t_b, t_c, et t_d sont initialisés avec différentes valeurs
binaires.
o La sélection (t_sel) change toutes les 100 ns pour tester les différentes
entrées.
o La sortie (t_s) doit refléter l'entrée correspondant à la valeur de t_sel.
3. Simulation :
o Lorsque vous simulez ce testbench, vous devriez observer les valeurs de
t_s changer en fonction de t_sel.
Emission parallèle série
Exercice 1 : Diviseur de fréquence
Code VHDL pour le diviseur de fréquence div_freq
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity div_freq is
generic (
DIV_FR : integer := 500; -- Valeur du diviseur
TAILLE_PULSE : integer := 10; -- Nombre d'impulsions de clk
N : integer := 32 -- Taille du compteur
);
port (
clk : in std_logic; -- Signal d'horloge
reset : in std_logic; -- Reset asynchrone
start_fb: in std_logic; -- Signal de démarrage
out_sig : out std_logic -- Sortie du module
);
end div_freq;
architecture Behavioral of div_freq is
signal compteur : integer range 0 to DIV_FR := 0;
begin
process (clk, reset)
begin
if reset = '1' then
compteur <= 0;
out_sig <= '0';
elsif rising_edge(clk) then
if start_fb = '1' then
if compteur = (DIV_FR - TAILLE_PULSE) then
out_sig <= '1';
compteur <= compteur + 1;
elsif compteur = DIV_FR then
out_sig <= '0';
compteur <= 0;
else
compteur <= compteur + 1;
end if;
end if;
end if;
end process;
end Behavioral;
Code VHDL - Banc de Test (Testbench) :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity tb_div_freq is
end tb_div_freq;
architecture Behavioral of tb_div_freq is
signal clk : std_logic := '0';
signal reset : std_logic := '0';
signal start_fb: std_logic := '0';
signal out_sig : std_logic;
constant clk_period : time := 10 ns; -- Période d'horloge
begin
-- Instanciation du module à tester
UUT: entity work.div_freq
generic map (DIV_FR => 500, TAILLE_PULSE => 10, N => 32)
port map (
clk => clk,
reset => reset,
start_fb => start_fb,
out_sig => out_sig
);
-- Génération de l'horloge
clk_process: process
begin
clk <= '0';
wait for clk_period / 2;
clk <= '1';
wait for clk_period / 2;
end process;
-- Stimulus de test
stimulus: process
begin
-- Initialisation
reset <= '1';
wait for 100 ns;
reset <= '0';
-- Activer le signal start_fb
start_fb <= '1';
wait for 100 ns; -- Laissez le module fonctionner
-- Désactiver start_fb
start_fb <= '0';
wait for 100 ns;
-- Réactiver start_fb
start_fb <= '1';
wait for 100 ns;
end process;
end Behavioral;
Explication des étapes dans le testbench
1. Initialisation :
o Un reset asynchrone (reset = '1') est appliqué au début de la simulation pour
s'assurer que tous les signaux internes sont initialisés correctement.
o start_fb est maintenu à '0' pendant cette phase pour empêcher le compteur de
s'incrémenter.
2. Activation de start_fb :
o start_fb est activé ('1') pour permettre au compteur de commencer son
incrémentation.
o La simulation laisse le compteur fonctionner suffisamment longtemps (5000 ns)
pour observer plusieurs cycles complets.
3. Désactivation de start_fb :
o En mettant start_fb à '0', on vérifie que le compteur s'arrête et que out_sig revient
à '0'.
4. Réactivation de start_fb :
o Le signal est réactivé pour tester à nouveau le comportement du module.
5. Horloge :
o Le processus clk_process génère un signal d'horloge avec une période de 10 ns.
Résultats attendus
➢ Lorsque start_fb est à '1', le signal out_sig doit passer à '1' pendant la durée définie par
TAILLE_PULSE et revenir à '0' après chaque cycle complet de DIV_FR.
➢ Lorsque reset est activé, le compteur doit être remis à zéro immédiatement, et la sortie
out_sig doit être '0'.
➢ Lorsque start_fb est à '0', le compteur doit cesser de s'incrémenter, et la sortie doit rester
à '0'.
Simulation
Chargez ce testbench dans un simulateur VHDL (comme ModelSim, GHDL, ou Xilinx Vivado), et
observez les signaux out_sig, compteur, et start_fb pour valider que le module fonctionne
comme prévu.
Exercice 2 : Compteur de bits count_bit :
Code VHDL pour le compteur count_bit
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL; -- Remplace std_logic_arith et std_logic_unsigned
entity count_bit is
port (
clk_bit : in std_logic; -- Signal d'horloge
reset : in std_logic; -- Reset asynchrone
end_fb : out std_logic; -- Signal indiquant la fin du comptage
sel : out std_logic_vector(3 downto 0) -- Sortie du compteur
);
end count_bit;
architecture Behavioral of count_bit is
signal compteur : integer range 0 to 11 := 0; -- Compteur interne
begin
process (clk_bit, reset)
begin
if reset = '1' then
compteur <= 0; -- Réinitialisation du compteur
end_fb <= '0'; -- Réinitialisation du signal de fin
elsif rising_edge(clk_bit) then
if compteur = 11 then
compteur <= 0; -- Remise à zéro du compteur
end_fb <= '1'; -- Activation du signal de fin
else
compteur <= compteur + 1; -- Incrémentation du compteur
end_fb <= '0'; -- Désactivation du signal de fin
end if;
end if;
end process;
-- Conversion du compteur en vecteur de 4 bits
sel <= std_logic_vector(to_unsigned(compteur, 4));
end Behavioral;
Testbench pour count_bit
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL; -- Utilisé pour les conversions nécessaires
entity tb_count_bit is
end tb_count_bit;
architecture Behavioral of tb_count_bit is
-- Signaux de test pour connecter au module `count_bit`
signal clk_bit : std_logic := '0'; -- Signal d'horloge
signal reset : std_logic := '0'; -- Signal de reset asynchrone
signal end_fb : std_logic; -- Signal indiquant la fin du comptage
signal sel : std_logic_vector(3 downto 0); -- Sortie du compteur
-- Constante pour définir la période de l'horloge
constant clk_period : time := 10 ns; -- Période de l'horloge
begin
-- Instanciation du module `count_bit` (Device Under Test)
UUT: entity work.count_bit
port map (
clk_bit => clk_bit,
reset => reset,
end_fb => end_fb,
sel => sel
);
-- Processus pour générer le signal d'horloge
clk_process: process
begin
while true loop
clk_bit <= '0';
wait for clk_period / 2;
clk_bit <= '1';
wait for clk_period / 2;
end loop;
end process;
-- Processus de génération des stimuli
stimulus_process: process
begin
-- Étape 1 : Initialisation avec reset actif
reset <= '1'; -- Activer le reset
wait for 100 ns; -- Attendre un moment
reset <= '0'; -- Désactiver le reset
-- Étape 2 : Permettre au compteur de fonctionner normalement
wait for 100 ns; -- Permettre au compteur d'atteindre 11
-- Étape 3 : Réinitialisation au milieu de la simulation
reset <= '1'; -- Activer le reset
wait for 100 ns; -- Attendre un moment
reset <= '0'; -- Désactiver le reset
-- Étape 4 : Poursuivre le comptage
wait for 100 ns;
-- Fin de la simulation
end process;
end Behavioral;
Explications du Testbench :
1. Instanciation du module :
o Le module count_bit est connecté aux signaux définis (clk_bit, reset, end_fb,
sel).
2. Signal d'horloge :
o Un processus génère un signal d'horloge clk_bit avec une période de 10 ns.
3. Scénarios simulés :
o Étape 1 : Activation de reset pour s'assurer que le compteur est réinitialisé.
o Étape 2 : Désactivation de reset et observation du fonctionnement du compteur
jusqu'à ce qu'il atteigne 11.
o Étape 3 : Réactivation de reset pour vérifier que le compteur peut être remis à
zéro à tout moment.
o Étape 4 : Retour au fonctionnement normal après un reset.
4. Observation des sorties :
o La sortie sel doit incrémenter de 0 à 11 (en binaire) puis revenir à 0.
o La sortie end_fb doit passer à '1' uniquement lorsque le compteur atteint 11, et
revenir à '0' pour tous les autres cas.
Résultats attendus :
• reset actif : Le compteur est remis à 0 (sel = "0000" et end_fb = '0').
• Comptage normal : sel incrémente de 0 à 11, et end_fb devient '1' uniquement au
moment où sel = "1011" (11 en binaire).
• Reset au milieu : Après l'activation du reset, le compteur est immédiatement remis à
zéro et recommence à compter à partir de 0.
Exercice 3 : Multiplexeur mux
Code VHDL pour le multiplexeur asynchrone mux :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity mux is
port (
sel : in std_logic_vector(3 downto 0); -- Sélection (4 bits)
data_in : in std_logic_vector(11 downto 0); -- Entrée 12 bits
data_out: out std_logic -- Sortie 1 bit
);
end mux;
architecture Behavioral of mux is
begin
process (sel, data_in)
begin
case sel is
when "0000" => data_out <= data_in(0);
when "0001" => data_out <= data_in(1);
when "0010" => data_out <= data_in(2);
when "0011" => data_out <= data_in(3);
when "0100" => data_out <= data_in(4);
when "0101" => data_out <= data_in(5);
when "0110" => data_out <= data_in(6);
when "0111" => data_out <= data_in(7);
when "1000" => data_out <= data_in(8);
when "1001" => data_out <= data_in(9);
when "1010" => data_out <= data_in(10);
when "1011" => data_out <= data_in(11);
when others => data_out <= '0'; -- Valeur par défaut
end case;
end process;
end Behavioral;
Testbench Complet :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity tb_mux is
end tb_mux;
architecture Behavioral of tb_mux is
-- Signaux de test pour connecter au module `mux`
signal sel : std_logic_vector(3 downto 0); -- Signal de sélection
signal data_in : std_logic_vector(11 downto 0); -- Entrée 12 bits
signal data_out: std_logic; -- Sortie 1 bit
begin
-- Instanciation du module `mux` (Device Under Test)
UUT: entity [Link]
port map (
sel => sel,
data_in => data_in,
data_out => data_out
);
-- Processus de génération des stimuli
stimulus_process: process
begin
-- Initialisation des signaux
data_in <= "101010101010"; -- Exemple de données d'entrée
sel <= "0000"; -- Initialisation de la sélection
wait for 100 ns; -- Attendre pour observer la sortie
-- Test des différentes sélections
sel <= "0001"; wait for 100 ns;
sel <= "0010"; wait for 100 ns;
sel <= "0011"; wait for 100 ns;
sel <= "0100"; wait for 100 ns;
sel <= "0101"; wait for 100 ns;
sel <= "0110"; wait for 100 ns;
sel <= "0111"; wait for 100 ns;
sel <= "1000"; wait for 100 ns;
sel <= "1001"; wait for 100 ns;
sel <= "1010"; wait for 100 ns;
sel <= "1011"; wait for 100 ns;
-- Test d'une sélection invalide
sel <= "1100"; wait for 100 ns;
-- Fin de la simulation
end process;
end Behavioral;
Explications du Testbench
1. Instanciation du module :
o Le module mux est connecté aux signaux définis (sel, data_in, data_out).
2. Stimuli générés :
o La donnée d'entrée data_in est initialisée à un vecteur binaire (101010101010)
pour tester chaque ligne.
o Le signal de sélection sel est modifié pour tester chaque bit de data_in.
o Une sélection invalide (1100) est également testée pour vérifier la gestion du cas
par défaut (data_out doit être '0').
3. Durée d'attente :
o Une pause de 10 ns entre chaque modification de sel permet d'observer
clairement la sortie.
4. Observation des sorties :
o Pour chaque valeur de sel, la sortie data_out doit correspondre au bit
correspondant de data_in.
Résultats attendus
Si data_in = "101010101010", les sorties pour les valeurs de sel sont :
sel (binaire) data_out
0000 1
0001 0
0010 1
0011 0
0100 1
0101 0
0110 1
0111 0
1000 1
1001 0
1010 1
1011 0
1100 (invalide) 0