Vous êtes sur la page 1sur 74

Le VHDL

Le VHDL : SOMMAIRE

• Introduction
• II Éléments généraux du langage
• III Architecture du langage
• IV Exemples d’application
Le VHDL

I INTRODUCTION
Le VHDL
Le VHDL: Qu’est-ce que c’est, et à quoi cela
sert-il?

• VHDL: VHSIC Hardware Description Language


• VHSIC: Very High Speed Integrated Circuit (projet
de grande envergure du DoD (Departement of
Defense) Américain, mis en place dans les
années ’80
• Principe de base: Définir un langage de
description de matériel qui puisse être utilisé
pour simuler du matériel numérique
• Extension: Utilisation du même langage pour la
synthèse automatique de circuits
Le VHDL
VHDL: Est-ce le seul HDL?

• Il existe plusieurs autres langages de description


de matériel, entre autres:
 Verilog (Très populaire aux États-Unis, utilisé aussi en
Europe, au Japon et au Canada)
 UDL/1 (Utilisé à un certain moment au Japon)
 Estérel (langage académique – Français)
 HardwareC (langage académique – Stanford)
• Verilog est plus simple que le VHDL, mais est un
peu moins utilisé
Le VHDL
Pourquoi utiliser des langages HDL?

• Pour accélérer la conception de circuits (raisons


économiques)
• Pour permettre la conception de circuits très
complexes (1 milliard de portes logiques d’ici 5
ans)
• Pour pouvoir représenter les systèmes
numériques selon différents axes d’abstraction
• Pour utiliser et/ou améliorer le code pour des
systèmes futures
Le VHDL

II ELEMENTS GENERAUX DU LANGAGE


Le VHDL
I LES CLASSES D’OBJETS

Le langage vhdl comporte quatre classes d’objets


utilisés dans les zones de déclaration des
programmes:

Les signaux
Les variables
Les constantes
Les fichiers (ne sont pas synthétisables)
Le VHDL
II NOTION DE SIGNAL
Un signal correspond à la a
représentation matérielle du
b
support de l’information en
VHDL. s1

s2

L’affectation de signal (a <= s3


‘0’) permet de faire évoluer
s4
au cours du temps les
valeurs présentes sur le z

signal.
2 4 6 8 10 12
Temps (ns)
Le VHDL
Exemple d’affectation de signal (utile pour la simulation)

a<=1 after 4ns,0 after 8ns,1 after 12ns;


a

b Attention : Les expressions doivent être


ordonnées selon un ordre croissant des
s1 délais.

s2

s3

s4

2 4 6 8 10 12
Temps (ns)
Le VHDL
Propriétés des signaux

Chaque signal a trois propriétés : son type, sa


valeur et sa valeur antérieure.
Les signaux sont déclarés dans les entités et la
partie déclarative des architectures.
Attention, on ne peut pas les déclarer dans un process
Les signaux ne reçoivent leur assignation définitive
que lorsque le process a fini son exécution.
Le VHDL
III Les variables
Les variables se déclarent dans le domaine séquentiel d’un PROCESS,
d’une PROCEDURE ou d’une FONCTION.
On peut leur donner une valeur initiale. Cette valeur initiale est attribuée à
chaque appel de la PROCEDURE ou de la FONCTION. Elles servent à
manipuler des variables temporaires/intermédiaires pour faciliter le
développement d'un algorithme séquentiel.
Une affectation de variable est immédiate dans un process.
Syntaxe :
VARIABLE var_name {, var_name} : type [:= value];
Exemple :
VARIABLE i : INTEGER RANGE 0 TO 3; -- valeur intiale 0
VARIABLE x : std_ulogic; -- valeur intiale 'U'
Assignation de variable:
i:=3;
x:=0;
Le VHDL
Le VHDL
IV Les constantes
Les constantes sont utilisées pour référencer une valeur ou un type
spécifique.
Elles permettent une meilleur lecture et maintenance d'une source.
De tous types, elles sont utilisées dans les architectures ou les
package.

Syntaxe

CONSTANT const_name {, const_name} : type := value;

Exemple

constant BUS_WIDTH : integer := 8;


Le VHDL
V La déclaration Generic

La section GENERIC_DECLARATIONS dans l'entête ENTITY


permet de définir des paramètres exploitables dans
l'architecture.
Cette méthode d'écriture permet une maintenance plus
aisée.

Exemple

ENTITY entity_name IS
GENERIC(TP : time := 30ns);
Port( déclarations);
END [entity_name];
Le VHDL
VII TYPAGE DES OBJETS

Le typage des objets permet en premier lieu de


protéger les affectations d’objets en restreignant les
possibilités d’affectations aux objets de même type.
Le VHDL
1 Les TYPES prédéfinis

Les types prédéfinis reconnaissent six objets scalaires ayant


une valeur unique à chaque instant:
Std_logic : représente un élément binaire avec les valeurs '0' , '1' et ‘Z’
(haute impédance);
Std_logic_vector : représente un tableau d'éléments binaires ;
Boolean : représente une donnée pouvant être TRUE ou FALSE ;
Integer : est un entier pouvant aller de –2E32 à
(2E32-1), pouvant être comprise entre 2 valeurs limites par la
déclaration : integer range mini to maxi.
Character : représente un caractère ASCII;
Le VHDL
2 Le TYPE énuméré (Machine à états)
TYPE permet de définir un type utilisateur auquel on peut
assigner un objet.
Tous les objets doivent être assignés à un type. Chaque TYPE
déclaré doit être unique.

Syntaxe
TYPE identifier IS (enumeration_type_literals);

Exemple
TYPE couleur IS (rouge, orange,vert);
TYPE op_type IS (opadd, opor, opand, opxor);
Il devient alors possible d’utiliser un signal de ce type en le
déclarant par :
Signal feu1, feu2 : couleur;
Le VHDL
3 Le TYPE tableau
Le type tableau est un groupement de types identiques.
Les tableaux peuvent être multidimentionels.
Il existe deux sortes de tableaux :
Les tableaux avec contrainte (Constrained Array)
Ces tableaux sont définis avec des dimensions figées (rangées colonnes).
Les tableaux sans contrainte (Unconstrained Array)
Ces tableaux sont définis sans préciser les dimensions. Le tableau est donc
dynamique.

Syntaxe
TYPE identifier IS ARRAY
[unconstrained_array_definition];
[constrained_array_definition];

Exemple

TYPE data_bus IS ARRAY (0 to 31) OF bit; -- tableau de 32 bit


TYPE 4x8 IS ARRAY (3 downto 0) OF std_logic_vector (7 downto 0);
--tableau de 4 mots de 8 bits
TYPE string IS ARRAY (positive RANGE <>) OF character;
TYPE bit_vector IS ARRAY (natural RANGE <>) OF bit;
TYPE dim2 IS ARRAY (0 TO 7, 0 TO 7) OF bit; -- tableau à deux dimensions
Le VHDL
4 Le TYPE physique
Cette définition de type représente une quantité physique.
La base des unités doit être spécifiée. Les valeurs sont calculées à partir de
cette base.

Syntaxe
TYPE identifier IS RANGE implementation_defined;
UNITS
base_unit_declaration
[secondary_unit_declaration]
END UNITS;

Exemple
TYPE time IS RANGE implementation_defined;
UNITS

ps = 1000fs;
ns = 1000ps;
us = 1000ns;
ms = 1000us;
sec = 1000ms;
min = 60sec;
hr = 60min;
END UNITS;
Le VHDL
5 Le TYPE fichier
Pour écrire et/ou lire dans un fichier externe, il faut :
Insérer la bibliothèque textio :
Library std;
Use std.textio.all;
Déclarer le fichier en précisant son type et le mode d’ouverture (entrée et/ou sortie) :
File FILE_R : text is in ’’données.dat’’;
File FILE_W : text is out ’’résultats.dat’’;
Déclarer une variable ligne de type LINE :
Variable L : LINE;
Pour lire une ligne dans le fichier, il faut d'abord lire la ligne dans le fichier puis lire la valeur
d'une variable R dans la ligne (la valeur lue est convertie automatiquement dans le type de la
variable R) :
readline(FILE_R, L);
read(L, R);
Pour écrire, c'est le même procédé, sauf qu'on écrit d'abord la valeur R dans la ligne, puis la
ligne dans le fichier :
write (L, R);
writeline(FILE_W, L);
Il existe une fonction endfile(…) qui retourne vrai lorsque le fichier est terminé, et faux sinon.
Pour stopper le test_bench, on peut envoyer un message du type :
assert FALSE report "fin de fichier" severity failure
Le VHDL
6 Le TYPE pointeur
Ils ne sont pas synthétisables du fait de leur caractère dynamique.
Ils sont strictement réservés au domaine fréquentiel, et peuvent
être associés soit à une constante soit à une variable, mais pas
aux signaux.
Syntaxe :
TYPE pointeur IS ACCESS typeobjet;
Exemple:
Variable pt : pointeur;
Pt := NEW typeobjet;
-- allocation dynamique d’un objet en mémoire.
La libération du pointeur se fait avec deallocate(pt)
Le VHDL
7 Le TYPE structure
Les structures permettent de regrouper un ou plusieurs champs de type différents et
fournissent un accès au champ par leur nom. Un type record peut être associé à une
variable comme à un signal.
Exemple:
TYPE data IS RECORD
Bus1,bus2 : bit;
durée : time;
Données : integer range 0 to 255;
End record;
Signal enregistrement1 : data;
Enregistrement1.bus1<=‘1’;
Enregistrement1 <= (‘0’,’1’,durée,données);
Le VHDL
8 Les sous-type :SUBTYPE

