Ministère de l’Enseignement Supérieur ‫وزارةزالتعليـةزاتعاليزالبحةزاتعلمة‬

et de la Recherche Scientifique ‫ة‬

Université de Carthage
‫جعمتيةةقرطعج‬

Ecole Nationale d’Ingénieurs de Carthage ‫زالداسيةةزايطنلةةاعلهندسلنةبقرطعج‬

Devoir Surveillé Matière : Circuits Programmables et VHDL Année universitaire 2015-2016

Enseignants : Y Lahbib, F Ben Abdallah Date : 05/10/2015

ème
Filière / Classe :2 Mécatronique Durée : 1h30
Barème indicatif : Ex1 :12 points/ Ex2 :8 points Documents : aut. / non aut.
Nbre. de pages : 2 pages Calculatrice : aut. / nonaut.

Exercice1 : Affichage des opérations de décalage

Soit à décrire en VHDL le circuit suivant permettant d’afficher sur un afficheur 7 segments le code hexadécimal de
l’entrée D et son résultat de décalage effectué par le circuit SHIFTER de la figure suivante. Suivant l’entrée de
sélection Sel du multiplexeur (Mux), la sortie Z prend la valeur de D ou de Y. Par la suite le décodeur 7 segments
(Dec7seg) transforme Z en une suite binaire de 7 bits affectée à la sortie CodeHex du décodeur. Cette suite sera
ensuite affichée sur l’afficheur 7 segments. Les noms des signaux ainsi que leurs tailles sont spécifiés dans la figure
ci-dessous. Nous allons vous guider pour décrire ce circuit en VHDL. a

0 f b
Mux 4 bits 7 bits
Décodeur
Circuit de Z 7 segments CodeHex
D 4 bits Y 4 bits g
décalages 1 (Dec7seg)
(SHIFTER) e c
1 bit
Sel
d
3 bits
Fct
1) Décrire en VHDL le circuit multiplexeur, appelé Mux. (1 point )
-- Question1 ----MUX ------------- P1: process(Sel,D,Y)
------------------------------------ begin
library ieee; if(Sel = '1') then
use ieee.std_logic_1164.all; Z <= Y;
entity mux is else
port Z <= D;
( Sel : in std_logic; end if;
D,Y : in std_logic_vector(3 downto 0);
Z: out std_logic_vector(3 downto 0) end process P1;
);
end mux; end comport;
architecture comport of mux is
begin

2) On suppose que le décodeur 7 segment est de type anode commune, c'est-à-dire un 0 Volt sur un segment
permet son allumage et un 5 Volt (1 logique) permet de l’éteindre. On suppose aussi que les segments sont
connectés comme suit :
- Segment a est connecté à CodeHex(0) Exemple : Le code du chiffre 0 (Z = "0000") sera alors décodé à
- Segment b est connecté à CodeHex(1) CodeHex = "1000000". Uniquement le segment g est égal à 1.
- Segment c est connecté à CodeHex(2)
- Segment d est connecté à CodeHex(3) Donner la valeur de la sortie CodeHex du décodeur pour chaque
code des chiffres 0 à F.
1/5
- Segment e est connecté à CodeHex(4)
- Segment f est connecté à CodeHex(5)
- Segment g est connecté à CodeHex(6)

-- Question2 ----Decodeur 7 segments ------------- (1 points )

--------------------------------------------------
-- Decimal Z(3 downto 0) ----- output CodeHex(7 downtot 0)
-- 0 "0000" ----- "1000000"
-- 1 "0001" ----- "1111001"
-- 2 "0010" ----- "0100100"
-- 3 "0011" ----- "0110000"
-- 4 "0100" ----- "0011001"
-- 5 "0101" ----- "0010010"
-- 6 "0110" ----- "0000010"
-- 7 "0111" ----- "1111000"
-- 8 "1000" ----- "0000000"
-- 9 "1001" ----- "0010000"
-- A "1010" ----- "0001000"
---- b "1011" ----- "0000011"
---- C "1100" ----- "1000110"
---- d "1101" ----- "0100001"
---- E "1110" ----- "0000110"
---- F "1111" ----- "0001110"

3) Décrire en VHDL comportemental le décodeur 7 segments, appelé Dec7seg en utilisant un processus et

