Conception Numerique VHDL PDF

1 Travaux pratiques: Conception Numérique VHDL 2éme Année cycle ingénieur : GE
TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

Remerciement
Nous avons l’honneur en marge de ce travail d’exprimer nos
profondes gratitudes ainsi que toute nos reconnaissances à notre
Professeurs I. LAGRAT pour l’intérêt avec lequel il a suivi la
progression de notre travail, ses conseils judicieux, et pour tous les
moyens qu’il a mis à notre disposition...
On sait bien que ça n’a pas été du facile de nous enseigner;
parfois dû à notre manque de base d’autre fois a notre surcharge,
merci de ne pas avoir baissé les bras quand même; de nous avoir
tant soutenu et encourager pour arriver au bout , que Dieu vous
bénisse. Les mots restent incapables de tout exprimer, la langue une
traitre mais Dieu un grand benedicteur qu’il vous bénisse.
Enfin, que toute personne ayant contribuée de près ou de loin à
la préparation de ce travail, trouve ici l’expression de notre profonde
gratitude

Sommaire
Remerciement ………………………………………………..……2
Introduction Général …………………………………………4
Objectif du TP………………………………………………………5
Initialisation : Compilation d’une unité fonctionnelle .….6
Simulation de l’unité fonctionnelle…………………8
TP1 Un Multiplexeur 4 vers 1……………………………11
TP2 LA Bascule D ……………………..……..…………..…20
TP3 Le Compteur……………………………..…….…………23
TP4 Unité arithmétique et logique….…….…….28
TP5 Détecteur de partie …………..………………..…..31
TP6 Etude d’un diviseur de fréquence …….34
TP7 Affichage digital…………………….………………….36
TP8 : Gestion d’un Carrefour………………..………38

Introduction Général
Pourquoi avoir créé un langage de description de structures électroniques

(H.D.L.Hardware Description language) VHDL ?
L’abréviation VHDL signifie VHSIC Hardware Description Language (VHSIC: VeryHigh

Speed Integrated Circuit). Ce langage a été écrit dans les années 70 pour réaliser la
simulation de circuits électroniques. On l’a ensuite étendu en lui rajoutant des
extensions pour permettre la conception (synthèse) de circuits logiques
programmables (P.L.D. Programmable Logic Device).
Le langage VHDL est un outil de conception et de développement des circuits

électroniques (numériques) en fournissant une méthode rigoureuse de description du
fonctionnement et de l'architecture du circuit désirée. L'idée est de ne pas réaliser un
composant réel, mais est de vérifier son fonctionnement attendu en utilisant à sa place
des outils de développement. Ce langage permet en effet d'utiliser des simulateurs,
dont le rôle est de tester le fonctionnement du circuit comme le logiciel ModelSim
qui le simulateur de ce Tp.
Ils permettent au code écrit d’être portable, c’est à dire qu’une description écrite pour
un circuit peut être facilement utilisée pour un autre circuit. Il faut avoir à l’esprit que
ces langages dits de haut niveau permettent de matérialiser les structures
électroniques d’un circuit. En effet les instructions écrites dans ces langages se
traduisent par une configuration logique de portes et de bascules qui est intégrée à
l’intérieur des circuits PLDs. C’est pour cela que je préfère parler de description VHDL
ou VERILOG que de langage.

Objectif du TP
L’objectif de ce TP est de prendre en main le langage et les différents outils

logiciels que nous devrons utiliser pour programmer les circuits FPGA.
Le but des ces séances de travaux pratiques est d’intégrer les différentes notions vues
en cours concernant l’apprentissage du langage VHDL.
Ce langage étant fortement utilisé dans le monde industriel pour la réalisation des
circuits numériques incluant la conception et le test des entités, l’enseignement est
fortement tourné vers l’utilisation du langage pour la synthèse. L’aspect
comportemental utilisé en modélisation de systèmes numériques sera abordé lors de la
conception des modules de test (écrits aussi en VHDL).
Afin de prendre en main le langage et les différents outils logiciels que nous devrons
utiliser, une présentation de chacun vous est présentée en annexe. Ils sont tous
intégrés dans l’environnement ISE de Xilinx qui propose à la fois éditeur de texte,
synthétiseur logique, simulateur, implémentation et programmation des composants
logiques (FPGA) que nous emploierons. Toutefois, il sera possible au cours des séances
d’utiliser le simulateur MODELSIM SE 6.3 de chez MENTOR comme simulateur VHDL
(Simulateur utilisé dans l’industrie).
Le logiciel model Sim est un simulateur du langage VHDL aussi bien que le
langage Verilog. Il fournit un environnement complet de simulation et débogage pour
les designs complexes en ASIC et en FPGA. Les opérations de compilation et
d'élaboration doivent être préalablement effectuées avant la simulation.