SUBTYPE est une restriction d’un type à un sous domaine de


ce type.

Exemple
TYPE colors IS (red, yellow, blue, green, black);
SUBTYPE primary IS colors RANGE red TO blue;

TYPE integer IS RANGE -2147483647 TO 2147483647;


SUBTYPE absolu IS integer 0 TO 2147483647;

TYPE area IS ARRAY (natural RANGE <>, natural RANGE <>)


OF bit;
SUBTYPE small_area IS area (0 TO 10, 0 TO 10);
Le VHDL

III ARCHITECTURE DU LANGAGE


Le VHDL
III) Structure d’une description VHDL simple.

Une description VHDL est


composée de 2 parties
indissociables à savoir :

- L’entité (ENTITY), elle


définit les entrées et sorties.
- L’architecture
(ARCHITECTURE), elle
contient les instructions
VHDL permettant de réaliser
le fonctionnement attendu.
Le VHDL
III.1) Déclaration des bibliothèques.

Toute description VHDL utilisée pour la synthèse a besoin de


bibliothèques. L’IEEE (Institut of Electrical and Electronics Engineers) les
a normalisées et plus particulièrement la bibliothèque IEEE1164. Elles
contiennent les définitions des types de signaux électroniques, des
fonctions et sous programmes permettant de réaliser des opérations
arithmétiques et logiques,...
Library ieee;
Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;

La directive Use permet de sélectionner les bibliothèques à utiliser.


Le VHDL
III.2) Déclaration de l’entité et des entrées / sorties
(I/O).
Elle permet de définir le NOM de la description VHDL ainsi que les entrées et sorties
utilisées, l’instruction qui les définit c’est port :
Syntaxe:
entity NOM_DE_L_ENTITE is
port ( Description des signaux d’entrées /sorties …);
end NOM_DE_L_ENTITE;
Exemple :
entity SEQUENCEMENT is
port (
CLOCK : in std_logic;
RESET : in std_logic;
Q : out std_logic_vector(1 downto 0) );
end SEQUENCEMENT;
Remarque : Après la dernière définition de signal de l’instruction port il ne faut jamais
mettre de point virgule.

L’instruction port .
Syntaxe: NOM_DU_SIGNAL : sens type;
Exemple: CLOCK: in std_logic;
BUS : out std_logic_vector(7 downto 0);
On doit définir pour chaque signal : le NOM_DU_SIGNAL, le sens et le type.
Le VHDL
III.2.1) Le NOM et le SENS du SIGNAL.

Le NOM du signal.
Il est composé de caractères, le premier caractère
doit être une lettre, sa longueur
est quelconque, mais elle ne doit pas dépasser une
ligne de code. VHDL n’est pas
sensible à la « casse », c’est à dire qu’il ne fait pas
la distinction entre les majuscules
et les minuscules.

Le SENS du signal.
- in : pour un signal en entrée.
- out : pour un signal en sortie.
- inout : pour un signal en entrée sortie
- buffer : pour un signal en sortie mais utilisé
comme entrée dans la description.
Le VHDL III.3) Déclaration de l’architecture correspondante à
l’entité : description du fonctionnement.