l’instruction case du VHDL. (1 points)
library ieee; when "0101" => CodeHex <= "0010010"; -- 5
use ieee.std_logic_1164.all; when "0110" => CodeHex <= "0000010"; -- 6
entity Dec7seg is when "0111" => CodeHex <= "1111000"; -- 7
port (Z: in std_logic_vector(3 downto 0); when "1000" => CodeHex <= "0000000"; -- 8
CodeHex : out std_logic_vector(6 downto 0) ); when "1001" => CodeHex <= "0010000"; -- 9
end Dec7seg; when "1010" => CodeHex <= "0001000"; -- A
architecture proce of Dec7seg is when "1011" => CodeHex <= "0000011"; -- b
begin when "1100" => CodeHex <= "1000110"; -- C
P2: process(Z) when "1101" => CodeHex <= "0100001"; -- d
begin when "1110" => CodeHex <= "0000110"; -- E
case Z is when "1111" => CodeHex <= "0001110"; -- E
when "0000" => CodeHex <= "1000000"; -- 0 when others => CodeHex <= "1111111";
when "0001" => CodeHex <= "1111001"; -- 1 end case;
when "0010" => CodeHex <= "0100100"; -- 2 end process P2;
when "0011" => CodeHex <= "0110000"; -- 3 end proce;
when "0100" => CodeHex <= "0011001"; -- 4
4) Le circuit SHIFTER présenté sur la figure ci-dessus permet 5 fonctions de décalage en fonction de l’entrée Fct
codée sur trois bits. Ces 5 fonctions sont résumées dans le tableau ci-dessous.
Entrée Fct(2 downto 0) Valeur de Sortie Y(3 downto 0) en Fonction de décalage réalisée
fonction de l’entrée D(3 downto 0) par le circuit SHIFTER
Y(3) Y(2) Y(1) Y(0)
"000 " 0 D(3) D(2) D(1) Décalage à droite
"001 " D(2) D(1) D(0) 0 Décalage à gauche
"010 " D(0) D(3) D(2) D(1) Rotation à droite
"011 " D(2) D(1) D(0) D(3) Rotation à gauche
"1xx " (x=0 ou 1) peu n’importe D(3) D(2) D(1) D(0) Pas de rotation Y=D

2/5
Donner le code VHDL comportemental de ce circuit en utilisant un processus et l’instruction case. (4 points)
library ieee; when "001" =>
use ieee.std_logic_1164.all; Y <= ((3 downto 1)=> D(2 downto 0), 0 => '0');
entity SHIFTER is -- decalage gauche
port(
Fct : in std_logic_vector(2 downto 0); when "010" =>
D : in std_logic_vector(3 downto 0); Y <= (D(0),D(3),D(2),D(1) ); -- rotation droite
Y : out std_logic_vector(3 downto 0) ); when "011" =>
end SHIFTER; Y <= (D(2),D(1),D(0),D(3) ); -- rotation gauche
architecture arch of SHIFTER is
begin when others =>
P3: process(Fct,D)
begin
Y <= D; -- pas de rotation
case Fct is end case;
when "000" => end process P3;
Y <= (3=> '0', (2 downto 0) => D(3 downto 1)); end arch;
-- decalage droite
-- Y <= '0' & D(3 downto 1);

5) Le circuit global aura comme entrées (Fct, D et sel) et comme sortie (CodeHex) comme présenté dans figure ci-
dessus. Donner la description VHDL structurelle du circuit global qui réutilise des instances des circuits décrits
dans les questions précédentes. ( 3 points)
library ieee; component SHIFTER
use ieee.std_logic_1164.all; port( Fct : in std_logic_vector(2 downto 0);
D : in std_logic_vector(3 downto 0);
entity GLOBAL is Y : out std_logic_vector(3 downto 0));
port( Fct : in std_logic_vector(2 downto 0); end component;
Sel : in std_logic;
D : in std_logic_vector(3 downto 0); begin
CodeHex : out std_logic_vector(7 downto 0) );
end GLOBAL; SHIFTER1: SHIFTER
architecture archG of GLOBAL is port map(Sel=>Sel, Fct=> Fct, Y=>Y);
signal Y, Z : std_logic_vector(3 downto 0);
component mux mux1: mux
port ( Sel : in std_logic; port map(D=>D,Sel=>Sel ,Y=>Y, Z => Z);
D,Y : in std_logic_vector(3 downto 0);
Z: out std_logic_vector(3 downto 0) );
end component; Dec7seg1: Dec7seg
port map(Z => Z, CodeHex => CodeHex);
component Dec7seg
port(Z: in std_logic_vector(3 downto 0); end archG;
CodeHex : out std_logic_vector(6 downto 0) );
end component;

