Chap02 Langage VHDL Combinatoire

Université de Carthage
Institut National des Sciences Appliquées et de Technologie
Chapitre 2
VHDL:
Circuits combinatoires
Par Emir Damergi
1/120
Chapitre 2: Langage VHDL: Circuits combinatoires
VHDL & Circuits VHDL & Circuits Synthèse: Exemples: Simulations Sous-
Introduction
Combinatoire Séquentiels Signal vs Variable FSM & Mémoires & Test programmes
système numérique (approche HW)
Un système numérique (ou logique) peut varier d’un simple compteur
constitué de quelques bascules et portes logiques à un processeur GPP assurant des
dizaines d’opérations arithmétiques et logiques.
 Si pour le premier, le développement et la fabrication peuvent être effectués

manuellement en utilisant la méthode classique :
Équations logiques  Circuit (portes logiques + bascules)  Transistors
Tables de vérité,
Karnaugh, transition
 Pour le deuxième, qui nécessite des millions de portes logiques, cette

méthode est complètement inadaptée et ingérable.
Nécessité d’automatiser les étapes de développement des systèmes

numériques.
2/120
Chapitre 3: Langage VHDL: Design & Synthèse – Emir DAMERGI
Introduction
Système numérique: outils de synthèse
• Ainsi, plusieurs outils permettant d’automatiser le développement sont apparus:
des « outils de synthèse ».

Programme
• Il s’agit d’applications logicielles qui reçoivent comme
entrée un programme écrit en un langage spécifique.
• Le programme est une description architecturale, Outil de
relationnelle ou bien fonctionnelle du système à synthèse
concevoir.
• Comme sortie, l’outil de synthèse produit un schéma
en portes logiques qui sera par la suite traitée selon
que la plateforme ciblée est un circuit logique
Schéma en portes
programmable ou un ASIC: logiques
- Pour un PLD, il s’agit d’une suite de bits (Bitstream)
permettant de configurer les blocs qu’il contient.
- Pour un ASIC, il s’agit plutôt d’un masque (plans des
couches de silicium dopés N et P) représentant les Bitsream Masque
transistors constituant le système. (PLD) (ASIC)
3/120
Introduction
Systèmes numériques: Langages HDL
Les programmes à traiter par les outils de synthèse, doivent être écrits en l’un des
langages HDL (Hardware Description Language).
Les deux langages les plus utilisés sont:
 Le langage VHDL (VHSIC Hardware Description Language) ou VHSIC signifie Very

High Speed Integrated Circuit :
 crée au début des années 80 suite à une initiative lancée par Le département
de la défense américain.
 Le langage VERILOG :
 À l'origine, langage propriétaire, développé par la société Cadence
 La syntaxe de Verilog est inspirée du langage de programmation C.
 Les deux:
 Supportés par tous les outils de synthèse disponibles sur le marché.
 Très utilisé dans le milieu industriel.
 En plus de la synthèse, il permettent de simuler le fonctionnement logique et
même chronologique du système.
4/120
Introduction
Langage VHDL: Approches
Au niveau de la programmation, on peut distinguer principalement 3 approches

pour la description du système à synthétiser:
 Description Dataflow il s’agit de décrire l’acheminement des signaux ainsi que des
fonctions logiques les traitant. C’est une approche qui est proche de l’architecture
réelle. Contrôle total du résultat de synthèse.
 Description comportementale (Behavioral Description): c’est une description

sous forme algorithmique de la relation entre entrées et sorties du système. C’est
une description de haut niveau qui ressemble à la programmation classique en
autres langages.
 Description Structurelle (Structural Description): Il s’agit d’une vison

hiérarchique du système qui est vu comme étant un assemblage de sous-
systèmes moins complexes. Les sous-systèmes étant eux-mêmes conçus selon
l’une des 3 approches.
Généralement, les 3 approches sont utilisées conjointement.
5/120
Introduction
VHDL: Design Flow
6/120
VHDL pour circuits combinatoires
 Additionneur 1 bit complet (DataFlow)
 Construire un additionneur 4 bits

(4 * additionneurs 1 bit): structurelle
 Additionneur 4 bits (comportementale)
 Description de Multiplexeurs