L’architecture décrit le Exemples :


fonctionnement souhaité pour un -- Opérateurs logiques de base
circuit ou une partie du circuit. entity PORTES is
En effet le fonctionnement d’un port (A,B :in std_logic;
circuit est généralement décrit par Y1,Y2,Y3,Y4,Y5,Y6,Y7:out
plusieurs modulesVHDL. Il faut std_logic);
end PORTES;
comprendre par module le couple
architecture DESCRIPTION of
ENTITE/ARCHITECTURE. Dans le PORTES is
cas de simples PLDs on trouve begin
souvent un seul module. Y1 <= A and B;
L’architecture établit à travers les Y2 <= A or B;
instructions les relations entre les Y3 <= A xor B;
entrées et les sorties. On peut Y4 <= not A;
avoir un fonctionnement purement Y5 <= A nand B;
Y6 <= A nor B;
combinatoire, séquentiel voire les
Y7 <= not(A xor B);
deux séquentiel et combinatoire. end DESCRIPTION;
Le VHDL
IV) Les instructions de base (mode « concurrent »), logique
combinatoire.

Qu’est ce que le mode « concurrent » ? Pour une description VHDL toutes


les instructions sont évaluées et affectent les signaux de sortie en même
temps. L’ordre dans lequel elles sont écrites n’a aucune importance. En effet
la description génère des structures électroniques, c’est la grande différence
entre une description VHDL et un langage informatique classique.
Dans un système à microprocesseur, les instructions sont exécutées les
unes à la
suite des autres.
Avec VHDL il faut essayer de penser à la structure qui va être générée par le
synthétiseur pour écrire une bonne description, cela n’est pas toujours
évident.
Le VHDL

Exemple : Pour le décodeur 2 vers 4 de la page 5,


l’ordre dans lequel seront écrites
les instructions n’a aucune importance.
architecture DESCRIPTION of DEMUX2_4 is
begin
D0 <= (not(IN1) and not(IN0)); -- première
instruction
D1 <= (not(IN1) and IN0); -- deuxième instruction
D2 <= (IN1 and not(IN0)); -- troisième instruction
D3 <= (IN1 and IN0); -- quatrième instruction
end DESCRIPTION;
L’architecture ci dessous est équivalente :
architecture DESCRIPTION of DEMUX2_4 is
begin
D1 <= (not(IN1) and IN0); -- deuxième instruction
D2 <= (IN1 and not(IN0)); -- troisième instruction
D0 <= (not(IN1) AND not(IN0)); -- première
instruction
D3 <= (IN1 AND IN0); -- quatrième instruction
end DESCRIPTION;
Le VHDL
IV.1) Les opérateurs.
IV.1.1) L’affectation simple : <=

Dans une description VHDL, c’est certainement l’opérateur le plus utilisé. En effet il
permet de modifier l’état d’un signal en fonction d’autres signaux et/ou d’autres opérateurs.
Exemple avec des portes logiques : S1 <= E2 and E1 ;

Les valeurs numériques que l’on peut affecter à un signal sont les suivantes :
- ‘1’ ou ‘H’ pour un niveau haut avec un signal de 1 bit.
- ‘0’ ou ‘L’ pour un niveau bas avec un signal de 1 bit.
- ‘Z’ pour un état haute impédance avec un signal de 1 bit.
-‘-’ pour un état quelconque, c’est à dire ‘0’ ou ‘1’. Cette valeur est très utilisée avec les
instructions : when … else et with …. Select ….

- Pour les signaux composés de plusieurs bits on utilise les guillemets


" … " , voir les exemples ci dessous :
- Les bases numériques utilisées pour les bus peuvent être :
BINAIRE, exemple : BUS <= "1001" ; -- BUS = 9 en décimal
HEXA, exemple : BUS <= X"9" ; -- BUS = 9 en décimal
OCTAL, exemple : BUS <= O"11" ; -- BUS = 9 en décimal

Remarque : La base décimale ne peut pas être utilisée lors de l’affectation de signaux. On peut
seulement l’utiliser avec certains opérateurs, comme + et – pour réaliser des compteurs
Le VHDL

Exemple:
Library ieee;
Use ieee.std_logic_1164.all;
entity AFFEC is
port (
E1,E2 : in std_logic;
BUS1,BUS2,BUS3 : out std_logic_vector(3 downto 0);
S1,S2,S3,S4 : out std_logic);
end AFFEC;
architecture DESCRIPTION of AFFEC is
begin
S1 <= '1'; -- S1 = 1
S2 <= '0'; -- S2 = 0
S3 <= E1; -- S3 = E1
S4 <= '1' when (E2 ='1') else 'Z'; -- S4 = 1 si E1=1 sinon S4 prend la valeur haute
impédance
BUS1 <= "1000"; -- BUS1 = "1000"
BUS2 <= E1 & E2 & "10"; -- BUS2 = E1 & E2 & 10
BUS3 <= x"A"; -- valeur en HEXA -> BUS3 = 10(déc)
end DESCRIPTION;
Le VHDL
IV.1.2) Opérateur de concaténation : Exemples :
&. S1 <= A sll 2 ; -- S1 = A décalé de 2 bits à
gauche.
Cet opérateur permet de joindre des S2 <= A rol 3 ; -- S2 = A avec une rotation de
signaux entre eux . 3 bits à gauche
Exemple : S3 <= not (R); -- S3 = R
-- Soit A et B de type 3 bits et S1 de Remarque : Pour réaliser des décalages
type 8 bits logiques en synthèse logique, il est
préférable d’utiliser les instructions
-- A = "001" et B ="110" suivantes :
S1 <= A & B & "01" ;
-- S1 prendra la valeur suivante après Décalage à droite :
cette affectation -- Si A est de type std_logic_vector(7 downto
-- S1 = "001110 01" 0)
S1 <= ‘0’ & A(7 downto 1); -- décalage d’un bit
IV.1.3) Opérateurs logiques. à droite
S1 <= "000" & A(7 downto 3); -- décalage de
trois bits à droite

Décalage à gauche :
-- Si A est de type std_logic_vector(7 downto
0)
S1 <= A(6 downto 0) & ‘0’; -- décalage d’un bit
à gauche
S1 <= A(4 downto 0) & "000"; -- décalage de
trois bits à gauche
Valeur de A Valeur de B
"001“ "110“
Le VHDL
IV.1.4) Opérateurs arithmétiques.