Initialisation : Compilation
d’une unité fonctionnelle
 Création d’un nouveau fichier VHDL dans notre projet .

 On fait la saisie suivante :
 L’étape de compilation ( Message de compilation ) :

 Création d’un fichier VHDL ArchiCompAnd :

Simulation de l’unité
fonctionnelle
 Stocker le tous dans le fichier TestAnd.vhd :

 La compilation correcte :
 Choix de l’entité TestPorteET disponible dans la librairie Work :

 Ajouter des signaux d’observation des chronogrammes :
 Lancement de la simulation :

TP1 Un Multiplexeur 4 vers 1 :

1. Etude théorique :
a. Schéma synoptique
b. Table de vérité :
2. la description VHDL d’un multiplixeur 4 vres 1 :

a. entity :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
entity multiplexer4_1 is
port (
i0 : in std_logic;
i1 : in std_logic;
i2 : in std_logic;
i3 : in std_logic;
sel : in std_logic_vector(1 downto 0);
bitout : out std_logic
);
end multiplexer4_1;

 l’architecture avec Instruction conditionnelle (when/else) : l’architecture avec l’instruction sélective :
library IEEE;
library IEEE; use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_1164.ALL; architecture Description of
architecture Description of multiplexer4_1 is
multiplexer4_1 is begin
begin process(i0,i1,i2,i3,sel)
bitout <= i0 WHEN (sel="00") begin
case sel is
ELSE when "00" => bitout <= i0;
i1 WHEN (sel="01") ELSE when "01" => bitout <= i1;
i2 WHEN (sel="10") ELSE when "10" => bitout <= i2;
i3; when others => bitout <= i3;
end Description; end case;
end process;
end Description;
Le testbench :
LIBRARY ieee ; BEGIN

USE ieee.std_logic_1164.all ; DUT : multiplexer4_1
ENTITY multiplexer4_1_tb IS PORT MAP (
END ; sel => sel ,
ARCHITECTURE multiplexer4_1_tb_arch i3 => i3 ,
OF multiplexer4_1_tb IS i0 => i0 ,
SIGNAL sel : std_logic_vector (1 downto i1 => i1 ,
0) ; bitout => bitout ,
SIGNAL i3 : STD_LOGIC ; i2 => i2 ) ;
SIGNAL i0 : STD_LOGIC ; tb : PROCESS
SIGNAL i1 : STD_LOGIC ; BEGIN
SIGNAL bitout : STD_LOGIC ; i0<='1';
SIGNAL i2 : STD_LOGIC ; i1<='0';
COMPONENT multiplexer4_1 i2<='1';
PORT ( i3<='0';
sel : in std_logic_vector (1 downto 0) ; sel <="00";
i3 : in STD_LOGIC ; wait for 2 ns;
i0 : in STD_LOGIC ; sel <="01";
i1 : in STD_LOGIC ; wait for 2 ns;
bitout : out STD_LOGIC ; sel <="10";
i2 : in STD_LOGIC ); wait for 2 ns;
END COMPONENT ; sel <="11";
wait for 2 ns;
END PROCESS tb;
END ;
1 2

b. sous Modelsim :
 L’entité :
 L’architecture avec l’instruction sélective
 L’architecture avec l’instruction conditionnelle :










 Le Testebench :











 Simulation :

 Affectation sélective avec les autres cas forcés à 0 et 1 :