7/120
Introduction
Combinatoires Séquentiels Signal vs Variable FSM & Mémoires & Test programmes
Additionneur 1 bit complet : Equations
Commençons par un exemple simple, une description RTL d’un additionneur 1 bit complet.
A B Cin Cout S
A
B S
Cin S  Cin  A  B
Cout Cout  ( A.B )  (Cin.( A  B ))
8/120
Introduction
Additionneur 1 bit complet: code VHDL
En VHDL, tout système ou sous-système est décrit par 2 structures:
1- Entity (entité): qui énumère les entrées et

les sorties du système ainsi que leurs types. entity Addcomplet is
port (A,B,Cin: in std_logic;
S,Cout: out std_logic);
end Addcomplet;
2- Architecture: qui décrit les

relations entre entrées et sorties
Architecture addarch of Addcomplet is
et par conséquent le S <= Cin XOR (A XOR B);
fonctionnement du système
(approche Dataflow). Cout <= (A AND B) OR (Cin AND (A XOR B));
S  Cin  A  B end addarch;

Cout  ( A.B)  (Cin.( A  B))
9/120
Introduction
Additionneur 1 bit complet: programme complet
Le package contenant les définitions des types utilisés Commentaires en VHDL
library ieee; - - Déclaration de la librairie à utiliser.

Use ieee.std_logic_1164.all; - - Importation du package std_logic_1164 de la librairie ieee.
entity Addcomplet is Mots réservés (VHDL)

port (A,B,Cin: in std_logic;
Mots choisis par le programmeur:
S,Cout: out std_logic); - Nom de l’entité, Nom de l’architecture
end Addcomplet ; - Les Noms des signaux.
• Ne doivent contenir que des

architecture addarch of Addcomplet is lettres, nombres et underscore.
begin • Ils doivent impérativement

commencer par une lettre, et ne
S <= Cin XOR (A XOR B);
pas terminer par un underscore.
Cout <= (A AND B) OR (Cin AND (A XOR B));
Rq:Le VHDL ne fait aucune distinction
end addarch ; Entre majuscules et miniscules
10/120
Introduction
L’entité en VHDL: instruction PORT
port est l’instruction qui déclare les signaux
d’entrée & de sortie de l’entité. Sa syntaxe :
entity Addcomplet is port (Nom_sig_1: sens type;
Nom_sig_2: sens type;
……………………………………….… ;
port (A,B,Cin: in std_logic; …………………………………..……….;
Nom_sig_N: sens type );
• Si plusieurs signaux possèdent le même sens et
le même type, ils peuvent être regroupés ensemble
(tel que A,B et Cin)
S,Cout: out std_logic); Le sens du signal :

• in: entrée
end Addcomplet ; • out : sortie
• inout : entrée & sortie mais à un instant donné
Ne peut être qu’en entrée ou en sortie
• Buffer : Une sortie qui peut être relue.
Type du signal
• VHDL est un langage fortement typé, c.a.d que chaque signal
doit avoir un type et on ne peut assigner la valeur d’un signal à
un autre d’une façon arbitraire.
11/120
Introduction
Types prédéfinis du langage VHDL
• STD_LOGIC: pour décrire un bit.

a,b,c: std_logic;
a <= ‘0’;
b <= ‘1’ ;
c <= a AND b;
d <= a OR b;
12/120
Introduction
• STD_LOGIC_VECTOR: pour représenter une suite (un vecteur) de N bits
 Exemples :A: std_logic_vector (7 downto 0);
B: std_logic_vector (1 to 8);
C,D: std_logic_vector (3 downto 0);
A <= “10010110”;
C <= A (2 to 5);
D <= “0101”;
B <= C & D; //Concténation
B <= “1001” & C;
C <= “1001” XOR D // toutes les opérandes de même taille
Rq: on ne peut appliquer des opérations arithmétiques sur des bits

13/120
Introduction
• UNSIGNED: pour les entiers non signés codés sur un nombre de bits
• SIGNED: pour les entiers signés codés en Complément à 2 sur N bits.
 Exemples :A,B : signed (7 downto 0);