Remarque N°1 : Pour pouvoir utiliser les opérateurs ci-


dessus il faut rajouter les bibliothèques suivantes au début
du fichier VHDL:
Use ieee.numeric_std.all ;
Use ieee.std_logic_arith.all ;
Exemples :
S1 <= A – 3 ; -- S1 = A – 3
-- On soustrait 3 à la valeur de l’entrée / signal A
S1 <= S1 + 1 ; -- On incrémente de 1 le signal S1
Remarque N°2 : Attention l’utilisation de ces opérateurs
avec des signaux comportant un nombre de bits important
peut générer de grandes structures électroniques.
Exemples :
S1 <= A * B ;-- S1 = A multiplié par B : A et B sont
codés sur 4 bits
S2 <= A / B ;-- S2 = A divisé par B : A et B sont codés
sur 4 bits
Le VHDL

VI.1.5) Opérateurs relationnels.


Ils permettent de modifier l’état d’un signal ou de signaux suivant le
résultat d’un test ou d’une condition. En logique combinatoire ils sont
souvent utilisés avec les instructions :
- when … else …
- with …. Select ….
Le VHDL
IV.2) Les instructions du mode « concurrent ».
IV.2.1) Affectation conditionnelle :
Cette instruction modifie l’état d’un signal suivant le résultat d’une condition
logique entre un ou des signaux, valeurs, constantes.
SIGNAL <= expression when condition
[else expression when condition]
[else expression];
Remarque : l’instruction [else expression] n’est pas obligatoire mais elle
fortement conseillée, elle permet de définir la valeur du SIGNAL dans le
cas où la
condition n’est pas remplie.

Exemple N°1 :
-- S1 prend la valeur de E2 quand E1=’1’ sinon S1 prend la --
valeur ‘0’
S1 <= E2 when ( E1= ‘1’) else ‘0’;
Schéma correspondant :
Le VHDL

Exemple N°2 :
-- Structure évoluée d’un multiplexeur 4
vers 1
S2 <= E1 when (SEL="00" ) else
E2 when (SEL="01" ) else
E3 when (SEL="10" ) else
E4 when (SEL="11" )
else ‘0’;
Le VHDL
Exemple de systèmes : additionneur 1-bit

s1
In1
Demi-additionneur Demi-additionneur
In2 HA1 HA2

s2
C_in

Demi-additionneur
Somme
s3 C_out
OR1
Le VHDL
Exemple d’architecture du demi-
additionneur

library IEEE;
use IEEE.std_logic_1164.all;

entity demi_add is
port(a, b: in bit;
som, ret: out bit);
end demi_add;

architecture comportement_concurrent of demi_add is


begin
som <= (a xor b) ;
ret <= (a and b) ;
end comportement_concurrent;
Le VHDL IV.2.2) Affectation sélective :
Cette instruction permet d’affecter différentes valeurs à un signal, selon les valeurs
prises par un signal dit de sélection.

with SIGNAL_DE_SELECTION select


SIGNAL <= expression when valeur_de_selection,
[expression when valeur_de_selection,]
[expression when others];

Remarque: l’instruction [expression when others] n’est pas obligatoire mais


fortement conseillée, elle permet de définir la valeur du SIGNAL dans le cas où la
condition n’est pas remplie.

Exemple N°1 :
-- Multiplexeur 4 vers 1
with SEL select
S2 <= E1 when "00",
E2 when "01",
E3 when "10",
E4 when "11",
'0' when others;

Remarque: when others est nécessaire car il faut toujours définir les autres cas du
signal de sélection pour prendre en compte toutes les valeurs possibles de celui-ci.
Le VHDL

Schéma correspondant après synthèse:


En conclusion, les descriptions précédentes
donnent le même schéma, ce qui est
rassurant. L’étude des deux instructions montre
toute la puissance du langage VHDL pour
décrire un circuit électronique, en effet si on
avait été obligé d’écrire les équations avec des
opérateurs de base pour chaque sortie, on
aurait eu les instructions suivantes :

S2 <= (E1 and not(SEL(1)) and not(SEL(0)))


or (E2 and not SEL(1) and (SEL(0)) or (E3
and SEL(1) and not(SEL(0))) or (E4 and
SEL(1) and SEL(0));
L’équation logique ci-dessus donne aussi le
même schéma, mais elle est peu
compréhensible, c’est pourquoi on préfère des
descriptions de plus haut niveau en utilisant les
instructions VHDL évoluées.
Le VHDL
Exemple : mémoire morte
library IEEE;
use IEEE.std_logic_1164.all;
entity memoire_morte is
port (addr1 : in std_logic_vector (2 downto 0);
reg0, reg1, reg2, reg3,reg4 :in std_logic_vector (31 downto 0);
mem1: out std_logic_vector (31 downto 0));
end memoire_morte;

architecture comportemental of memoire_morte is


begin
with addr1 select
mem1 <= reg0 when ‘‘000’’,
reg1 when ‘‘001’’,
reg2 when ‘‘010’’,
reg3 when ‘‘011’’,
reg4 when others;
end comportemental;
Le VHDL

V) Les instructions du mode séquentiel.


V.1) Définition d’un PROCESS.

Un process est une partie de la description d’un circuit dans laquelle les
instructions
sont exécutées séquentiellement c’est à dire les unes à la suite des autres.
Il permet d’effectuer des opérations sur les signaux en utilisant les instructions
standard de la programmation structurée comme dans les systèmes à
microprocesseurs.

L’exécution d’un process est déclenchée par un ou des changements d’états


de signaux logiques. Le nom de ces signaux est défini dans la liste de
sensibilité lors de la déclaration du process.

[Nom_du_process :] process(Liste_de_sensibilité_nom_des_signaux)
Begin
-- instructions du process
end process [Nom_du_process] ;
Remarque: Le nom du process entre crochet est facultatif, mais il peut être
très utile pour repérer un process parmi d’autres lors de phases de mise au
point ou de simulations.
Le VHDL
Règles de fonctionnement d’un process :

1) L’exécution d’un process a lieu à chaque changement d’état d’un


signal de la liste de sensibilité.
2) Les instructions du process s’exécutent séquentiellement.
3) Les changements d’état des signaux par les instructions du process
sont pris en compte à la fin du process.
Le VHDL
Les processus: exemple d’un compteur
simple de 8 bits
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all;
ENTITY compt IS
PORT (
h: IN STD_LOGIC;
q: OUT INTEGER RANGE 0 TO 7
);
END compt;

