Td tp corrigé exercices vhdl langage de description vhdl par
Télécharger PDFTD/TP Langage de description VHDL : Corrigé Partie N°2
Ce document présente une série d'exercices corrigés en VHDL, couvrant des concepts fondamentaux tels que les compteurs, les fonctions, les boucles et les additionneurs. Chaque exercice inclut le code VHDL correspondant, accompagné d'explications pour une meilleure compréhension des principes de description matérielle.
Exercice N°1 : Compteur simple
Cet exercice propose l'implémentation d'un compteur simple en VHDL. Il s'agit d'un compteur asynchrone pour deux bits (q0 et q1), où le basculement est déclenché par le front montant de l'horloge.
ENTITY cmpt IS
PORT (
clk: IN BIT;
q0,q1: INOUT BIT
);
END cmpt;
ARCHITECTURE acmpt OF cmpt IS
BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
q0 <= NOT q0;
q1 <= q0 XOR q1;
END IF;
END PROCESS;
END acmpt;
Dans ce code VHDL, la condition clk'EVENT AND clk='1' est utilisée pour détecter un front montant du signal d'horloge clk. À chaque front montant, le bit q0 est inversé, et le bit q1 est mis à jour par une opération XOR avec q0. Ce comportement crée une séquence de comptage binaire.
Exercice N°2 : Calcul Factoriel
Cet exercice démontre l'utilisation d'une fonction en VHDL pour calculer la factorielle d'un nombre entier. La fonction funfact est intégrée dans l'architecture de l'entité.
LIBRARY ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.std_logic_unsigned.all;
entity fact is
port (
x : in integer range 0 to 255;
F : out integer
);
end fact;
architecture arch_fact of fact is
function funfact (e : in integer) return integer is
variable FF: integer;
begin
FF:=e;
For i in 1 to e-1 loop
FF:=FF*(e-i);
End loop;
return FF;
end funfact;
begin
F<=funfact(x);
End arch_fact;
La fonction funfact calcule la factorielle de l'entrée e à l'aide d'une boucle For. La variable FF est initialisée avec la valeur de e, puis multipliée de manière itérative par les nombres entiers inférieurs jusqu'à 1. Le résultat final est affecté au port de sortie F.
Exercice N°3 : Compteur contenant une fonction
Cet exercice présente un compteur 4 bits dont la logique d'incrémentation est encapsulée dans une fonction VHDL. La fonction funcompt gère l'addition binaire avec propagation de retenue pour incrémenter la valeur du compteur.
LIBRARY ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.std_logic_unsigned.all;
ENTITY cmpt4b IS
PORT (
clk: IN BIT;
Q: INOUT BIT_VECTOR(3 downto 0)
);
END cmpt4b;
ARCHITECTURE acmpt OF cmpt4b IS
function funcompt (e : in bit_vector) return bit_vector is
variable s : bit_vector(e'left downto 0);
variable c : bit;
begin
c := e(0);
s(0) := not c;
for i in 1 to e'left loop
s(i) := c xor e(i);
c := c and e(i);
end loop;
return s;
end funcompt;
BEGIN
PROCESS (clk)
BEGIN
IF (clk'EVENT AND clk='1') THEN
Q <= funcompt(Q);
END IF;
END PROCESS;
END acmpt;
La fonction funcompt simule l'incrémentation d'un nombre binaire. Elle prend un bit_vector en entrée et retourne le bit_vector incrémenté. La variable c gère la retenue (carry) qui est propagée à travers les bits du vecteur, permettant ainsi un comptage binaire cohérent.
Exercice N°4 : Boucle et variables de boucle
Cet exercice illustre l'utilisation de boucles au sein d'un processus VHDL pour appliquer une logique à chaque bit d'un vecteur d'entrée. Il s'agit d'un codeur ou d'un transformateur de signal.
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity cod is
port (
A : in std_logic_vector(3 downto 0);
S : out std_logic_vector(3 downto 0)
);
end cod;
architecture desc of cod is
begin
process (A)
begin
for i in 0 to A'left loop
if (i=0) then
s(0)<=A(0);
else
s(i)<=(a(i) and a(i-1)) or (not a(i)and not a(i-1));
end if;
end loop;
end process;
end desc;
Dans ce processus sensible au signal A, une boucle for parcourt chaque bit du vecteur d'entrée A. Pour le premier bit (i=0), la sortie S(0) est directement égale à A(0). Pour les bits suivants, S(i) est calculé comme la fonction XNOR entre A(i) et A(i-1). Cela signifie que S(i) sera '1' si les bits adjacents A(i) et A(i-1) sont identiques, et '0' s'ils sont différents.
Exercice N°5 : Notion de variable
Bien que le code spécifique pour cet exercice ne soit pas fourni, cette section aborde la notion fondamentale de variables en VHDL. Les variables sont des éléments de stockage de données qui sont déclarés et utilisés au sein d'un processus, d'une fonction ou d'une procédure. Contrairement aux signaux, les affectations aux variables sont immédiates et ne sont pas soumises aux délais de propagation. Elles sont particulièrement utiles pour des calculs intermédiaires complexes, améliorant la clarté et l'efficacité du code séquentiel.
Exercice N°6 : Construction d'un additionneur 4 bits
Cet exercice illustre la conception d'un additionneur binaire à propagation de retenue (ripple-carry adder) de 4 bits. Il est structuré en deux parties : l'implémentation d'un bloc d'additionneur complet et son assemblage pour former un additionneur de 4 bits.
Additionneur Complet (bloc élémentaire)
Ce bloc représente un additionneur complet capable de sommer trois bits d'entrée (deux opérandes et une retenue entrante) pour produire un bit de somme et une retenue sortante.
LIBRARY ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.std_logic_unsigned.all;
entity Full_Adder_Block is -- Renommé de 'demi_add' pour plus de clarté
port (
x,y, cin : in std_logic;
s,cout : out std_logic
);
end Full_Adder_Block;
architecture arch_fulladder_block of Full_Adder_Block is
signal resultat: unsigned(1 downto 0);
begin
resultat<=('0' & x)+('0' & y)+('0' & cin);
s<=resultat(0);
cout<=resultat(1);
end arch_fulladder_block;
L'entité Full_Adder_Block calcule la somme arithmétique de x, y et cin. La concaténation avec '0' et la conversion en unsigned permettent d'effectuer l'addition binaire. Le bit de poids faible du resultat est la somme s, et le bit de poids fort est la retenue cout.
Additionneur 4 bits (assemblage)
Cette section montre comment interconnceter plusieurs blocs d'additionneurs complets pour construire un additionneur de plus grande taille, ici un additionneur capable de sommer deux nombres de 4 bits.
LIBRARY ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
use ieee.std_logic_unsigned.all;
entity Full_add is
port (
a,b: in unsigned(3 downto 0);
Som: out unsigned(3 downto 0);
Ret: out std_logic
);
end Full_add;
architecture arch_fulladd of Full_add is
component Full_Adder_Block -- Utilisation du composant renommé
port (
x,y, cin : in std_logic;
s,cout : out std_logic
);
end component;
signal c: unsigned(2 downto 0);
begin
add0: Full_Adder_Block port map ( x=>a(0),y=>b(0),cin=>'0',s=>Som(0),cout=>c(0));
add1: Full_Adder_Block port map ( x=>a(1),y=>b(1),cin=>c(0),s=>Som(1),cout=>c(1));
add2: Full_Adder_Block port map ( x=>a(2),y=>b(2),cin=>c(1),s=>Som(2),cout=>c(2));
add3: Full_Adder_Block port map ( x=>a(3),y=>b(3),cin=>c(2),s=>Som(3),cout=>Ret);
end arch_fulladd;
L'entité Full_add implémente un additionneur 4 bits en instanciant quatre blocs Full_Adder_Block. Les retenues (cout) de chaque bloc sont connectées aux entrées de retenue (cin) du bloc suivant, créant ainsi une cascade. La retenue finale de l'additionneur 4 bits est la retenue sortante du dernier bloc, désignée par Ret.
Foire Aux Questions (FAQ)
Qu'est-ce que le VHDL et à quoi sert-il ?
VHDL (VHSIC Hardware Description Language) est un langage de description matérielle standardisé utilisé pour modéliser le comportement et la structure des circuits électroniques numériques. Il permet aux ingénieurs de concevoir, simuler et synthétiser des systèmes numériques complexes, des simples portes logiques aux microprocesseurs entiers, avant leur fabrication physique.
Quelle est la distinction principale entre un signal et une variable en VHDL ?
En VHDL, un signal est utilisé pour modéliser des interconnexions physiques et ses affectations sont planifiées pour un futur immédiat ou différé, reflétant les délais de propagation réels. Une variable, en revanche, est un élément de stockage temporaire qui existe uniquement au sein d'un processus, d'une fonction ou d'une procédure. Ses affectations sont instantanées et n'introduisent pas de délai, ce qui la rend idéale pour les calculs intermédiaires.
Comment un front montant d'horloge est-il détecté en VHDL ?
Pour détecter un front montant (un passage de '0' à '1') d'un signal d'horloge (par exemple clk) en VHDL, la méthode courante consiste à utiliser la construction IF (clk'EVENT AND clk = '1') THEN à l'intérieur d'un processus dont la liste de sensibilité inclut clk. clk'EVENT vérifie si un changement d'état s'est produit sur le signal, et clk = '1' confirme que l'état actuel est le niveau haut.