C,D: unsigned (0 to 4);
E: signed (3 to 10);
A <= “10010110”;
B <= C & D; //concaténation
E <= A + B;
14/120
Introduction
•INTEGER : nombre compris entre -2-31 et 231 – 1 (codé sur 32 bits)
•REAL: réels compris entre -1.79769E308 et 1.79769E308
15/120
Introduction
Librairies & Packages
D’autres types ainsi que les opérateurs permettant de les manipuler sont définis dans les
différents packages qui doivent être importés avec l’instruction use.
Package Type Opérateurs

•std_logic : pour les bits Logiques (and, or, xor,
std_logic_1164 rotation, ….), concaténation
•std_logic_vector: un
tableau (array) de std_logic *)
std_logic_signed • signed logiques.

arithmétiques (-,+,..)
std_logic_unsigned • unsigned comparaison (=, >,..)
numeric_std • INTEGER
math_real • REAL
16/120
Introduction
Le Type STD_LOGIC
C’est le type de base pour la description d’un signal binaire.

Il peut prendre l’une des 9 valeurs possibles:
'U',-- état non initialisé

'0',-- état logique 0 fort
'1',-- état logique 1 fort
On s’intéresse à ces valeurs
'Z',-- état haute impédance
'-' -- état indifférent, don't care
'X',-- état inconnu fort
'W',-- état inconnu faible
'L',-- état logique 0 faible
'H',-- état logique 1 faible
17/120
Introduction
STD_LOGIC: l’état ‘Z’ ou Haute impédance
Pour la valeur « état haute impédance », iI s’agit d’un état ou le signal est
considéré comme étant complètement déconnecté du reste du circuit.
S <= ‘0’
‘0’ ~ 0V
S
S <= ‘Z’
S <= ‘1’
‘1’ ~ +V
S
18/120
Introduction
STD_LOGIC: l’état ‘Z’ ou Haute impédance
Pourquoi l’état haute impédance? : Si plusieurs signaux (en sortie) sont
reliés à un même conducteur et émettent des niveaux de tensions différents
S S S S
Court-circuit
‘0’ ~ 0V ‘1’ ~ +V
Si plusieurs signaux sont connectés à un même point, un seul peut imposer

un niveau logique, les autres étant en état haute impédance
S S S S
19/120
Introduction
Définition de nouveaux types
 Il est possible de définir des signaux ayant de nouveau types composés qui seront
des tableaux de types existants.
Prenons à titre d’exemple, une matrice de 32*8 bits:
On peut la déclarer ainsi :
• matrice: array (0 to 31) of std_logic_vector (7 downto 0);
On peut également définir de nouveau types (en traitant le même exemple)

32 mots
• type mot is std_logic_vector (7 downto 0)

• matrice: array (0 to 31) of mot;
Ou bien
• type mat_type is array (0 to 31) of std_logic_vector (7 downto 0)
Mot de 8 bits • matrice: mat_type
L’accès au mot i (i: 0  31) de la matrice se fait comme suit:

matrice (i) - - i étant un entier (de type integer)
20/120
Introduction
Définition de nouveaux types
 Il est également possible de définir des signaux comme un intervalle (range) de
valeurs ou un sous ensemble d’un autre type prédéfini.
type small_entier is range 0 to 1024; Intervalle d’entiers (limites entiers) .
• type probability is range 0.0 to 1.0; Intervalle de réels ( limites réelles).
•subtype entier_small is integer range -1024 to +1024;

Quand il s’agit de définir un type à partir d’un
Autre déjà existant, on utilise subtype.
 Des type énumérées (ensemble de valeurs discrètes) peuvent être également

définies:
type chiffre_impair is (‘1’, ‘3’, ‘5’, ‘7’, ‘9’);
Type date is record

 On peut créer des enregistrements impair : chiffre_impair;
réunissant des objets de types différents en
pourcentage : probabilty;
utilisant Le type RECORD
end record;
21/120
Introduction
Synthèse de l’additionneur: concurrence
 On voit bien que les deux affectations se trouvant

dans le corps de la section architecture:
Cout <= (A AND B) OR (Cin AND (A XOR B));
sont interprétés comme 2 logiques s’exécutant en
parallèle
 les signaux A et B attaquent en même temps la