ARCHITECTURE archi OF compt IS


SIGNAL test: INTEGER RANGE 0 TO 7;
BEGIN

PROCESS
BEGIN
WAIT UNTIL h='1';
test <= test+ 1;
END PROCESS;

q <= test;
END archi;
Le VHDL
V.2) Les deux principales structures utilisées dans un process.

L’assignation conditionnelle L’assignation sélective

case signal_de_slection is
if condition then
when valeur_de_sélection => instructions
instructions
[when others => instructions]
[elsif condition then instructions]
end case;
[else instructions]
end if ;
Exemple:
case SEL is
Exemple:
when “000” => S1 <= E1;
if (RESET=’1’) then SORTIE <=
when “001” => S1 <= ‘0’;
”0000”;
when “010” | “011” => S1 <=’1’;
-- La barre | permet de réaliser
-- un ou logique entre les deux
-- valeurs “010” et “011”
when others => S1 <= ‘0’;
end case;
Remarque: ne pas confondre
=> (implique) et <= (affecte).
Le VHDL
Exemple : Un décodeur 7 segments

library IEEE; WHEN "0111" => segment_data <= "1110000";


use IEEE.STD_LOGIC_1164.all; WHEN "1000" => segment_data <= "1111111";
use IEEE.STD_LOGIC_ARITH.all;
use IEEE.STD_LOGIC_UNSIGNED.all; WHEN "1001" => segment_data <= "1111011";
WHEN "1010" => segment_data <= "1110111";
ENTITY dec_7seg IS WHEN "1011" => segment_data <= "0011111";
PORT(hex_digit : IN STD_LOGIC_VECTOR(3 downto WHEN "1100" => segment_data <= "1001110";
0);
segment_a, segment_b, segment_c, segment_d, WHEN "1101" => segment_data <= "0111101";
segment_e, segment_f, segment_g : out std_logic); WHEN "1110" => segment_data <= "1001111";
END dec_7seg; WHEN "1111" => segment_data <= "1000111";
WHEN OTHERS => segment_data <= "0111110";
ARCHITECTURE a OF dec_7seg IS
SIGNAL segment_data : STD_LOGIC_VECTOR(6
END CASE;
DOWNTO 0); END PROCESS;
BEGIN
-- extract segment data and LED driver is inverted
PROCESS (Hex_digit)
-- HEX to 7 Segment Decoder for LED Display
BEGIN segment_a <= NOT segment_data(6);
segment_b <= NOT segment_data(5);
CASE Hex_digit IS segment_c <= NOT segment_data(4);
segment_d <= NOT segment_data(3);
WHEN "0000" => segment_data <= "1111110";
WHEN "0001" => segment_data <= "0110000"; segment_e <= NOT segment_data(2);
WHEN "0010" => segment_data <= "1101101"; segment_f <= NOT segment_data(1);
WHEN "0011" => segment_data <= "1111001"; segment_g <= NOT segment_data(0);
WHEN "0100" => segment_data <= "0110011";
END a;
WHEN "0101" => segment_data <= "1011011";
WHEN "0110" => segment_data <= "1011111";
Le VHDL
Exemple : MEMOIRE de 2 mots

-- Les adresses 0 et 1 sont accessibles en lectures et en -- Process for memory write operation
écritures
PROCESS
BEGIN
LIBRARY IEEE;
WAIT UNTIL clock'event and clock='1';
USE IEEE.STD_LOGIC_1164.all;
IF (reset = '1') THEN
ENTITY memory IS
-- initial values for memory (optional)
PORT(read_data : OUT std_logic_vector(7 DOWNTO 0);
mem0 <= "01010101";
read_address : IN std_logic_vector(2 DOWNTO 0);
mem1 <= "10101010";
write_data : IN std_logic_vector(7 DOWNTO 0);
ELSE
write_address : IN std_logic_vector(2 DOWNTO 0);
-- Write to memory?
Memwrite : IN std_logic;
-- use a flip-flop with an enable for memory
clock,reset : IN std_logic);
IF memwrite = '1' THEN
END memory;
CASE write_address IS
ARCHITECTURE behavior OF memory IS
WHEN "000" => mem0 <= write_data;
SIGNAL mem0, mem1 : std_logic_vector(7 DOWNTO 0);
WHEN "001" => mem1 <= write_data;
BEGIN
-- unimplemented memory locations
-- Process for memory read operation
WHEN OTHERS => NULL;
PROCESS (read_address, mem0, mem1)
END CASE;
BEGIN
END IF;
CASE read_address IS
END IF;
WHEN "000" => read_data <= mem0;
END PROCESS;
WHEN "001" => read_data <= mem1;
END behavior;
-- unimplemented memory locations
WHEN OTHERS => read_data <= "11111111";
END CASE;
END PROCESS;
Le VHDL
Exemple : MEMOIRE de plusieurs mots

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.all;
USE IEEE.STD_LOGIC_ARITH.all;
USE IEEE.STD_LOGIC_UNSIGNED.all;

ENTITY bmemory IS
PORT(read_data : OUT std_logic_vector(7 DOWNTO 0);
read_address : IN std_logic_vector(2 DOWNTO 0);
write_data : IN std_logic_vector(7 DOWNTO 0);
write_address : IN std_logic_vector(2 DOWNTO 0);
Memwrite : IN std_logic;
clock : IN std_logic);
END bmemory;

ARCHITECTURE behavior OF bmemory IS


-- definition d’un type de données tableau pour la mémoire
TYPE memory_type IS ARRAY (0 TO 7) OF std_logic_vector(7 DOWNTO 0);
SIGNAL memory : memory_type;
BEGIN
-- Lecture de la Mémoire
-- Conversion de l’indice de ligne en entier avec CONV_INTEGER
read_data <= memory(CONV_INTEGER(read_address(2 DOWNTO 0)));
-- Ecriture dans la mémoire ?
PROCESS
BEGIN
WAIT UNTIL clock'event and clock='1';
IF (memwrite = '1') THEN
-- Conversion de l’indice de ligne en entier avec CONV_INTEGER
memory(CONV_INTEGER(write_address(2 DOWNTO 0))) <= write_data;
END IF;
END PROCESS;
END behavior;
Le VHDL
Exemple mémoire : Utilisation de la bibliothèque de fonction
de Max plus + II
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.all;
LIBRARY lpm;
USE lpm.lpm_components.ALL;