6) Coder en VHDL un testbench qui pour la valeur de D égale à "0101", permet de stimuler toutes les fonctions de
décalage et d’afficher le résultat Y sur l’afficheur 7 segments. (2points)
entity TB is D <= "0101"; Fct <= "100";
end TB; Sel <= '1'; wait for 20 ns;
architecture test of TB is
component GLOBAL stimuli: process Fct <= "101";
port(Fct : in std_logic_vector(2 downto 0); begin wait for 20 ns;
Sel : in std_logic; Fct <= "000";
D : in std_logic_vector(3 downto 0); wait for 20 ns; Fct <= "110";
CodeHex:out std_logic_vector(6 downto 0)); wait for 20 ns;
end component; Fct <= "001";
wait for 20 ns; Fct <= "111";
signal D : std_logic_vector(3 downto 0); wait;
signal sel: std_logic; Fct <= "010";
signal Fct : std_logic_vector(2 downto 0); wait for 20 ns; end process stimuli;
signal CodeHex : std_logic_vector(6 downto 0);
begin Fct <= "011"; end test;
wait for 20 ns; 3/5
GLOBAL1: GLOBAL port map(Fct, Sel, D, CodeHex);
 Exercice2 : Circuit de complément à 2 générique

On se propose de réaliser un circuit qui calcule le complément à 2 d’une entrée codée sur N bits. Le circuit OPP1
ci-dessous est composé de deux entrées (Xe et Ce) et deux sorties (Xs et Cs) codées toutes sur 1 bit.

1) Donner le code VHDL comportemental de ce circuit en se basant sur des instructions concurrentes

library ieee; architecture comport of OPP is

use ieee.std_logic_1164.all; begin
Xs <= Ce or Xe;
1 point
entity OPP is Cs <= Ce xor Xe;
port (Ce, Xe : in std_logic; end comport;
Xs, Cs: out std_logic);
end OPP;

Le circuit OPP3 de la figure suivante réutilise 3 circuits de type OPP1.

2) Coder en VHDL le circuit OPP3 en utilisant l’instruction concurrente for … generate. Indication :
exprimer la sortie S en fonction de l'entrée E et du signal interne C (exprimer S(i) en fonction de E(i) et
C(i) pour i allant de 0 à 2) (exprimer de même C(i+1) en fonction de E(i) et C(i) pour i allant de 0 à 2).
library ieee; gen1: for I in 0 t 2 generate
use ieee.std_logic_1164.all; C(I+1) <= C(I) xor E(I);
S(I) <= C(I) or E(I);
entity OPP3 is end generate gen1;
port(E : in std_logic_vector(2 downto 0);
S : out std_logic_vector(2 downto 0)); C(0) <= '0';
end OPP3; Cout <= C(3); 2 points
architecture comport3 of OPP3 is end comport3;
signal C : std_logic_vector(3 downto 0);
begin
4/5
 3) Donner le code VHDL du circuit générique OPPN correspondant (le cas général de la question 2).

library ieee; gen1: for I in 0 t N-1 generate

use ieee.std_logic_1164.all; C(I+1) <= C(I) xor E(I);
S(I) <= C(I) or E(I);
entity OPPN is end generate gen1;
generic(N : integer := 8);
port( E : in std_logic_vector(N-1 downto 0); C(0) <= '0';
S : out std_logic_vector(N-1 downto 0) ); Cout <= C(N);
end OPPN; 3 points
end comportN;
architecture comportN of OPPN is
signal C : std_logic_vector(N downto 0);
begin

4) Reprendre la même question en décrivant de façon structurelle le circuit générique de paramètre N qui
réutilise N circuits OPP1.

library ieee;
use ieee.std_logic_1164.all; gen2: for I in 0 t N-1 generate
OPPx: OPP port map(
entity OPPN is Ce => C(I),
generic(N : integer := 8); Xe => E(I),
port
X(S) => S(I),
( E : in std_logic_vector(N-1 downto 0);
S : out std_logic_vector(N-1 downto 0) Cs => C(I+1)
); );
end OPPN; end generate gen2;
2 points
architecture Structurelle of OPPN is C(0) <= '0';
signal C : std_logic_vector(N downto 0); Cout <= C(N);

end Structurelle;
component OPP is
port
( Ce, Xe : in std_logic;
Xs, Cs: out std_logic
);
end component;

begin

5/5