porte XOR et AND et par conséquent les signaux
de sortie S et Cout sont évalués en même temps.
 Si on inverse l’ordre des deux affectations: Cout <= (A AND B) OR (Cin AND (A XOR B));
on obtient le même résultat  L’ordre n’a aucun effet sur la synthèse .
Les instructions en VHDL s’exécutent d’une façon parallèle et leur ordre n’a
aucun effet sur le résultat de synthèse (mais pas toujours):
On parle d’instructions concurrentes ou de concurrence

22/120
Introduction
Additionneur 4 bits
Essayons maintenant de concevoir un programme VHDl pour la réalisation d’un

additionneur 4 bits:
A3 A2 A1 A0 B3 B2 B1 B0
Additionneur 4 bits Cin=0 (entrée retenue)
Cout (sortie retenue) S3 S2 S1 S0
Commençons par la section entité:
entity Add_4bits is
port (A,B: in std_logic_vector (3 downto 0);
Cin: in std_logic;
S: out std_logic_vector (3 downto 0);
Cout: out std_logic);
end Add_4bits;
23/120
Introduction
Additionneur 4 bits
Essayons maintenant de concevoir un programme VHDl pour la réalisation d’un
additionneur 4 bits:
A3 A2 A1 A0 B3 B2 B1 B0
Additionneur 4 bits Cin=0
Cout (sortie retenue) S3 S2 S1 S0
Inputs outputs
A A A A B B B B S s S S C
3 2 1 0 3 2 1 0 3 2 1 0 o
Pour 4
Approche DataFlow bits: 0 0 0 0 0 0 0 0
inappropriée . . . . . . . .
29=512 . . . . . . . .
1 1 1 1 1 1 11
24/120
Introduction
Additionneur 4 bits: architecture structurelle
• Approche Structurelle Par association d’additionneurs 1 bit complet.
cout3 cout1 cout0

cout2
Cin =0
(entrée retenue)
S4
(sortie retenue: Cout)
25/120
Introduction
Description structurelle en VHDL (1/5)
Considérons tout d’abord cet exemple générique d’un système hiérarchique
pouvant être décrit d’une façon structurelle.
Ce système est composé de 3 sous-systèmes (2 identiques (composant_A) et
un 3ème correspondant au composant_B).
Ent1 compA
compB Sortie
Ent2 compA
in1
Ent Sor Composant_B
Composant_A In2 outb
entity compA is entity compB is

Port (Ent: in std_logic; Port (in1,in2: in std_logic;
Sor: out std_logic); outb: out std_logic);
end compA; end compB;
architecture archA of compA is architecture archB of compB is
………. ………..
………. ………..
end archA; end archB;
26/120
Introduction
En ce qui concerne le système complet: connex1
 pour la section entité:
entity system is
Ent1 compA
port (Ent1, Ent2: in std_logic;
compB Sortie
Sortie: out std_logic) Ent2 compA
end system;
connex2
 pour la section architecture, il faut:
1. Déclarer les composants utilisés au niveau du système (instruction component):
component nom_composant
port (…………………..);
end nom_composant;
2. Déclarer les signaux internes au système et permettant de connecter les composants

(connex1 et connex2).
3. Instancier les composants et décrire les liaisons en effectuant un mapping des signaux
avec l’instruction port map.
27/120
Introduction
Ainsi la section architecture sera:
Unit0, unit1, unit2: utilisés juste pour
mieux documenter le système
Architecture arch of system is
component compA connex1

Port (Ent: in std_logic; Sor: out std_logic); Ent1 Unit0
end compA; (compA) Unit2
1 (compB) Sortie
Ent2 Unit1
component compB (compA)
Port (in1,in2: in std_logic;outb: out std_logic);
end system; connex2
2 signal connex1, connex2: std_logic; - - au niveau de l’architecture déclarer les signaux

- - en utilisant l’instruction signal
Begin
unit0: compA port map ( );