ENTITY memory IS
PORT(read_data : OUT std_logic_vector(7 DOWNTO 0);
memory_address: IN std_logic_vector(2 DOWNTO 0);
write_data: IN std_logic_vector(7 DOWNTO 0);
Memwrite : IN std_logic;
clock,reset: IN std_logic);
END memory;
ARCHITECTURE behavior OF memory IS
BEGIN
data_memory: lpm_ram_dq
GENERIC MAP (lpm_widthad => 3, -- taille des adresses : sur 3
bits
lpm_outdata => "UNREGISTERED",
lpm_indata => "REGISTERED",
lpm_address_control => "UNREGISTERED",
-- Reads in mif file for initial data values
lpm_file => "memory.mif",
lpm_width => 8)

PORT MAP (data => write_data, address => memory_address(2 DOWNTO 0), we => Memwrite, inclock =>
clock, q => read_data);
END behavior;
Le VHDL
Les fichiers .mif : les 12 premières valeurs
du sinus

DEPTH= 256;
WIDTH= 8;

ADDRESS_RADIX = DEC;
DATA_RADIX = DEC;

CONTENT
BEGIN
0 : 127;
1 : 130;
2 : 133;
3 : 136;
4 : 139;
5 : 142;
6 : 145;
7 : 148;
8 : 151;
9 : 154;
10 : 157;
11 : 160;
12 : 163;
Le VHDL
Une ALU en VHDL
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.all;
USE IEEE.STD_LOGIC_ARITH.all;
USE IEEE.STD_LOGIC_UNSIGNED.all;

ENTITY ALU IS
PORT( Op_code : in std_logic_vector(2 DOWNTO 0);
A_input, B_input: in std_logic_vector(7 DOWNTO 0);
ALU_output : out std_logic_vector(7 DOWNTO 0));

END ALU;

ARCHITECTURE behavior OF ALU IS


SIGNAL temp_output: std_logic_vector(7 DOWNTO 0);

BEGIN
PROCESS (Op_code, A_input, B_input)
BEGIN
-- Select Arithmetic/Logical Operation
CASE Op_Code (2 DOWNTO 1) IS
WHEN "00" =>
temp_output <= A_input + B_input;
WHEN "01" =>
temp_output <= A_input - B_input;
WHEN "10" =>
temp_output <= A_input AND B_input;
WHEN "11" => -- Select Shift Operation
IF Op_Code(0) = '1' THEN
-- Shift bits left with zero fill using concatination operator
Alu_output <= temp_output(6 DOWNTO 0) & '0';
ELSE
Alu_output <= temp_output;
END IF;
END CASE;
END PROCESS;
END behavior;
Le VHDL
V.3) Les autres structures utilisées dans LIBRARY ieee;
un process. La commande : For loop USE ieee.std_logic_1164.all;
USE ieee.std_logic_arith.all;
ENTITY codage IS
PORT (
Syntaxe
a: IN STD_LOGIC_VECTOR(3 DOWNTO 0);
FOR paramètre IN intervalle (Ex:0 to 5) s : OUT STD_LOGIC_VECTOR(3 DOWNTO
LOOP 0)
);
Instructions; END codage;
END LOOP;
ARCHITECTURE archi OF codage IS
Exemple: codage de données:
BEGIN
Le cahier des charges est le suivant : PROCESS
BEGIN
s0 = a0
s(0) <= a(0);
pour i>0 Si = ai . ai-1 + /ai . /ai-1 FOR i IN 1 TO 3 LOOP
S(i)<=(a(i) AND a(i-1)) OR ( NOT a(i) AND NOT
a(i-1));
END LOOP;
END PROCESS;
END archi;
Le VHDL
V.4 L’instruction « wait »

Il est possible de définir un Exemple de wait et d’attributs: flip-flop


« process » sans liste de library IEEE;
dépendance. Chaque « process » use IEEE.std_logic_1164.all;
est toujours exécuté au moins une
fois, au début entity dff is
En ajoutant des énoncés « wait », il port(D, Clk: in std_logic;
devient possible d’indiquer que le Q, QN: out std_logic);
« process » sera réveillé à un end dff;
certain endroit, selon une certaine
condition: architecture comp_dff of dff is
wait for time; constant delai: Time:= 5 ns;
wait on signal; begin
One_ff: process
wait until condition;
begin
wait until (Clk’event and Clk = ‘1’);
Q <= D after delai;
QN <= not D after delai;
end process One_ff;
end comp_dff;
Le VHDL
VI Les attributs et les fonctions de conversion
Les attributs permettent d'ajouter des informations supplémentaires à un signal,
variable ou un composant.
Syntaxe
object_name'attribut_name
Syntaxe des attributs pour le type ARRAY ou scalaire
X'HIGH élément le plus grand ou borne maximale
X'LOW élément le plus petit ou borne minimale
X'LEFT élément de gauche ou borne de gauche
X'RIGHT élément de droite ou borne de droite

Syntaxe des attributs pour SIGNAL


x'EVENT retourne TRUE si x change d'état
x'ACTIVE retourne TRUE si x a changé durant le dernier intervalle
x'LAST_EVENT retourne une valeur temporelle depuis le dernier changement de x
x'LAST_ACTIVE retourne une valeur temporelle depuis la dernière transition de x
x'LAST_VALUE retourne la dernière valeur de x

Ces attributs créent un nouveau SIGNAL


x'DELAYED(t) crée un signal du type de x retardé par t
x'STABLE(t) retourne TRUE si x n'est pas modifié pendant le temps t
x'QUIET(t) crée un signal logique à TRUE si x n'est pas modifié pendant un temps t
x'TRANSACTION crée un signal logique qui bascule lorsque x est change d'état
Le VHDL
VI Les attributs et les fonctions de conversion
(suite)
-- Les fonctions de conversion de type
FUNCTION To_bit ( s : std_ulogic; xmap : BIT := '0') RETURN BIT;
FUNCTION To_bitvector ( s : std_logic_vector ; xmap : BIT := '0') RETURN BIT_VECTOR;
FUNCTION To_bitvector ( s : std_ulogic_vector; xmap : BIT := '0') RETURN BIT_VECTOR;
FUNCTION To_StdULogic ( b : BIT ) RETURN std_ulogic;
FUNCTION To_StdLogicVector ( b : BIT_VECTOR ) RETURN std_logic_vector;
FUNCTION To_StdLogicVector ( s : std_ulogic_vector ) RETURN std_logic_vector;
FUNCTION To_StdULogicVector ( b : BIT_VECTOR ) RETURN std_ulogic_vector;
FUNCTION To_StdULogicVector ( s : std_logic_vector ) RETURN std_ulogic_vector;