l’entité : Testbench
library IEEE; LIBRARY ieee ;
use USE ieee.std_logic_1164.all ;
IEEE.STD_LOGIC_1164.ALL; ENTITY multiplexer4_1_tb IS
entity multiplexer4_1 is END ;
port ( ARCHITECTURE
i0 : in std_logic; multiplexer4_1_tb_arch OF
i1 : in std_logic; multiplexer4_1_tb IS
i2 : in std_logic; SIGNAL sel : std_logic_vector
i3 : in std_logic; (1 downto 0) ;
sel : in std_logic_vector(1 SIGNAL i3 : STD_LOGIC ;
downto 0); SIGNAL i0 : STD_LOGIC ;
bitout : out std_logic SIGNAL i1 : STD_LOGIC ;
); SIGNAL bitout : STD_LOGIC
end multiplexer4_1; ;
SIGNAL i2 : STD_LOGIC ;
COMPONENT multiplexer4_1
PORT (
sel : in std_logic_vector (1
downto 0) ;
i3 : in STD_LOGIC ;
i0 : in STD_LOGIC ;
l’architecture : i1 : in STD_LOGIC ;
bitout : out STD_LOGIC ;
i2 : in STD_LOGIC );
END COMPONENT ;
library IEEE; BEGIN
use DUT : multiplexer4_1
IEEE.STD_LOGIC_1164.ALL; PORT MAP (
architecture Description of sel => sel ,
multiplexer4_1 is i3 => i3 ,
begin i0 => i0 ,
with sel select i1 => i1 ,
bitout <= i0 when "00", bitout => bitout ,
i1 when "01", i2 => i2 ) ;
i2 when "10", tb : PROCESS
i3 when "11", BEGIN
'0' when others ; i0<='1';
end Description; i1<='0';
i2<='1';
i3<='0';
sel <="00";
wait for 2 ns;
sel <="01";
wait for 2 ns;
sel <="10";
wait for 2 ns;
sel <="11";
wait for 2 ns;
END PROCESS tb;
END ;
b. sous Modelsim :

 L’entité
 L’architecture avec l’instruction sélective :

 Le Testebench :

 simulation : Affectation sélective avec les autres cas forcés à 0 :
 simulation : Affectation sélective avec les autres cas forcés à 1 :

TP2 La Bascule D:
1. Etude théorique :
a. Schéma synoptique :
b. Table de vérité :
2. La description VHDL d’une Bascule D :

a. le programme :
 Entité :

 Architecture :
 Testbench :

 Simulation :