unit1: compA port map ( );
3
unit2: compB port map ( );
End arch;
28/120
Introduction
Description structurelle en VHDL (4/5): le programme complet
library ieee;
Déclaration des librairies
Use ieee.std_logic_1164.all;
entity compA is
Port (Ent: in std_logic; Sor: out std_logic);
end compA;
architecture archA of compA is

……….
……….
end archA;
Déclaration des sections
entité/Architecture des composants
library ieee; formant le système
entity compB is
Port (in1,in2: in std_logic; outb: out std_logic);
end compB;
architecture archB of compB is
………..
………..
end archB;
29/120
Introduction
Description structurelle en VHDL (5/5): le programme complet ‘suite’
entity system is
port (Ent1, Ent2: in std_logic;Sortie: out std_logic) Déclaration de la section entité
du système entier
end system;
Architecture arch of system is Déclaration de la section

architecture du système entier:
component compA
Port (Ent: in std_logic; Sor: out std_logic); • redéclarer les entrées/sorties
end compA; des composants:
component compB instruction component
Port (in1,in2: in std_logic;outb: out std_logic);
end system;
• déclarer les signaux internes
signal connex1, connex2: std_logic; du système: instruction signal
Begin
unit0: compA port map (Ent1,connex1);
• Instancier les composats et
unit1: compA port map (Ent2, connex2);
décrire les connexions entre :
unit2: compB port map (connex1, connex2, Sortie); instruction port map
end arch
30/120
Introduction
Additionneur 4 bits : description structurelle
Exercice :
Écrire en VHDL, un programme permettant de décrire sous forme structurelle

l’additionneur 4 bits (avec Cin et cout) .
31/120
Introduction
32/120
Introduction
cout3 cout1 cout0

cout2
Cin
(entrée retenue)
S4
(sortie retenue: Cout)
33/120
Introduction
Additionneur 4 bits (description structurelle)
34/120
Introduction
Duplication de composants: l’instruction generate
• Pour décrire d’une façon structurelle une architecture, il faut faire des
instanciations « port map » au nombre de composants utilisés.
Exemple: 1 additionneur de 32 bits  32 instanciations.
• L’instruction generate permet une instanciation multiple d’un composant

en une seule fois. La syntaxe est la suivante
Generate_label: FOR index_variable IN val_debut TO val_fin GENERATE
Nom_composant port map (liste des signaux) ;
END GENERATE generate_label ;
35/120
Introduction
Generate & instructions concurrentes
• Les instructions à l’intérieur d’une boucle Generate peuvent être des
instructions concurrentes telles que des assignations de signaux.
Pour chaque opération, un nombre d’opérateurs matériels correspondant au

nombre d’itérations est crée (Dans cet exemple 4 portes OR).
36/120
Introduction
L’instruction generate: decription structurelle de l’Additionneur 4 bits
Exemple: Réécrire l’architecture (description structurelle) de l’additionneur 4 bits :
37/120
Introduction
38/120
Introduction
39/120
Introduction
Pour changer la taille de l’additionneur de 4 à 8 bits (par exemple) , on doit changer

toutes les occurrences du paramètre (taille) dans le programme vhdl.
40/120
Introduction
Lisibilité du code: Paramètres Génériques (1/2)
Exemple: Réécrire l’architecture (description structurelle) de l’additionneur N bits :

Pour changer la taille de l’additionneur sans être obligé de changer les dimensions des
signaux déclarées dans la section port (meilleure flexibilité et lisibilité du code).
Indiquer au niveau de la section entity que la taille de l’additionneur est un paramètre

générique : generic ( Nom_paramètre: Type [:= valeur] );
41/120
Introduction
Lisibilité du code: Paramètres Génériques (2/2)
42/120
Introduction
Additionneur 4 bits: utilisation des opérateurs mathématiques
Pour ce cas ‘simple’, l’approche comportementale ou algorithmique se résume à un

appel de la fonction addition du package numeric_std : (dans ce cas, les opérandes
doivent être de type unsigned ou bien signed)
A B
(Cout)
S=A+B
Rq: A et B sont de type std_logic_vector
43/120
Introduction
Additionneur 4 bits: utilisation des opérateurs mathématiques (2/9)
On pourrait proposer cette solution !!