FUNCTION CONV_INTEGER (ARG: STD_ULOGIC) return INTEGER;


FUNCTION CONV_UNSIGNED(ARG: STD_ULOGIC; SIZE: INTEGER) return UNSIGNED;
FUNCTION CONV_STD_LOGIC_VECTOR(ARG: INTEGER; SIZE: INTEGER) return
STD_LOGIC_VECTOR;

-- Détection des fronts des signaux


FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
Le VHDL
VII Communication entre processus

• Les signaux sont globaux: il est possible à un


processus d’accéder (lire et/ou écrire) un signal
d’un autre processus
• La communication entre processus se fait donc
à l’aide de signaux
• Note: on parle ici de processus qui font partie
d’une même architecture…
• Exemple: additionneur 1-bit
Le VHDL
Exemple de communication entre
processus: additionneur 1-bit

s1
In1
Demi-additionneur Demi-additionneur
In2 HA1 HA2

s2
C_in

Demi-additionneur
Somme
s3 C_out
OR1
Le VHDL
Exemple de communication entre
processus: additionneur 1-bit
library IEEE; HA2: process(s1, C_in)
use IEEE.std_logic_1164.all; begin
Somme <= (s1 xor C_in) after delai;
s2 <= (s1 and C_in) after delai;
entity add_1_bit is
end process HA2;
port(In1, In2, C_in: in std_logic;
Somme, C_out: out std_logic);
OR1: process(s2, s3)
end add_1_bit; begin
C_out <= (s2 or s3) after delai;
architecture comp_add of add_1_bit is end process OR1;
signal s1, s2, s3: std_logic; end comp_add;
constant delai: Time:= 5 ns;
begin
HA1: process(In1, In2)
begin
s1 <= (In1 xor In2) after delai;
s3 <= (In1 and In2) after delai;
end process HA1;
Le VHDL
1 Représentation hiérarchique

• On peut utiliser VHDL de façon hiérarchique et


ainsi simplifier la description d’une machine
complexe.
• Pour cela, on associe entre eux plusieurs
composants élémentaires (couples :
entité/architecture) dont on connecte les sorties
sur les entrées adéquates.
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: portes XOR et AND
library IEEE; library IEEE;
use IEEE.std_logic_1164.all; use IEEE.std_logic_1164.all;

entity one_xor is entity one_and is


port(In1, In2 : in std_logic; port(In1, In2 : in std_logic;
Z: out std_logic); Z: out std_logic);
end one_xor; end one_and;

architecture comp_xor of one_xor is architecture comp_and of one_and is


constant delai: Time:= 5 ns; constant delai: Time:= 5 ns;
begin begin
z <= (In1 xor In2) after delai; z <= (In1 and In2) after delai;
end comp_xor; end comp_and;
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: porte OU
library IEEE;
use IEEE.std_logic_1164.all;

entity one_or is
port(In1, In2 : in std_logic;
Z: out std_logic);
end one_or;

architecture comp_or of one_or is


constant delai: Time:= 5 ns;
begin
z <= (In1 or In2) after delai;
end comp_or;
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: demi-additionneur
library IEEE; -- 2° attribution des circuits à leur ENTITY
use IEEE.std_logic_1164.all; for XOR1: xor_gate use entity
work.one_xor(comp_xor);
entity one_half_adder is for AND1: and_gate use entity
port(In1, In2 : in std_logic; work.one_and(comp_and);
sum, c_out: out std_logic); Begin
end one_half_adder; -- 3° affectation des liaisons du schéma aux
broches des composants
architecture comp_ha of one_half_adder is
-- 1° recensement de tous les composants
du schéma
XOR1:xor_gate port map(In1, In2, sum);
component xor_gate
port (In1, In2: in std_logic; AND1:and_gate port map(In1, In2,
c_out);
z: out std_logic);
end component;
end comp_ha;

component and_gate
port (In1, In2: in std_logic;
z: out std_logic);
end component;
Le VHDL
2 Les composants
Le composant est déclaré dans la zone déclarative de l’architecture dans laquelle
il est utilisé.
La syntaxe est la suivante :

COMPONENT NOM_DU_COMPOSANT
Port (entrées,… : in type; sorties : out type)
End component;
Le composant a un nom propre dans l’architecture. Puis, on indique la
localisation (répertoire source) du composant.
for C1: NOM_DU_COMPOSANT use entity
NOM_REPERTOIRE_COMPOSANT.NOM_ENTITE(NOM_ARCHI);
Enfin, on définit les liaisons existantes entre les ports du composants et les
connexions de l’architecture.
C1 : NOM_DU_COMPOSANT
Port map(entrées sorties à utiliser);
Le VHDL
Exemple de représentation hiérarchique: un
additionneur: l’ensemble
library IEEE; for HA1: half_addr use entity
use IEEE.std_logic_1164.all; work.one_half_adder(comp_ha);
for HA2: half_addr use entity
entity one_adder is work.one_half_adder(comp_ha);
port(In1, In2, C_in : in std_logic; for OR1: or_gate use entity
sum, c_out: out std_logic); work.one_or(comp_or);
end one_adder;
signal s1, s2, s3: std_logic;
architecture comp_add of one_adder is begin
component half_addr
HA1:half_addr port map(In1, In2, s1,
port (In1, In2: in std_logic; s3);
sum, c_out: out std_logic);
HA2:half_addr port map(s1, C_in, sum,
end component; s2);
OR1:or_gate port map(s2, s3, c_out);
component or_gate
end comp_add;
port (In1, In2: in std_logic;
z: out std_logic);
end component;
Le VHDL
VIII Les Package : fonctions et procédures
PACKAGE déclare une fonction ou une procédure.
Le nom défini par PACKAGE BODY doit être le même que celui
déclaré par PACKAGE.
Syntaxe :
PACKAGE package_name IS
[type_declaration]
[constant_declaration]
..
[fonctions]
[component_declaration]
END [package_name];

PACKAGE BODY packname of package_name IS