Library ieee;
1- Avec des entrées de présélections de mise Use ieee.std_logic_1164.all;
à zéro RESET prioritaire sur l’entrée de Use ieee.numeric_std.all;
mise à un SET, toutes les deux sont Use ieee.std_logic_unsigned.all;
synchrones de l’horloge CLK.
entity BASCULE_d_reset is
port (
D,CLK,SET,RESET : in std_logic;
S : out std_logic);
end BASCULE_d_reset;
architecture DESCRIPTION of
BASCULE_d_reset is
begin
PROC : process (CLK)
Begin
if (CLK'event and CLK ='1') then
if (RESET = '1') then
S <= '0';
elsif (SET = '1') then
S <= '1';
else
S <= D;
end if;
end if;
end process PROC;
end DESCRIPTION;

TP3 :Un compteur

Définition :
Un compteur (ou décompteur) est un circuit électronique constitué essentiellement par un ensemble de bascules et le
plus souvent d'un réseau combinatoire.
Ce compteur (ou décompteur) permet de comptabiliser le nombre d'événements qui se produisent pendant un temps
donné.
Chaque événement est traduit en impulsion électrique.
Compteur Simple :
 Programme de l’entité et l’architecture: la description VHDL d’un compteur simple
library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity compt is port (
clk, rst: in std_logic;
q : buffer unsigned( 7 downto 0));
end compt;
architecture Acompt of compt is
begin
process (clk,rst) begin
if rst = '1' then
q <= ( others => '0');
elsif ( clk'event and clk='1') then
q<= q+1;
end if;
end process;
end Acompt;

Testbench
 Compteur 3 bits avec remise à zéro asynchrone :
Programme de l’entité LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.numeric_std.ALL;
ENTITY tb IS
END tb;
library IEEE; ARCHITECTURE behavior OF tb
use IEEE.STD_LOGIC_1164.ALL; IS
use IEEE.NUMERIC_STD.ALL; signal RST_I : std_logic := '0';
entity ring_counter is signal CLK_I : std_logic := '0';
port ( signal DAT_O : unsigned(2
DAT_O : out unsigned(2 downto 0); downto 0);
RST_I : in std_logic; constant CLK_I_period : time := 1
CLK_I : in std_logic ); ns;
end ring_counter; BEGIN
uut: entity work.ring_counter
PORT MAP (
DAT_O => DAT_O,
RST_I => RST_I,
CLK_I => CLK_I );
l’architecture: CLK_I_process :process
begin
CLK_I <= '1';
wait for CLK_I_period/2;
architecture Behavioral of ring_counter is CLK_I <= '0';
signal temp : unsigned(2 downto 0):=(others wait for CLK_I_period/2;
=> '0'); end process;
begin stim_proc: process
DAT_O <= temp;
process(CLK_I) begin
begin
RST_I <= '1';
if( rising_edge(CLK_I) ) then
if (RST_I = '1') then wait for 2 ns;
temp <= (0=> '1', others => '0'); RST_I <= '0';
else wait for 5 ns;
temp(1) <= temp(0); RST_I <= '1';
temp(2) <= temp(1); wait for 10 ns;
temp(0) <= temp(2); RST_I <= '0';
end if; wait;
end if; end process;
end process; END
end Behavioral;
LIBRARY ieee;
USE ieee.numeric_std.ALL;
ENTITY tb IS
END tb;
ARCHITECTURE behavior OF tb IS
signal RST_I : std_logic := '0';
signal CLK_I : std_logic := '0';
signal DAT_O : unsigned(2 downto 0);
constant CLK_I_period : time := 1 ns;
BEGIN
uut: entity work.ring_counter PORT MAP (
DAT_O => DAT_O,
RST_I => RST_I,
CLK_I => CLK_I );
CLK_I_process :process
TP&Cours encadrés
beginpar Mr.Dr LAGRAT Année universitaire 2015-2016
Sous ModelSim
Programme de l’entité et l’architecture: Testbench
Simulation :

 Compteur 3 bits avec remise à zéro synchrone
library ieee;
library ieee; use ieee.std_logic_1164.all;
use ieee.std_logic_1164.all;
entity up_down_counter_tst is
use ieee.std_logic_arith.all; end up_down_counter_tst;
use ieee.std_logic_unsigned.all;
architecture beh of up_down_counter_tst is
entity up_down_counter is component up_down_counter
port(clk, rst_a, mode : in std_logic;
port(clk, rst_a,mode : in std_logic;
q : out std_logic_vector(2 downto 0)); q : out std_logic_vector(2 downto 0));
end up_down_counter;
end component;
architecture archi of up_down_counter is signal clk_s,rst_a_s,mode_s : std_logic;
signal tmp: std_logic_vector(2 downto 0);
signal q_s : std_logic_vector(2 downto 0);
begin begin -- beh
process (clk, rst_a)
u1 : up_down_counter port map (
begin clk => clk_s,
if (rst_a='1') then
rst_a => rst_a_s,
tmp <= "000"; Page 15 mode => mode_s,
q => q_s);
elsif (clk'event and clk='1') then clockk: process
if (mode='1') then begin -- process clockk
tmp <= tmp + 1; clk_s <= '1';
end if; wait for 55 ns;
end if; clk_s <= '0';
end process; wait for 55 ns;
q <= tmp; end process clockk;
end archi; tst: process
begin -- process tst
rst_a_s <= '1';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '1';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '1';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '0';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '0';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '1';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '0';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '0';
wait for 1 ns;
rst_a_s <= '0';
mode_s <= '1';
wait for 1 ns;
end process tst;
end beh;
TestBench
Sous ModelSim :
Entité et Architecture
Simulation

TP4 : Unité Arithmétique et Logique

Principe :
L'UAL assure les fonctions basiques de calcul arithmétique et les opérations logiques.
Définition :
L'UAL (Unité d'Arithmétique et de Logique) est l'élément de base d'un microprocesseur. Comme son nom l'indique, son
rôle est la réalisation d'opérations arithmétiques (additions, soustractions...), logiques (OR, AND, NOR...), mais aussi de
décalage, et de transfert. Sous sa forme la plus simple, elle possède une entrée reliée au bus de données du
microprocesseur, une autre reliée à un registre interne, et une sortie reliée au même registre et au bus de données. Elle
possède également un bus destinée à la sélection des opérations à réaliser. Le cycle pour la réalisation d'une opération
est le suivant : -Présentation d'une donnée sur la première entrée. -Sélection de l'opération de chargement dans le
registre interne. La donnée est ainsi véhiculée vers la sortie de l'ual, chargée dans le registre, et présentée sur la seconde
entrée. -Présentation d'une nouvelle donnée sur la première entrée. -Sélection de l'opération à réaliser. -Récupération du
résultat en sortie de l'ual et sur le bus de données du microprocesseur
Schéma synoptique :
Tableau de vérité :
Op R
00 A+B
01 A-B
10 A && B
11 A||B

Programme de l’entité et l’architecture: Testbench :
library IEEE; LIBRARY ieee;

use IEEE.STD_LOGIC_1164.ALL; USE ieee.std_logic_1164.ALL;
use IEEE.NUMERIC_STD.ALL; USE ieee.numeric_std.ALL;
USE IEEE.STD_LOGIC_SIGNED.ALL; USE IEEE.STD_LOGIC_SIGNED.ALL;
ENTITY tb IS
entity simple_alu is END tb;
port( Clk : in std_logic; ARCHITECTURE behavior OF tb IS
A,B : in std_logic_vector(15 downto 0); signal Clk : std_logic := '0';
Op : in std_logic_vector(1 downto 0); signal A,B,R : std_logic_vector(15 downto 0) := (others => '0');
R : out std_logic_vector(15 downto 0) signal Op : std_logic_vector(1 downto 0) := (others => '0');
); constant Clk_periode : time := 10 ns;
BEGIN
end simple_alu;
uut: entity work.simple_alu PORT MAP (
architecture Behavioral of simple_alu is Clk => Clk, A => A, B => B, Op => Op, R => R );
begin Clk_process :process
process(Clk,A,B,Op) begin
begin Clk <= '0';
if(rising_edge(Clk)) then wait for Clk_periode/2;
case Op is Clk <= '1';
wait for Clk_periode/2;
when "00" => R <= A + B; --addition end process;
when "01" => R <= A - B; --subtraction stim_proc: process
begin
when "10" => R <= A AND B; -- et wait for Clk_periode*1;
A <= "0000000000000011";
when "11" => R <= A OR B; -- ou B <= "0000000000000001";
when others => NULL; Op <= "00";
end case; wait for Clk_periode;
end if; Op <= "01";
end process; wait for Clk_periode;
Op <= "10";
end Behavioral; wait for Clk_periode;
Op <= "11";
wait for Clk_periode;
wait;
end process;
END;

Sous Modelsim :
Entité et Architecture
TestBench

Simulation

TP5 : Détecteur de partie

Définition :
Un bit de parité permet d'assurer un contrôle sur le contenu d'une trame. Une trame même composé de plusieurs octets
est vue comme une suite de bits. Selon que le nombre de bits à 1 soit pair ou impair, le bit de parité aura pour valeur 0
ou 1. Dans un échange de trame sur un réseau, l'expéditeur calcul le bit de parité et le joint à la trame. Le destinataire
calcul le bit de parité sur la trame reçue et le compare avec le bit de parité que l'expéditeur lui a envoyé. Si les deux bits
de parités sont de valeurs différentes, alors c'est que la trame a subi des dommages au cours de son transport puisque la
série de bits a changé. Le destinataire va donc demander la réémission de la trame.
Le principe du détecteur de parité est de « compter » le nombre de bits à ‘1’ dans un mot de n bits. La valeur du signal
de sortie vaut ‘1’ lorsque le nombre de ‘1’ est impair et ‘0’ lorsqu’il est pair.
Dans cet exercice, il est demandé de proposer une description VHDL générique.
library ieee ; LIBRARY ieee ;

use ieee.std_logic_1164.all ; USE ieee.std_logic_1164.all ;
entity parity is use IEEE.STD_LOGIC_ARITH.ALL ;
port ( ENTITY parity_tb IS
A: in std_logic_vector (15 downto 0 ); END ;
p:out std_logic); ARCHITECTURE parity_tb_arch OF parity_tb IS
end entity ; SIGNAL p : STD_LOGIC ;
architecture archi of parity is SIGNAL A : std_logic_vector (15 downto 0) ;
begin COMPONENT parity
process (A) PORT (
variable K: std_logic; p : out STD_LOGIC ;
begin A : in std_logic_vector (15 downto 0) );
K:= '0'; END COMPONENT ;
for i in 0 to 15 loop BEGIN
K:=K xor A(i); DUT : parity
end loop; PORT MAP (
p <= K ; p => p ,
end process ; A => A ) ;
end ; stim_proc: process
begin
wait for 2 ns;
A <= "1100000000011100" ;
wait for 2 ns;
A <= "0000000000000000" ;
wait for 2 ns;
A<= "1111111111111111";
wait for 2 ns;
WAIT ;
end process stim_proc ;
END ;

Sous Modelsim :
Testbench
Entité
Simulation
TP6 : Etude d’un diviseur de fréquence

Le programme fourni est destiné à générer deux signaux à une fréquence différente de celle de l’horloge d’entrée.
a. On traduit ce programme en un schéma synoptique dans lequel apparaîtront des bascules, des
blocs combinatoires dont on ne demande pas les détails internes et des signaux d’interconnexions
nommées.
b. On représente le fonctionnement logique de chaque processus par un diagramme de transitions

(un par processus) commenté.
c. A partir de la réponse à la question précédente, on complète le chronogramme ébauché ci-dessous :
Programme de l’entité et l’architecture: Testbench :
entity divnn is
port (hor, en : in bit ; library IEEE;
div1, div2 : out bit ) ; USE IEEE.NUMERIC_BIT.ALL;
end divnn ; Entity divnn_tb is
architecture combien of divnn is end;
signal sig1 : integer range 0 to 3 ; Architecture divnn_tb_arch of divnn_tb is
signal sig2 : bit ; signal div1 : BIT ;
begin signal div2 : BIT ;
div1 <= '1' when sig1 = 2 else '0' ; signal hor : BIT;
div2 <= sig2 ; signal en : BIT ;
d1 : process Component divnn
begin PORT(
wait until hor = '1' ;
if en = '0' then div1 : out BIT;
sig1 <= 0 ; div2 : out BIT;
else hor : in BIT ;
case sig1 is en : in BIT );
when 0 => if sig2 = '1' then end Component ;
sig1 <= 1 ; Begin
end if ; DUT : divnn
when 1 => sig1 <= 2 ; PORT MAP (
when 2 => sig1 <= 0 ; div1 => div1,
when others => sig1 <= 0 ; div2 => div2,
end case ; hor => hor,
end if ;
end process ; en => en );
d2 : process end ;
begin
wait until hor = '1' ;
if en = '0' then
sig2 <= '0' ;
else
case sig2 is
when '0' => if sig1 = 0 then
sig2 <= '1' ;
end if ;
when others => sig2 <= '0' ;
end case ;
end if ;
end process ;
end combien ;

 Sous Modelsim :
Entité Testbench
Simulation

TP 7 : Affichage digital
Définition :
Les afficheurs 7 segments sont un type d'afficheur très
présent sur les calculatrices et les montres à affichage
numérique : les caractères (des chiffres, bien que quelques
lettres soient utilisées pour l'affichage hexadécimal)
s'écrivent en allumant ou en éteignant des segments, au
nombre de sept. Quand les 7 segments sont allumés, on
obtient le chiffre 8.
La figure suivante montre un décodeur de 7 segments avec 7

sorties qui sont utilisées pour afficher un caractère sur un
affichage 7 segments. Les 7 segments de l'affichage sont
identifiés par les chiffres 0-6 comme indiqué sur la figure.
Chaque segment est illuminé lorsque la valeur logique 0 lui est assignée.
Programme de l’entité et l’architecture: Sous ModelSim
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity test is
port (
clk : in std_logic;
bcd : in std_logic_vector(3 downto 0);
segment7 : out std_logic_vector(6 downto 0));
end test;
architecture Behavioral of test is
begin
process (clk,bcd)
BEGIN
if (clk'event and clk='1') then
case bcd is
when "0000"=> segment7 <="1000000"; -- '0'
when "0001"=> segment7 <="1111001"; -- '1'
when "0010"=> segment7 <="0100100"; -- '2'
when "0011"=> segment7 <="0110000"; -- '3'
when "0100"=> segment7 <="0011001"; -- '4'
when "0101"=> segment7 <="0010010"; -- '5'
when "0110"=> segment7 <="0000010"; -- '6'
when "0111"=> segment7 <="1111000"; -- '7'
when "1000"=> segment7 <="0000000"; -- '8'
when "1001"=> segment7 <="0010000"; -- '9'
when "1010"=> segment7 <="0001000"; -- 'A'
when "1011"=> segment7 <="0000011"; -- 'B'
when "1100"=> segment7 <="1000110"; -- 'C'
when "1101"=> segment7 <="0100001"; -- 'D'
when "1110"=> segment7 <="0000110"; -- 'E'
when "1111"=> segment7 <="0001110"; -- 'F'
when others=> segment7 <="1111111";
end case;
end if;
end process;
end Behavioral;

Testbench : sous Modelsim :
LIBRARY ieee;
use IEEE.STD_LOGIC_ARITH.ALL;
ENTITY test_tb IS
END test_tb;
ARCHITECTURE behavior OF test_tb IS
signal clk : std_logic := '0';
signal bcd : std_logic_vector(3 downto 0) :=
(others => '0');
signal segment7 : std_logic_vector(6 downto 0);
constant clk_periode : time := 1 ns;
BEGIN
uut: entity work.test PORT MAP
(clk,bcd,segment7);
clk_process :process
begin
clk <= '0';
wait for clk_periode/2;
clk <= '1';
wait for clk_periode/2;
end process;
stim_proc: process
begin
for i in 0 to 15 loop
bcd <= conv_std_logic_vector(i,4);
wait for 2 ns;
end loop;
end process;
END;
Simulation :

TP8 : Gestion d’un Carrefour

Introduction :
Ce TP est consacré à l’étude d’un feu de carrefour dont le rôle est de sécuriser et de fluidifier la circulation
automobile d’un carrefour lorsque le trafic est dense.
Fonctionnement :
On définira les temps de fonctionnement des feux en fonction de la période de l’horloge de base. Pour la simulation
T de l’horloge fera 1 μs. Dans la réalité il suffira de connecter au circuit une horloge de 1 seconde par exemple.
V1 dure 8 s, V2 dure 5s, et les feux oranges 1s.
On décrit donc le fonctionnement global comme suit :

L’axe 1 vient de passer au vert (V1=1, R1 et O1=0 ; V2 et O2=0, R2=1). 8 s plus tard il passe à l’orange (O1=1, R2=1). On
laisse par sécurité les 2 feux au rouge pendant une seconde (R1 et R2=1). 10 secondes se sont écoulées lorsqu’on ouvre
le passage à l’axe 2 (V2 et R1=1). Le cycle complet dure donc 17s.
L’initialisation doit placer le système en état de sécurité, soit R1 et R2=1 pendant une seconde. On libère ensuite l’axe
1. Il n’y a pas d’entrée (appel piéton...) dans cet exemple très simplifié.

Diagramme d’états :
Code VHDL :


Simulation :

Conception Numerique VHDL PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Conception Numerique VHDL PDF

Transféré par

Droits d'auteur :

Formats disponibles

1 Travaux pratiques: Conception Numérique VHDL 2éme Année cycle ingénieur : GE

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

Pourquoi avoir créé un langage de description de structures électroniques

L’abréviation VHDL signifie VHSIC Hardware Description Language (VHSIC: VeryHigh

Le langage VHDL est un outil de conception et de développement des circuits

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

L’objectif de ce TP est de prendre en main le langage et les différents outils

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 Création d’un nouveau fichier VHDL dans notre projet .

 L’étape de compilation ( Message de compilation ) :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 Création d’un fichier VHDL ArchiCompAnd :

 L’étape de compilation ( Message de compilation ) :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 L’étape de compilation ( Message de compilation ) :

 Choix de l’entité TestPorteET disponible dans la librairie Work :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 Ajouter des signaux d’observation des chronogrammes :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP1 Un Multiplexeur 4 vers 1 :

2. la description VHDL d’un multiplixeur 4 vres 1 :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 l’architecture avec Instruction conditionnelle (when/else) : l’architecture avec l’instruction sélective :

LIBRARY ieee ; BEGIN

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 L’architecture avec l’instruction sélective

 L’architecture avec l’instruction conditionnelle :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 Affectation sélective avec les autres cas forcés à 0 et 1 :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 L’architecture avec l’instruction sélective :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 simulation : Affectation sélective avec les autres cas forcés à 0 :

 simulation : Affectation sélective avec les autres cas forcés à 1 :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

2. La description VHDL d’une Bascule D :

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP3 :Un compteur

 Programme de l’entité et l’architecture: la description VHDL d’un compteur simple

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

 Compteur 3 bits avec remise à zéro synchrone

Programme de l’entité et l’architecture: Testbench

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP4 : Unité Arithmétique et Logique

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

Programme de l’entité et l’architecture: Testbench :

library IEEE; LIBRARY ieee;

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016

TP5 : Détecteur de partie

Programme de l’entité et l’architecture: Testbench

library ieee ; LIBRARY ieee ;

TP&Cours encadrés par Mr.Dr LAGRAT Année universitaire 2015-2016