library ieee;
Use ieee.numeric_std.all;
(Cout)
entity Add_4bits is
port (A,B: in std_logic_vector (3 downto 0);
S: out std_logic_vector (4 downto 0) );
end Add_4bits;
architecture addarch of Add_4bits is

begin Les opérations arithmétiques ne
peuvent pas être effectuées sur
S <= A + B ; des signaux de type
end addarch ; std_logic_vector uniquement sur
des signaux de type signed ou
unsigned
44/120
Introduction
Il est évidement possible de faire l’addition avec des signaux A et B de type unsigned:
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Adder is
port ( A, B : in unsigned(3 downto 0); S : out unsigned(3 downto 0);
Cout : out std_logic );
end;
architecture Behavioral of Adder is

signal resultat_temp : unsigned(4 downto 0);
begin
resultat_temp <= ( ‘0’ & A ) + ( ‘0’ & B );
S <= temp(3 downto 0);
Cout <= temp(4); Même avec A et B de type Unsigned, il
faut les adapter à la taille du résultat
end architecture Behavioral;
Rq: On peut également utiliser le type integer (sans adaptation de la taille).Mais dans ce cas, on utilisera 32 bits pour chaque
signal (gaspillage)
45/120
Introduction
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE. STD_LOGIC_UNSIGNED.ALL;
entity Adder is
port ( A, B : in unsigned(3 downto 0); S : out unsigned (4 downto 0); );
end;
architecture Behavioral of Adder is
begin
S <= ( ‘0’ & A ) + ( ‘0’ & B );
end architecture Behavioral;
46/120
Introduction
Conversions entre types
47/120
Introduction
‘0’&A = 0 A3A2A1A0
• Il faut coder A et B sur 5 bits sans changer leurs valeurs
 En ajoutant (par concaténation: &) un ‘0’ à gauche: ‘0’&B = 0 B3B2B1B0
48/120
Introduction
Autres instructions concurrentes (combinatoires)
Évidement, les opérateurs arithmétiques et logiques ainsi que les simples assignations
ou affectations entre signaux ne sont pas suffisantes pour décrire le comportement de
circuits combinatoires plus évolués (Multiplexeur, Codeur,..).
 L’instruction WITH …SELECT ayant la syntaxe suivante:

WITH signal_name SELECT
signal_output <= signal1 WHEN valeur1 ,

signal2 WHEN valeur2 ,
……………………………. ,
…………………………… ,
signalN WHEN valeurN ,
autre_signal WHEN OTHERS ;
• valeur1,… valeurN sont relatives au signal signal_name
• Signal1, … signalN, autre_signal peuvent être remplacés par des valeurs de même
type que signal_output.
• la dernière ligne ‘ WHEN OTHERS ‘ est obligatoire.

49/120
Introduction
Autres instructions concurrentes (combinatoires)
 L’instruction WHEN …ELSE ayant la syntaxe suivante:
signal_output <= signal1 WHEN condition1 ELSE

signal2 WHEN condition2 ELSE
……………………………. ELSE
…………………………… ELSE
signalN WHEN conditionN
ELSE autre_signal ;
• Signal1, … signalN, autre_signal peuvent être remplacés par des valeurs de même
type que signal_output.
• la dernière ligne « ELSE ‘ autre_signal ‘ » est optionnelle, mais conseillée.
50/120
Introduction
Autres instructions concurrentes (combinatoires): MUX 1:4
Pour un multiplexeur (1:4), la sortie (output) prend

la valeur de l’une des entrées (In0, In1, In2 et In3)
en fonction des entrées de sélection (s0 et s1) :
s1s0= 00  output = In0

1. L’entité
51/120
Introduction
Autres instructions concurrentes (combinatoires): MUX 1:4
En ce qui concerne l’architecture, on peut la construire en utilisant l’une

des deux instructions (WITH…SELECT) et ( WHEN….ELSE) :
ARCHITECTURE MuxWith OF mux4_1 IS ARCHITECTURE MuxWhen OF mux4_1 IS
SIGNAL sel: std_logic_vector (1 DOWNTO 0); BEGIN