[type_declaration]
[subtype_declaration]
[constant_declaration]
..
[subprogram_declaration]
END [packname];
Le VHDL
IX Les Fonctions
Les FONCTIONS sont des blocs d'instructions qui retournent une
valeur unique.
Les fonctions peuvent être appelées de différents endroits.
Les paramètres passés sont du type IN et les objets de classe
SIGNAL ou CONSTANT.
On peut déclarer des variables locales à l'intérieur d'une fonction.
Ces variables perdent leur valeur à chaque sortie de la fonction et
sont initialisées à chaque appel.
Une fonction peut être déclarée dans un PACKAGE ou dans le corps
d'une ARCHITECTURE.

Syntaxe :
FUNCTION nom_fonction (liste des entrées ) RETURN type_name IS
BEGIN
variables;
instructions;
END nom_fonction;
Le VHDL
Exemple : utilisation d’une fonction
« retard »

LIBRARY ieee; -- déclaration de la fonction PACKAGE BODY my_funcs of myfuncs IS


FUNCTION delay(newval : IN std_logic; -- corps
USE ieee.std_logic_1164.all; de delay
USE work.myfuncs.all; -- on déclare la delay01 : IN time;
bibliothèque utilisateur myfuncs delay10 : IN time) RETURN time;
BEGIN

PACKAGE myfuncs IS CASE newval IS


FUNCTION delay(newval : IN std_logic; --
entête de delay WHEN '0' => RETURN delay01; -- retourne la
valeur delay01
WHEN '1' => RETURN delay10; -- retourne la
delay01 : IN time; -- les paramètres n'ont valeur delay10
pas le même nom, c'est l'ordre qui compte WHEN OTHERS => IF (delay01 > delay10) THEN --
retourne la plus grande valeur
delay10 : IN time) RETURN time; -- RETURN delay01;
retourne un nombre de type time ELSE
END myfuncs; RETURN delay10;
END IF;
END CASE;
END delay;
END my_funcs;
Le VHDL
Exemple :
LIBRARY ieee;
USE ieee.std_logic_1164.all;

ENTITY nor2 IS
GENERIC (tphl : time := 10.0ns; -- déclaration
des temps de propagation
tplh : time := 15.0ns);

PORT (a,b : IN std_logic;


z : OUT std_logic);
END nor2;

ARCHITECTURE behavior OF nor2 IS


BEGIN

dly: PROCESS(a,b)
VARIABLE newstate : std_logic;
BEGIN

newstate := a NOR b;
z <= newstate AFTER delay(a NOR b,tplh,tphl);
-- appel de la fonction delay

END PROCESS dly;


END behavior;
Le VHDL
Exemple
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY nor2 IS
GENERIC (tphlmin, tplhmin: time := 3.0ns; -- déclaration des temps de propagation
tphltyp : time := 8.0ns;
tplhtyp : time := 6.5ns;
tphlmax, tplhmax: time := 13.0ns);
PORT (a,b : IN std_logic;
z : OUT std_logic);
END nor2;
ARCHITECTURE behavior OF nor2 IS
BEGIN
dly0: PROCESS(a,b);
BEGIN
IF a = '0' AND b = '0' THEN -- il faut résoudre tous les cas puisque tplhtyp < ou >
tphltyp
z <= '1' AFTER tplhmin;
ELSIF a = '0' AND b = '1' THEN
z <= '0' AFTER tphlmin;
ELSIF a = '1' AND b = '0' THEN
z <= '0' AFTER tphlmin;
ELSIF a = '1' AND b = '1' THEN
z <= '0' AFTER tphlmin;
END IF;
END PROCESS dly0;
END behavior;
Le VHDL
X Les procédures
• Les PROCEDURES sont des blocs d'instructions qui permettent d‘
effectuer des calculs et qui peuvent être appelées de différents endroits.
Les paramètres passés sont du type IN, OUT et INOUT et les objets de
classe SIGNAL, CONSTANT ou VARIABLE. Le mode par défaut du type IN
est de classe CONSTANT. OUT et INOUT sont considérés comme de
classe VARIABLE. En fait, le paramètre CONSTANT IN peut être associé
avec un signal, variable, constante ou une expression lorsque la
procédure est appelée.
Une procédure peut être déclarée dans un PACKAGE ou dans le corps
d'une ARCHITECTURE.
On peut déclarer des variables locales à l'intérieur d'une procédure. Ces
variables perdent leur valeur à chaque sortie de la procédure et sont
initialisées à chaque appel.
Une procédure peut contenir un WAIT sauf si elle est appelée par un
PROCESS avec une liste de sensibilité ou depuis une FONCTION.

• syntaxe
PROCEDURE procedure_name (parameter_list) IS
BEGIN
variables;
instructions;
END [procedure_name];
Le VHDL
Exemple : Procédure
• LIBRARY ieee; -- déclaration de la procédure
USE ieee.std_logic_1164.all;
PACKAGE myfuncs IS
• PROCEDURE addparity(VARIABLE d : IN std_logic_vector(7 DOWNTO 0);
• do, de : OUT std_logic_vector(8 DOWNTO 0)); -- les paramètres n'ont pas le même
nom, c'est l'ordre qui compte
• END myfuncs;

PACKAGE BODY myfuncs IS


• PROCEDURE addparity(VARIABLE d IN std_logic_vector(7 DOWNTO 0); -- corps de la
procédure
• do, de : OUT std_logic_vector(8 DOWNTO 0)) IS -- do et de sont les valeurs de sorties
de la procédure
VARIABLE temp : std_logic;
BEGIN
• temp := '0';
loop1: FOR i IN 7 DONWTO 0 LOOP
• temp := temp XOR d(i);
• END LOOP loop1;
de := temp & d;
do := NOT temp & d;
• END addparity;
• END myfuncs;
Le VHDL
Exemple
• LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.myfuncs.all; -- on déclare la bibliothèque utilisateur myfuncs
ENTITY parity_add IS

• PORT (din : std_logic_vector(7 DOWNTO 0);

• douto, doute : OUT std_logic_vector(8 DOWNTO 0));

• END parity_add;

ARCHITECTURE behv OF parity_add IS


BEGIN

• PROCESS(din)
VARIABLE dintemp : std_logic_vector(7 DOWNTO 0);
VARIABLE dptempo,dptempe : std_logic_vector(8 DOWNTO 0);
BEGIN

• dintemp := din;
addparity(dintemp,dptempo,dptempe);
douto <= dptempo;
doute <= dptempe;

• END PROCESS;
• END behv;

Vous aimerez peut-être aussi