Output <= in0 WHEN (s1&s0)= “00“
BEGIN ELSE in1 WHEN (s1&s0)= “01“
Sel <= s1 & s0; -- concaténation de s1 et s0
ELSE in2 WHEN (s1&s0)= “10“
WITH sel SELECT
ELSE in3 WHEN (s1&s0)= “11“
Output <= in0 WHEN “00“,
in1 WHEN “01“, ELSE ‘X’ ;
in2 WHEN “10“, END MuxWith
in3 WHEN “11“,
‘X’ WHEN OTHERS ;
END MuxWith
52/120
Introduction
53/120
Introduction
54/120

Chap02 Langage VHDL Combinatoire

Transféré par

Droits d'auteur :

Formats disponibles

Chap02 Langage VHDL Combinatoire

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

Chap02 Langage VHDL Combinatoire

Transféré par

Droits d'auteur :

Formats disponibles

Université de Carthage

Institut National des Sciences Appliquées et de Technologie

Par Emir Damergi

 Si pour le premier, le développement et la fabrication peuvent être effectués

Équations logiques  Circuit (portes logiques + bascules)  Transistors

 Pour le deuxième, qui nécessite des millions de portes logiques, cette

Nécessité d’automatiser les étapes de développement des systèmes

• Ainsi, plusieurs outils permettant d’automatiser le développement sont apparus:

des « outils de synthèse ».

Les deux langages les plus utilisés sont:

 Le langage VHDL (VHSIC Hardware Description Language) ou VHSIC signifie Very

Au niveau de la programmation, on peut distinguer principalement 3 approches

 Description comportementale (Behavioral Description): c’est une description

 Description Structurelle (Structural Description): Il s’agit d’une vison

 Construire un additionneur 4 bits

 Additionneur 4 bits (comportementale)

1- Entity (entité): qui énumère les entrées et

S,Cout: out std_logic);

2- Architecture: qui décrit les

S  Cin  A  B end addarch;

library ieee; - - Déclaration de la librairie à utiliser.

entity Addcomplet is Mots réservés (VHDL)

• Ne doivent contenir que des

begin • Ils doivent impérativement

S,Cout: out std_logic); Le sens du signal :

• STD_LOGIC: pour décrire un bit.

• STD_LOGIC_VECTOR: pour représenter une suite (un vecteur) de N bits

 Exemples :A: std_logic_vector (7 downto 0);

C,D: std_logic_vector (3 downto 0);

B <= C & D; //Concténation

B <= “1001” & C;

C <= “1001” XOR D // toutes les opérandes de même taille

Rq: on ne peut appliquer des opérations arithmétiques sur des bits

• SIGNED: pour les entiers signés codés en Complément à 2 sur N bits.

 Exemples :A,B : signed (7 downto 0);

•INTEGER : nombre compris entre -2-31 et 231 – 1 (codé sur 32 bits)

•REAL: réels compris entre -1.79769E308 et 1.79769E308

Package Type Opérateurs

std_logic_signed • signed logiques.

C’est le type de base pour la description d’un signal binaire.

'U',-- état non initialisé

Si plusieurs signaux sont connectés à un même point, un seul peut imposer

Prenons à titre d’exemple, une matrice de 32*8 bits:

On peut la déclarer ainsi :

• matrice: array (0 to 31) of std_logic_vector (7 downto 0);

On peut également définir de nouveau types (en traitant le même exemple)

• type mot is std_logic_vector (7 downto 0)

L’accès au mot i (i: 0  31) de la matrice se fait comme suit:

type small_entier is range 0 to 1024; Intervalle d’entiers (limites entiers) .

• type probability is range 0.0 to 1.0; Intervalle de réels ( limites réelles).

•subtype entier_small is integer range -1024 to +1024;

 Des type énumérées (ensemble de valeurs discrètes) peuvent être également

Type date is record

 On voit bien que les deux affectations se trouvant

on obtient le même résultat  L’ordre n’a aucun effet sur la synthèse .

On parle d’instructions concurrentes ou de concurrence

Essayons maintenant de concevoir un programme VHDl pour la réalisation d’un

Additionneur 4 bits Cin=0 (entrée retenue)

Cout (sortie retenue) S3 S2 S1 S0