Langage VHDL:L'essentiel pour démarrer

Emmanuelle Peuch
 TABLE DES MATIERES

I. Structure d’une description VHDL _______________________________________________ 3

II. Librairies - paquetages _______________________________________________________ 4
III. Les données : classe et type ___________________________________________________ 6
I. Les classes _______________________________________________________________________ 6
I.1 Les signaux ____________________________________________________________________________6
I.2 Les variables ___________________________________________________________________________6
I.3 Les constantes__________________________________________________________________________7
II. Les types de données ______________________________________________________________ 8
II.1 Les bits et l’extension std_logic ____________________________________________________________8
II.2 Les types std_logic_vector et bus de données en électronique / opérateur concaténation _____________9
II.3 Les booléens (boolean) __________________________________________________________________10
II.4 Les types unsigned et signed et exemple d'utilisation __________________________________________10
II.5 Les entiers (integer) ____________________________________________________________________11
II.6 Les types énumérés: création de ses propres types ___________________________________________11
II.7 Le type tableau (array) __________________________________________________________________12
II.8 Les enregistrements (record) _____________________________________________________________12

IV. Les opérations de base sur les objets _________________________________________ 14

V. Les attributs _______________________________________________________________ 15
VI. Les instructions concurrentes _______________________________________________ 16
I. Les instructions d’affectation conditionnelles _________________________________________ 17
II. Les process _____________________________________________________________________ 18
III. Les instructions " generate " _______________________________________________________ 19
VII. Les instructions séquentielles _______________________________________________ 21
I. Instruction de test If … Else ________________________________________________________ 22
II. Instruction de test CASE … WHEN ___________________________________________________ 22
III. VHDL pour la simulation: Les boucles FOR ____________________________________________ 23
IV. VHDL pour la simulation: Les boucles WHILE __________________________________________ 24
VIII. Différentes façons de décrire un composant en VHDL ____________________________ 24
I. Descriptions comportementales ____________________________________________________ 26
II. Description structurelle ___________________________________________________________ 27
IX. Procédures et fonctions ____________________________________________________ 28
I. Les fonctions ____________________________________________________________________ 28
I.1 Syntaxe ______________________________________________________________________________28
I.2 Exemple______________________________________________________________________________28
II. Les procédures __________________________________________________________________ 29
II.1 Syntaxe ______________________________________________________________________________30
II.2 Exemple______________________________________________________________________________30
III. Déclaration des sous-programmes au sein de paquetages _______________________________ 31

Emmanuelle Peuch
Annexes

Rappel de quelques principes sur la logique combinatoire et sur la logique séquentielle

Mots réservés du VHDL

Création d’un paquetage : documentation ISE fundation

Emmanuelle Peuch
VHDL

Langage de description VHDL

I. Structure d’une description VHDL

 Entité et architecture

Entrées .. Structure
logique
.. Sorties
. .

En VHDL, une structure logique est décrite à l’aide d’une entité et d’une architecture.

La paire {entité – architecture} forme un composant: elle est appelée component.

entitynom_entiteis L'entité définit les signaux d'entrées et

port ( de sorties (et éventuellement les
paramètres génériques)
Liste des entrées sorties de la structure en explicitant pour
chacune d’entre elles sonnom, sadirection (in, out) et sontype
Ces ports sont des bits ou des bus de
); données (std_logic ou std_logic_vector)

endnom_entite; Entité = vue externe

architecturenom_architectureofnom_entiteis

Zone de déclaration des objets (signaux, constantes), des L’architecture décrit le fonctionnement
types. Ces déclarations sont locales au bloc considéré et
sont optionnelles.
du circuit auquel est attachée une entité.

begin Architecture = description interne du

composant
Description de la structure logique, domaine concurrent ;

end nom_architecture;

Création du fichier<nom>.vhd
Un fichier .vhd est donc un fichier texte constitué d'une entité et d'une architecture.

Les entrées sorties du composantsont des signaux particuliers dont il faut spécifier le sens (la
direction) d’utilisation. Ce sont les signaux d'interface de l'entité et ils sont appelés des ports.

E. Peuch 3
VHDL

Mode Sens

Input La broche concernée est une entrée

Output La broche concernée est une sortie

Inout La broche est bidirectionnelle

La broche concernée est une sortie, mais elle peut être

Buffer
utilisée en lecture à l’intérieur du composant.

La traduction schématique est la suivante :

Extérieur
Intérieur
Mode OUT

Mode IN
Mode buffer

Mode inout

Le mode Inout (bidirectionnel) est déconseillé sur certaines architectures de FPGA (ils ne
possèdent pas de buffer trois états internes).
Donc en général pour que la description VHDL soit transportable d'un fabricant à l'autre, on
n'utilise que les ports IN et OUT (ce qui n'est pas du tout bloquant).

Conventions d’écritures :
- Il n’y a pas de différence entre majuscules et minuscules.
- La longueur d’un identificateur est limitée à celle d’une ligne.
- Un identificateur est composé de lettres (mais sans accents et ç), du symbole _ (underscore)
et de chiffres mais il doit commencer par une lettre ; il n’accepte pas deux symboles _
successifs.
- Une liste de mots est réservée à la syntaxe du langage VHDL : ces mots sont donc interdits
comme identificateurs (la liste est disponible en annexe).

II. Librairies - paquetages

Une librairie (library) comprend différents éléments qui peuvent être des composants, des sous-
programmes ou plus simplement des types de données. C’est une collection de modules
VHDLdéjà synthétisés, utilisés fréquemment et partageables par plusieurs concepteurs. Au sein
d’une librairie, ces éléments sont regroupés dans un paquetage (package).

E. Peuch 4
VHDL

Package= collection d’éléments regroupés dans un même fichier.

Une librairie par défaut, work, est systématiquement associée à l’environnement de travail de
l’utilisateur.

L'ouverture d'une librairie se fait à l'aide de l'instruction:

Librarynom_de_la_librairie;
La déclaration d’utilisation d’un paquetage se fait à l’aide de l’instruction use : les
informations de ce paquetage sont alors visibles.
useIEEE.STD_LOGIC_1164.ALL;

Exemple

L’entête de nos fichiers de programmes VHDL est par défaut la suivante :

Ouverture de la librairie IEEE (la librairie est visible).

library IEEE; IEEE = The Institute of Electrical and Electronics Engineers

On accède au paquetage STD_LOGIC_1164 de la librairie

use IEEE.STD_LOGIC_1164.ALL;
IEEE. L’extension .ALL permet de rendre visible la totalité
des informations du paquetage.

Petite histoire des librairies et paquetages

La librairie std est la librairie standard de VHDL et contient les paquetages standard (contient les
types et fonctions prédéfinies classiquement) et textio. Elle contient donc les types de base bit,
integer, boolean, caracter, real, string, bit_vector (bus de données).

Depuis 1992, un standard a été défini et agréé par IEEE : c’est le standard IEE 1164qui comporte
neuf états de base comme, par exemple, la définition d’état haute impédance (Z), la possibilité
de disposer d’états inconnus (X). Pour ce standard il a été défini le type std_ulogic, remplaçant
le type bit et le type std_ulogic_vector remplaçant le type bit_vector.

Tous les synthétiseurs n’acceptent pas ces 9 valeurs. Il a été défini le sous type std_logic qui est
maintenant le type utilisé (à la place du type bit)ainsi que le type std_logic_vector (à la place
de bit_vector).

Ces deux types sont décrits de façon plus précise dans le chapitre suivant.

Dans le chapitre "les procédures" on trouvera un exemple de création d'un paquetage.

E. Peuch 5
VHDL

III. Les données : classe et type

Une donnée appartient à une classe qui définit, avec son type, son comportement.
Des données de deux classes différentes mais de même type peuvent échanger des informations
directement.

La portée des noms est en général locale : un nom déclaré à l’intérieur d’une architecture n’est
connu que dans celle-ci.

I. Les classes
Il existe trois classes : signaux, variables et constantes.

I.1 Les signaux

Ils représentent les données physiques échangées entre des blocs logiques d’un circuit (les
interconnexions entre circuits).

Syntaxe de déclaration (dans la partie déclarative d’une architecture) :

signalnom1, nom2 : type ;

Affectation d’une valeur (dans le corps d’une architecture ou d’un processus) :

nom1<= valeur compatible avec le type ;

La valeur affectée peut être le résultat d’une expression, simple ou conditionnelle, ou la valeur
renvoyée par l’appel d’une fonction.

Al’extérieur d’un process, toutes les affectations de signaux sont concurrentes.

L’affectation d’une valeur à un signal traduit une connexion « physique » (soudure par
exemple), il s’agit donc d’une opération permanente ! Il serait donc aberrant d’affecter plus
d’une fois une valeur à un signal !

L'instruction d’affectation simple pour les signaux:<=Signifie " prend la valeur de"
ou " reçoit "

I.2 Les variables

Les variables sont des objets qui servent à stocker un résultat intermédiaire pour faciliter la
construction d’un algorithme séquentiel.
Elles ne peuvent donc être utilisées que dans les process, les procédures et les fonctions,
également dans les boucles « generate » qui servent à créer des schémas répétitifs.

Pour synthétiser un système électronique, on évitera d'utiliser les variables. On leur

préfèrera les signaux qui ont un sens physique contrairement aux variables!

E. Peuch 6
VHDL

Syntaxe de déclaration (dans la partie déclarative d’un process, d’une fonction ou procédure) :
variable nom1, nom2 : type [ := expression];
NB : tout ce qui est mis entre crochet [ ] est facultatif.

L’expression facultative (dans la déclaration de la variable) permet de donner à une variable une
valeur initiale choisie par l’utilisateur.

Affectation d’une valeur :

nom1 :=valeur compatible avec le type ;

La valeur affectée peut être le résultat d’une expression ou la valeur renvoyée par une fonction.

Différences entre variable et signal

La variable n’a pas d’équivalent physique dans le schéma électronique contrairement au
signal. C'est un intermédiaire de calcul utilisé pour décrire algorithmiquement un traitement.
Le résultat de ce traitement sera ensuite affecté à un signal.
Le signal permet d'interconnecter des composants: les signaux sont donc des connexions
permanentes et concurrentes. Ils représentent les canaux ou fils par lesquels transitent les
informations numériques.
Il est possible d’affecter la valeur d’une variable à un signal pourvu que les
types soient compatibles.

I.3 Les constantes

Les constantes sont des objets dont la valeur est fixée une fois pour toute. On déclare une
constante dans le domaine séquentiel comme dans le domaine concurrent.

Exemple

'0' (valeur d’un objet de type bit)

''01101'' (valeur d’un objet de type std_logic_vector)
189 (valeur d’un objet de type entier)

On peut créer des constantes nommées :

constantnom1 : type [ := valeur_constante] ;

E. Peuch 7
VHDL

On déclare :
- une constantedans le domaine séquentiel comme dans le domaine concurrent,
- une variableuniquement dans le domaine séquentiel. L’affectation d’une valeur à une
variable se fait par := à l’intérieur d’un processus. La variable a alors été déclarée entre
process et begin,
- un signaluniquement dans le domaine concurrent.

II. Les types de données

VHDL connaît un certain nombre de types de base adaptés à l’électronique numérique.

II.1 Les bits et l’extension std_logic

Pour pouvoir utiliser les types std_logic et std_logic_vectoril faut déclarer dans le fichier .vhd
que l'on utilise le paquetage std_logic_1164:

use IEEE.STD_LOGIC_1164.ALL;

Le type actuellement le plus utilisé en remplacement du type bit est le type std_logic.
Nous utilisons donc maintenant le type std_logic et non plus le type bit !

Déclaration :
signalnom : std_logic ;
constantnom : std_logic := '0';
variablenom : std_logic ;

Info
L'IEEE définit en 1993 le standard IEEE1164 qui normalise la représentation des signaux
multi valeurs et qui étend la portée des opérateurs à ce nouveau type. C'est un complément au
standard IEEE1076 et tous les outils de développement d'aujourd'hui doivent intégrer cette
extension.

Le standard IEEE 1164 contient des types définis dont :

STD_LOGIC ('U','X','0','1','Z','W','L','H','-'):

qui signifient
'U' valeur non initialisée
'X' valeurinconnue
'0' niveaulogique bas
'1' niveaulogiquehaut
'Z' état haute impédance

E. Peuch 8
VHDL

'W' valeurinconnue*
'L' niveaulogique bas*
'H' niveaulogiquehaut*
'-' valeur indifférente

*'W', 'L' et 'H' représentent respectivement un état inconnu, un niveau 0 et un niveau 1 mais ont un niveau plus
faible que 'X', '0' et '1'. Ces valeurs sont essentiellement utilisées pour la simulation.

D'un point de vue synthèse (réalisation d'un composant), il ne faut utiliser que
les valeurs '0', '1' et 'Z'.

Affectation d’une valeur à S qui est un signal de type std_logic :

S <= '0' ;
S <= A and B ; -- A et B étant des std_logic

II.2 Les types std_logic_vectoret bus de données en électronique / opérateur

concaténation

Signal nom :std_logic_vector(7 downto 0) ;

- Définit un bus de 8 bits
- Le bit de poids fort est à gauche et est repéré par l'indice 7.

L'indice de gauche représente toujours le bit de poids fort.

Rappel : le type bit n’est plus utilisé et est remplacé par le type std_logic. Il en est donc de même
pour définir un bus de données : nous utiliserons le type std_logic_vector !

Affectation :
nom<= ''10001010''; -- Les bits de rang 7 , 3 et 1 sont à 1 et les autres sont à 0.
Ou alors
nom<= X"8A" -- X"valeur" indique une valeur en hexadécimale

Constant nom1 : std_logic_vector(7downto 0) := ''11111011'' ;

On accède à un élément quelconque à l’aide d’un indice.

nom(7) <= '0' ; --le bit de rang (d'indice) 7 (MSB) est mis à 0

On peut aussi accéder à un groupe d'éléments du tableau:

nom(5 downto 3) <= "111"; -- Les bits de rang 3 à 5 sont mis à 1.

E. Peuch 9
VHDL

Il est possible de fusionner deux vecteurs, c’est la concaténation (&), pour affecter les
valeurs correspondantes à un bus plus grand.

Déclaration des bus de données :

Signal etat : std_logic_vector (4 downto 0) ;
Signal sous_etat1 : std_logic_vector (1 downto 0) ;
Signal sous_etat2 : std_logic_vector (2 downto 0) ;

Concaténation :

Etat <= sous_etat1 & sous_etat2 ;

Cet opérateur est très utile pour décrire un registre à décalage.

Remarque

1- Les indices peuvent être définis dans le sens croissant :

Signal nom :std_logic_vector(0 to 7) ;
- Définit un bus de 8 bits
- Le bit de poids fort est à gauche et est repéré par l'indice 0.

2- L'indexation peut commencer à une valeur différente de 0:

Signal D:std_logic_vector(10 downto 5) représente un bus de largeur 6.

II.3 Les booléens (boolean)

Le type booléen peut prendre deux valeurs : « true » ou « false ». Il intervient essentiellement
comme résultat d’expressions de comparaisons (dans des IF ou dans des Whenelse, valeurs
renvoyées par une fonction…).

II.4 Les types unsigned et signed et exemple d'utilisation

Ils sont définis dans le paquetage numeric_stdcomme des tableaux de std_logic. Ils permettent
d'avoir une représentation binaire d'un nombre signé en complément à 2(signed) ou non signé
(unsigned) ainsi qu'un sens mathématique. C’est-à-dire qu'on peut effectuer des opérations
arithmétiques avec des signaux de type unsigned ou signed, chose que l'on ne peut pas faire
directement avec des signaux de type std_logic ou std_logic_vector qui n'ont qu'un sens
purement physique.

E. Peuch 10
VHDL

Déclaration :
signalnom : signed(3 downto 0) ;
signalnom : unsigned(3 downto 0) ;
constantnom : signed(3 downto 0) := "1101"; -- ou unsigned

Convertir des nombres signés ou non signés en std_logic_vector

Avec
Signal sortie:std_logic_vector(3 downto 0);-- signal interne ou port de sortie (Out)
Signal interne:unsigned(3 downto 0);

On peut par exemple faire les opérations suivantes:

Interne <= interne + 1; -- on utilise un signal de type signe ou unsigned pour effectuer des opérations
arithmétiques (+, -,…)

Sortie <= std_logic_vector(interne);-- on peut ensuite placer le résultat dans un bus de données (un vecteur)
via la fonction de conversion de type std_logic_vector

On utilise cette technique pour réaliser des compteurs binaires, des diviseurs de fréquence,…

II.5 Les entiers (integer)

VHDL manipule des valeurs entières qui correspondent à des mots de 32 bits ou 64 bits.

Il faut consulter le paquetage standard du compilateur utilisé pour connaître le format des
nombres entiers !

Déclaration :
signalnom : integer ;
variablenom : integer ;
constantnom : integer ;

Lors de l’utilisation d'un objet de type integer, il est possible de définir ses champs d’utilisation
afin de réduire son encombrement physique. Pour cela l’opérateur rangepermet de spécifier son
étendue :

signal nom : integer range 0 to 4095 ;

II.6 Les types énumérés: création de ses propres types

L’utilisateur peut créer ses propres types, par simple énumération de toutes les valeursque
pourra prendre un objet déclaré de ce type.

E. Peuch 11
VHDL

On utilise cette technique pour la description des machines d'états

Architecture version1 of exempleis
Type bulleis (repos, start, ecriture, stop) ;

Signal etat_present, etat_futur: bulle; -- on déclare les objets etat_present et etat_futur

comme étant de type bulle
Begin
…
Etat_futur<= start; -- on affecte la valeur start au signal etat_futur
-- On utilise le symbole d'affectation <= car etat_futur est un signal !
…
End version1;

II.7 Le type tableau (array)

Le type tableau permet d'accéder à des parties d'un objet en utilisant un indice.

Info
Les types std_logic_vector, unsigned et signed sont définis comme des tableaux de std_logic !

Pour décrire par exemple une mémoire, on utilise un tableau.

Exemple

Mem:

Déclaration Case 0
Case 1
Type exemple_tableauisarray (7 downto 0) of
Case 2 1101
std_logic_vector(3 downto 0;
Signal mem:exemple_tableau;

Case 7
Affectation
mem(2) <= "1101"; Chaque case à une longueur de
4, c’est à dire qu’on peut y
stocker des mots de 4 bits

II.8 Les enregistrements (record)

Les enregistrements (record) définissent des collections d’objets de types, ou de sous types,
différents.

E. Peuch 12
VHDL

Type clock_time is record Définition d’un type :

heure : integer range 0 to 12 ; heure, minute et seconde sont les champs
minute, seconde : integer range 0 to 59 ; de l’objet record clock_time.
End record ;

signalheure_du_jour : clock_time ; Déclaration d’un objet de ce type.

heure_du_jour.heure <= 3 ;
heure_du_jour.minute <= 45 ; Utilisation de l’objet déclaré :on accède à un
heure_dujour.seconde <=55 ; élément de clock_time par son champ.

chrono <=heure_du_jour.seconde ; chrono doit donc être un signal de type

integer.

heure_du_jour <= (3,45,55) ; L’ensemble d’un enregistrement peut être

manipulé par son nom.

E. Peuch 13
VHDL

IV. Les opérations de base sur les objets

Le langage VHDL comporte six classes d’opérationsavec un niveau de priorité défini pour chaque
classe.
Lors de l’évaluation d’une expression, l’opération dont la classe a la plus haute priorité est
effectuée en premier. Cependant, il est conseillé d’utiliser les parenthèses ne serait ce que pour
améliorer la lisibilité de l’écriture !

Le tableau ci-dessous regroupe la liste des opérateurs classés par priorité croissante (de haut en
bas). Ainsi, les opérateurs logiques ont le niveau de priorité le plus faible, excepté l’opérateur
not!

Classes Opérateurs(du moins Types d’opérandes Résultat

prioritaire au plus prioritaire)

std_logic, std_logic_vector
and, or, nand, nor, std_logic, ou
Op. logiques (pour résultat booléen)ou
xor, xnor booléen
booléen
Tous types scalaire (std_logic,
Op. relationnels = /= <<= >>= std_logic_vector, integer, booléen
unsigned, signed, booléen)
Unsigned,
+ - Unsigned, signed, integer
signed, integer
Op. d’addition
std_logic et
& (concaténation) std_logic et std_logic_vector
std_logic_vector
Unsigned,
Unsigned, signed, integer
signed, integer
* /
Op. de
multiplication(liés à la
mod (modulo)
multiplication) Unsigned,
rem(calcul du reste) Unsigned, signed, integer
signed, integer

std_logic, std_logic_vector std_logic, ou

Not (op.logique) (pour résultat booléen) ou booléen
booléen
Numérique
Op. divers Abs
Numérique
** (exponentiation) numérique
Ax s’écrit A ** x
Numérique

On notera que tous les opérateurs logiques de la première ligne ont la même priorité !Il est
donc fortement conseillé de placer les parenthèses dans toute expression contenant ces
opérateurs.
Les opérateurs arithmétiques sont utilisables avec les signed et unsigned si on a déclaré au
préalable le packetagenumeric_std:use iee.numeric_std.all

E. Peuch 14
VHDL

V. Les attributs

Un attribut est une propriété associée à un type, un objet (signal, variable, constante), à une
entité: il en précise les propriétés. Cette propriété, une fois définie, peut être utilisée dans des
expressions.

L'utilisation d'attributs permet par exemple de déterminer de façon dynamique la taille

d’un tableau, le domaine de définition d’un objet scalaire, l’élément suivant d’un type
énuméré ou de détecter la transition montante d’un signal, d'attribuer des numéros de
broches à des signaux d’entrées sorties,……

L’utilisation d’un attributse fait au moyen d’un nom composé :

Le préfixe est le nom de l’objet auquel est rattaché l’attribut,
Le suffixe est le nom de l’attribut,
Préfixe et suffixe sont séparés par une apostrophe ' :

Tableau_ou_type_ou_nom_de_signal' nom_attribut

Comme pour les types, il existe des attributs prédéfiniset des attributs utilisateur
(user_defined).

Quelques attributs prédéfinis du VHDL synthétisables

Attribut Agit sur Valeur retournée

‘left Valeur du rang le plus à gauche
Type tableau
‘right Valeur du rang le plus à droite.
‘high Elément le plus grand
Type scalaire
‘low Elément le plus petit
‘high Valeur du rang le plus haut.
Type tableau
‘low Valeur du rang le plus bas
‘length Type tableau Entier qui est la longueur du tableau
‘pos(v) Type scalaire Position de l’élément v dans le type
‘val(p) Type scalaire Valeur de l’élément de position p dans le type
‘succ(v) Valeur qui suit (position + 1) l’élément de valeur v dans
Type scalaire
le type
‘pred(v) Valeur qui précède (position - 1) l’élément de valeur v
Type scalaire
dans le type
‘leftof(v) Type scalaire Valeur de l’élément juste à gauche de l’élément de
valeur v
‘rightof(v) Type scalaire Valeur de l’élément juste à droite de l’élément de
valeur v
‘event signal Valeur booléenne « true » si la valeur du signal vient de
changer

E. Peuch 15
VHDL

‘range Type tableau Renvoie la plage de variation de la borne gauche à la

borne droite. « for i in bus’rangeloop… »
‘reverse_range Type tableau Renvoie la plage de variation de la borne droite à la
borne gauche.

Un type scalaire est caractérisé par le fait que la valeur d’un objet de ce type est constituée d’un seul élément.

Utilisation pour détecter des fronts montants ou descendants d'une horloge:

Signal horloge : std_logic ;
horloge’event and horloge = '1' ; --renvoie la valeur true si le signal horloge vaut 1 après un
changement de valeur : ce qui revient à tester la présence
d’unetransition montante de ce signal.

VI. Les instructions concurrentes

Les instructions concurrentes sont décrites directement dans le corps de l’architecture. On

rappelle qu’en raison du parallélisme du langage (instructions concurrentes), ces instructions
peuvent être écrites dans un ordre quelconque, çà n'influe en rien le résultat de synthèse.
Les instructions concurrentes ne s'appliquent qu'à des signaux puisqu'elles sont utilisées dans le
corps d'une architecture (et non dans un process)!

Principales instructions concurrentes

 Les instructions d’affectation simples de signaux : <=
 Les instructions d’affectation conditionnelles de signaux
 Les instanciations de composants

Voir FICHE "description structurelle d'un composant"

 Les processus
 Les instructions " generate " ;

 Rappelons ce que signifie "instruction concurrente":

Les deux instructions S<= a xor b et R <= a and b sont ditesinstructions concurrentespar
opposition aux instructions séquentielles d’un programme en informatique (ou d’un process
en VHDL). Le terme concurrent signifie que l’ordre des exécutions est quelconque: les
signaux logiques S et R évoluent de façon indépendante et parallèle.
Ainsi, en VHDL,

A <= B ; représente la même chose que C <= A+D ;

C <= A+D ; A <= B ;

On peut dire que « peu importe l’ordre dans lequel on soude ses composants, le résultat
sera le même ». D’un point de vue logiciel : " chacune des lignes est évaluée par le
synthétiseur, indépendamment de l’ordre dans lequel elles sont écrites ".

E. Peuch 16
VHDL

I. Les instructions d’affectation conditionnelles

L’instruction WHEN ELSE

Signal_sortie reçoit Expr_1 quand la condition

booléenne 1 est vraie sinon
Il reçoit Expr_2 si la condition booléenne 2 est
Signal_sortie<=Expr_1whencondit_booléenne1 else
Expr_2whencondit_booléenne2else
vraie sinon …
……
Expr ; Le dernier cas présenté recouvre tous ceux qui
n’ont pas été décrits précédemment (c'est
pourquoi il n'y a pas de condition "when … else" à la
suite de Expr). C'est le cas par défaut !

Exemple de condition booléenne multiple :

nom_signal<= '0' when C = '1' and B = '1' else
(A and B) when C = '0' else
'1';

Exemple

Description d’une fonction d’aiguillage (multiplexage) : l’aiguillage permet de

sélectionner une entrée parmi deux à l’aide d’un bit de sélection.

E1 Sel S
E0 0 E0
S 1 E1
Sel

Entity aiguillage is
Port (E0, E1, Sel : in std_logic ;
S : out std_logic) ;
End aiguillage ;

Architecture version1 of aiguillage is

Begin
S <= E0 when Sel = '0' else
E1 ;
End version1 ;

E. Peuch 17
VHDL

L’instructionWith select WHEN

Cette instruction est semblable à la précédente avec en plus une précision préalable du signal sur
lequel vont se porter les conditions. En d’autres termes elle permet de mettre en facteur une
condition sur un signal commun de la manière suivante :

Withsignal_conditionselect

Signal_sortie<=Expr_1whenvaleurs_1_signal_condition,
Expr_2whenvaleurs_2_signal_condition,
……
Expr when others ;

Toutes les valeurs possibles de signal_condition doivent être décrites dans l’instruction select.
Le cas par défaut est décrit par whenothers.

Dans « valeurs_1_signal_condition, valeurs_2_signal_condition,... », on peut lister plusieurs valeurs de la

façon suivante :
with signal_condition select -- signal_condition: std_logic-vector(1 downto 0)

signal_sortie<= '0' when "11 " | "10", -- le signe | signifie ‘OU’ (agrégat)
'1' whenothers;

Exemple

Nouvelle description de notre aiguillage :

Architecture version2 of aiguillage is

Begin
With Sel select
S <= E0 when '0' ,
E1 when others;
End version1 ;

II. Les process

Le process est une instruction concurrente dont le contenu est une suite d'instructions
séquentielles, instructions semblables à celles des langages de programmation.

Cela signifie que plusieurs process fonctionnent en parallèle et qu'ils sont permanents comme
toute instruction concurrente.

E. Peuch 18
VHDL

SYNTAXE:

Pour fonctionner de manière concurrente et permanente, le process boucle indéfiniment, plus

exactement il est en attente.
En attente de quoi?

D'un évènement qui l'active, qui le réveille.

Une fois "réveillé" il effectue le traitement décrit dans le corps du process, en prenant en compte
les instructions les unes après les autres selon l'ordre d'écriture, jusqu'à "End process". Il se
remet alors en attente d'un nouvel évènement.

 Règles de fonctionnement d’un process :

 L’exécution d’un process a lieu à chaque changement de valeur d’un signal de la
liste de sensibilité.
 Les instructions du process s’exécutent selon l'ordre d'écriture (elles ne
s'exécutent pas temporellement l'une après l'autre!!!!)
 Les changements de valeur des signaux par les instructions séquentielles du
process sont tous pris en compte uniquementà la findu process (donc en même
temps).

III. Les instructions " generate "

1- Ces instructions permettent de créer des structures dont la largeur de bus des modules
instanciés peut être paramétré lors de chaque appel à cette structure. On peut l'utiliser par
exemple:
- pour un compteur dont la taille du bus est déterminé par un paramètre nombre_bits,
- pour une mémoire de n mots de p bits,
- …

Exemple

Compteur

entity compteur is
GENERIC (nb_bits : integer := 8 ) ;-- valeur par défaut = 8
PORT ( clk, en, reset : in STD_LOGIC;
CPT: out STD_LOGIC_VECTOR (nb_bit - 1downto 0));
end compteur;

E. Peuch 19
VHDL

architecture ARCHI of compteur is

signal cpt_1 : STD_LOGIC_VECTOR (nb_bit - 1downto 0);

begin

cpt<= cpt_1;

process(clk, reset)
begin
if reset = '1' then
cpt_1 <= (others => '0'); -- affectation générique
elsifclk'event and clk = '1' then
cpt_1 <= cpt_1 + 1; -- additiongénérique
end if;
end process;

end ARCHI;

2- Une instruction generatepeutdupliquer un bloc d’instructions concurrentes un certain nombre

de fois, ou créer un tel bloc si une condition est vérifiée.

Forme générale:
Etiquette :forvariable indebuttofingenerate
Instructions concurrentes
End generate [etiquette] ;

Exemple

Additionneur 8 bits

entity add_8bits is
port ( A,B : in STD_LOGIC_VECTOR (0 to 7);
CIN : in STD_LOGIC;
SUM : out STD_LOGIC_VECTOR (0 to 7);
COUT : out STD_LOGIC);
end add_8_bits;

architecture ARCHI of add_8bits is

signal C : STD_LOGIC_VECTOR (0 to 8);

begin

C(0) <= CIN;

COUT <= C(8);

BOUCLE_ADD : for I in 0 to 7 generate

E. Peuch 20
VHDL

SUM(I) <= A(I) xor B(I) xor C(I);

C(I+1) <= (A(I) and B(I)) or (A(I) and C(I)) or (B(I) and C(I));

endgenerate;

end ARCHI;

VII. Les instructions séquentielles

Les instructions séquentielles sont semblables à celles des langages de programmation

(descriptions algorithmiques).

Elles ne se rencontrent qu’à l’intérieur d’un process(ou d’un sous programme).

On rappelle que : un process regroupe des instructions séquentielles et se
comporte, d’un point de vue externe, comme une instruction concurrente.

Ci-dessous, un exemple d’équivalence entre deux descriptionsd'un système combinatoire, l’une à

base d’instructions concurrentes et l’autre à base d’instructions séquentielles :

Architecture arch of exp is Architecture arch1 of exp is

Begin Begin

S1 <= A and B ; Process (A, B)

Begin
If (A = ‘1’ and B =’1’) then
S1 <= ‘1’ ;
Else
S1 <= ‘0’ ;
End if ;
End process ;

S2 <= A when (B = ‘1’) else Process (B, C)

Not (A) when (C = ‘1’) else Begin
D; If (B = ‘1’) then
S2 <= A ;
Elsif (C = ‘1’) then
S2 <= not (A) ;
Else
S2 <= D ;
End arch ; End if ;
End process ;

End arch1 ;

E. Peuch 21
VHDL

I. Instruction de test If … Else

Cette instruction permet de sélectionner une ou des instructions à exécuter en fonction des valeurs
prises par une ou des conditions.

IFcondition_logique1THEN
Instructions qui s'exécutent selon l'ordre Chaque séquence d’instructions n’est exécutée
d'écriture; que si la condition logique associée est vraie
[ELSIF condition_logique2THEN] (true).
Instructions qui s'exécutent selon l'ordre
d'écriture; La condition booléenne peut se présenter sous
[else] différentes formes mais le résultat doit être
Instructions qui s'exécutent selon l'ordre vrai ou faux.
d'écriture;
end if ; […] signifie que c'est optionnel !

II. Instruction de test CASE … WHEN

Cette instruction permet de sélectionner une ou des instructions à exécuter en fonction des valeurs
prises par une expression.

caseexpressionis
when choix1=> Le signe =>signifie alors.
Instructions qui s'exécutent selon l'ordre
d'écriture;
whenchoix2=>
Instructions qui s'exécutent selon l'ordre
d'écriture;
…
when others =>
Instructions qui s'exécutent selon l'ordre
d'écriture;
end case;

 La condition validant l’exécution d’une séquence (choix) n’est pas limitée à une seule valeur.
Elle peut en regrouper plusieurs en utilisant l’une ou l’autre des deux écritures suivantes :

Whenvaleur1 |valeur2=>instructions séquentielles ;

Ce qui signifie : " si la valeur de l’expression est valeur1 ou valeur2 alors exécuter les
instructions qui suivent ".

When valeur3 to valeur7 =>instructions séquentielles ;

Ce qui signifie : " Si la valeur de l’expression est l’une des valeurs consécutives situées
entre valeur3 et valeur7 incluses, alors exécuter les instructions qui suivent ".

Exemple

E. Peuch 22
VHDL

case SEL is
when 0 | 1 | 2 =>
Z <= B;

when 3 to 10 =>
Z <= C;

when others =>

null;

end case;

Précision concernant un process combinatoire :

Un process sera considéré comme combinatoire si la structure matérielle finale ne fait pas
intervenir d’éléments mémoire. Pour le logiciel de développement utilisé (XST pour nous) cela
signifie que tous les signaux d’un process ont bien été traités (c'est-à-dire que, dans des
instructions du type If ou Case,… il faut bien traiter tous les cas possibles pour chacun des
signaux).
Cela signifie aussi que la liste de sensibilité doit contenir tous les signaux qui seront utilisés
dans les instructions IF, CASE,…..(Un Warning est alors généré par le logiciel).

Il est à noter que si on oublie de traiter un cas dans les instructions IF ou CASE, le logiciel va
générer un latch (une cellule mémoire) afin de mémoriser la valeur précédente du signal de
sortie (on n’est donc plus en présence d’un système combinatoire !). Pour éviter la création de
ce latch, n’oubliez pas d’expliciter toutes les branches possibles des tests !

III. VHDL pour la simulation:Les boucles FOR

foriin<lower_limit>to<upper_limit>loop
instructions séquentielles ; Cette instruction est basée sur un indice i
endloop; de type entier.

Ou alors : Il n’y a pas à déclarer la variable de

boucle, mais celle-ci ne peut être utilisée
foriin<upper_limit>downto<lower_limit>loop à l’extérieur de la boucle !
instructions séquentielles ;
endloop;

Exemple

for I in 1 to 10 loop
I_SQR(I) := I * I;
end loop;

E. Peuch 23
VHDL

IV. VHDL pour la simulation:Les boucles WHILE

while<condition>loop L’incrémentation de la variable de

instructions séquentielles ; boucle se fait tant qu’une condition
endloop; booléenne associée est vraie.

Exemple

I := 0;
while (I < 10) loop
S <= I;
I := I + 1;
endloop;

VIII. Différentes façons de décrire un composant en VHDL

Il existe différentes façons de décrire un composant en VHDL. Ces styles sont résumés sur le
schéma ci-après:

E. Peuch 24
VHDL

Description VHDL d’un système

électronique numérique

Description Description
comportementale structurelle

Interconnections
de boîtes noires
On décrit le comportement
de chaque sortie

Sous forme flot de données: On découpe notre système

Sous forme algorithmique:
numérique en plusieurs structures
On décrit le système à l’aide de ses (boîtes noires).
Lorsque le système électronique à
équations logiques. Cette méthode La dernière opération consiste à
réaliser est plus complexe, il peut être
est adaptée lorsque le système est connecter entres elles ces différentes
plus facile de le décrire de manière
relativement simple (c’est à dire structures.
algorithmique
qu’on peut écrire rapidement son
équation logique).

Utilisation d’instructions séquentielles

Utilisation d’instructions concurrentes: au sein d’un process:
If ...then...else Notons que les différentes boîtes noires
<=
case peuvent être chacune décrite à l’aide d’une
When else
... description comportementale ou d’une
With select when
description structurelle!
Opérateurs logiques (and, or,…)

E. Peuch 25
VHDL

I. Descriptions comportementales

Décrivons la structure du demi-additionneur de deux façons différentes.

Description comportementale sous forme de flot de données :

entity demi_add is
Port (a,b: in std_logic;
- description avec des
S,R: out std_logic);
instructions concurrentes.
end demi_add;
- Méthode qui n’est que le reflet
architecture flot_donnees of demi_add is des équations logiques de la
begin structure combinatoire à
S <= a xor b; décrire.
R <= a and b;
end flot_donnees;

Description comportementale à l’aide d’instructions séquentielles d’un process :

- On décrit notre système matériel de façon algorithmique -

entity demi_add is
Port (a,b: in std_logic;
S, R: out std_logic);
end demi_add;
architecture instr_seq of demi_add is
begin

process (a,b)
begin
if (a='0' and b='0') then
S <= '0'; R <= '0';
end if;
if (a='0' and b='1') then
S <= '1'; R <= '0';
end if;
if (a='1' and b='0') then
S <= '1'; R <= '0';
end if;
if (a='1' and b='1') then
S <= '0'; R <= '1';
end if;
end process;
end instr_seq;

E. Peuch 26
VHDL

II. Description structurelle

Ce type de description permet de décrire un système sous la forme d'une interconnexion de
composants, chacun étant vu comme une boîte noire.

Cette description sera utilisée (inévitablement) lorsque notre système numérique atteint un
certain niveau de complexité. On le décomposealors en différents blocs (instances), chacun d’eux
formant un couple {entité – Architecture} qui est décrit de façon comportementale ou structurelle.

Ci-dessous est rappelé l'exemple de la description structurelle d'un additionneur 1 bit. Pour plus
de détail sur l'instanciation de composant, se reporter à la fiche "description structurelle d'un
composant".

L'additionneur 1 bit peut être réalisé à partir de deux boîtes noires "demi-additionneur":

-- description structurelle

entity add_1_bit is
port ( A1, B1, R1: in std_logic;
S1, R2: out std_logic);
end demi_add;

architecture structurelle of add_1_bit is

componentdemi_add is
port ( A, B: in std_logic;
Sd,Rd: out std_logic);
end component;

Signal S2, S3, S4: std_logic;

begin

U1:demi_add
PORT MAP(A => A1,
B => B1,
Sd => S2,
Rd => S3);

U2: demi_add
PORT MAP(A => S2,
B => R1,
Sd => S1,
Rd => S4);

R2 <= S4 or S3;
end structurelle;

L'instanciation d'un composant est une instruction concurrente: elle ne s'utilise donc que hors
d'un process!

E. Peuch 27
VHDL

IX. Procédures et fonctions

Il est souvent utile de subdiviser en petits modules le programme à développer. Ainsi on met au
point chaque module indépendamment les uns des autres que l’on rassemble ensuite.
Les outils de base de cette organisation modulaire sont les procédures ou fonctions, les
paquetages et librairies.

Avec les sous programmes (procédures ou fonctions), e programmeur peut se constituer une
bibliothèque d’algorithmes séquentiels que l’on peut ensuite inclure dans une description.

Les fonctions et procédures diffèrent par les mécanismes d’échanges d’informations entre le
programme appelant et le sous-programme.

I. Les fonctions
Une fonction exécute une suite d’instructions séquentielles et retourne au programme
appelant une valeur unique, elle a donc un type.

Elle peut recevoir des arguments (liste de paramètres), exclusivement des signaux ou des
constantes, dont les valeurs lui sont transmises lors de l’appel.

Une fonction ne peut en aucun cas modifier les valeurs de ses arguments d’appel.

Les variables locales, déclarées dans la fonction, cessent d’exister dès que la fonction se
termine.

I.1 Syntaxe

FUNCTIONnom_fonction(liste paramètres avec leur type)RETURNtypeIS

[Zone de déclaration des variables] ;

BEGIN
….
Instructions séquentielles ;
….
RETURNnom de la variable ou valeur de retour ;

ENDnom_fonction ;

I.2 Exemple

L’exemple étudié est un additionneur de deux mots de 4 bits

Comme nous devons faire 4 fois l’addition binaire, on utilise une fonction appelée ADD.

E. Peuch 28
VHDL

entity EXAMPLE 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 EXAMPLE;

architecture ARCHI of EXAMPLE is

signal S0, S1, S2, S3 : STD_LOGIC_VECTOR (1 downto 0);

-- description de la fonction ADD

function ADD (A,B, CIN : STD_LOGIC ) return STD_LOGIC_VECTOR is

variable S, COUT : STD_LOGIC;

variable RESULT : STD_LOGIC_VECTOR (1 downto 0);

begin

S := A xor B xor CIN;

COUT := (A and B) or (A and CIN) or (B and CIN);
RESULT := COUT & S;
return RESULT;

end ADD;

begin
S0 <= ADD (A(0), B(0), CIN); -- L'appel de la function est une instruction.
S1 <= ADD (A(1), B(1), S0(1));
S2 <= ADD (A(2), B(2), S1(1));
S3 <= ADD (A(3), B(3), S2(1));
S <= S3(0) & S2(0) & S1(0) & S0(0);
COUT <= S3(1);
end ARCHI;

Si la description de la fonction n'est pas placée dans un paquetage, elle doit être
placée avant le BEGIN de l'architecture qui l'utilise. Elle n'est donc visible que de
l'architecture dans laquelle elle est déclarée.

II. Les procédures

Une procédure, comme une fonction, peut recevoir du programme appelant des arguments :
constantes, variables ou signaux. Mais ces arguments peuvent être déclarés de modes IN, INOUT

E. Peuch 29
VHDL

ou OUT (sauf les constantes qui sont toujours de mode IN). Ce qui autorise une procédure à
renvoyer un nombre quelconque de valeurs au programme appelant.

II.1 Syntaxe

PROCEDURE nom (liste paramètres avec leur sens de direction et type) IS

[Zone de déclaration des variables] ;

BEGIN
….
Instructions séquentielles ;
….

END nom;

II.2 Exemple

On décrit maintenant notre additionneur de deux mots de 4 bits à l’aide d’une procédure.

entity EXAMPLE 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 EXAMPLE;

architecture ARCHI of EXAMPLE is

procedure ADD (A,B, CIN : in STD_LOGIC;C : out std_logic_vector

(1 downto 0) ) is

variable S, COUT : STD_LOGIC;

begin
S := A xor B xor CIN;
COUT := (A and B) or (A and CIN) or (B and CIN);
C := COUT & S;
end ADD;

begin

process (A,B,CIN)
variable S0, S1, S2, S3 : STD_LOGIC_VECTOR (1 downto 0);
begin
ADD (A(0), B(0), CIN, S0); -- L'appel de la procedure est une instruction
ADD (A(1), B(1), S0(1), S1);
ADD (A(2), B(2), S1(1), S2);

E. Peuch 30
VHDL

ADD (A(3), B(3), S2(1), S3);

S <= S3(0) & S2(0) & S1(0) & S0(0);
COUT <= S3(1);
end process;
end ARCHI;

Une procédure peut être appelée par une instruction concurrente ou par une instruction
séquentielle (ce qui est le cas ici dans notre exemple puisque l’appel de la procédure est dans le
corps d’un process).
Mais si l’un des arguments de la procédure est une variable, elle ne peut être appelée que par
une instruction séquentielle.

Si la description de la fonction n'est pas placée dans un paquetage, elle doit être placée avant
le BEGIN de l'architecture qui l'utilise. Elle n'est donc visible que de l'architecture dans laquelle
elle est déclarée.

III. Déclaration des sous-programmes au sein de paquetages

Dans les exemples qui précèdent, les fonctions et procédures ont été insérées dans des
architectures. Or dans de cas précis, les sous-programmes en question ne sont accessibles que
dans l’architecture dans laquelle elles ont été décrites.

Pour les rendre accessibles à partir de plusieurs architectures il est nécessaire de la déclarer au
sein de packages et de déclarer en amont de l’architecture vouloir utiliser ce package.

Dans sa forme la plus complète, un paquetage est constitué de deux parties :

 La spécification de paquetage (package) qui est en quelque sorte la vue externe, donc
visible, du paquetage. Elle comprend donc la liste des déclarations : types, signaux,
constantes (jamais de variables), composants, sous-programmes.

 Le corps du paquetage (package body) qui est la vue interne du paquetage, à savoir les
descriptions des sous-programmes s’il y en a. Cette seconde partie peut donc ne pas exister.

Syntaxe de création d’un package (dans un fichier)

Packagenom_du_packageis
Déclarations de composants Les éléments d’un paquetage sont
Déclarations de fonctions accessibles dans n’importe quel fichier si le
Déclaration de types paquetage y est déclaré.
Endnom_du_package ;
Spécification de package = vue externe
Package bodynom_du_packageis
Corps d’une fonction
E. Peuch 31
VHDL

Corps d’une procédure Le package body doit porter le même nom

Endnom_du_package ; que la spécification de package. C’est la
vue interne.

 Application à notre exemple de l’additionneur (utilisation d’une fonction):

package PKG is
function ADD (A,B, CIN : STD_LOGIC ) return STD_LOGIC_VECTOR;
end PKG;

package body PKG is

function ADD (A,B, CIN : STD_LOGIC )return STD_LOGIC_VECTOR is
variable S, COUT :STD_LOGIC;
variable RESULT :STD_LOGIC_VECTOR (1 downto 0);
begin
S := A xor B xor CIN;
COUT := (A and B) or (A and CIN) or (B and CIN);
RESULT := COUT & S;
return RESULT;
end ADD;
end PKG;

Dans notre fichier d’application il suffit de rendre visible ce paquetage par l’instruction USE. Il est à
noter que WORK est la bibliothèque de travail. L’utilisateur y stockesesproprespaquetages.

use work.PKG.all;

entity EXAMPLE 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 EXAMPLE;

architecture ARCHI of EXAMPLE is

signal S0, S1, S2, S3 :STD_LOGIC_VECTOR (1 downto 0);
begin
S0 <= ADD (A(0), B(0), CIN);
S1 <= ADD (A(1), B(1), S0(1));
S2 <= ADD (A(2), B(2), S1(1));
S3 <= ADD (A(3), B(3), S2(1));
S <= S3(0) & S2(0) & S1(0) & S0(0);
COUT <= S3(1);
end ARCHI;

E. Peuch 32
VHDL

E. Peuch 33
Annexes
Rappel de quelques principes sur la logique combinatoire et sur
la logique séquentielle
Logique combinatoire
1- Tout process décrivant de la logique
combinatoire doit être sensible à toutes les
entrées intervenant dans le processus (il
doit être déclenché par toutes les entrées). 2- Un signal dont la valeur n’est pas indiquée
2- Toute signal affecté à l’intérieur d’un
processdoit avoir une valeur spécifiée pour
toutes les combinaisons d'entrée (sinon il se
verra affecté une bascule ou verrou pour le
mémoriser: nous ne sommes donc plus en
logique combinatoire!).
Pour cela il est intéressant d’utiliser :
- la clause WHEN OTHERS de l’instruction
CASE,
- ou la clause ELSE de l’instruction IF,
- ou l’instruction IF sans ELSE mais précédée
d’une initialisation de la sortie.
Logique séquentielle
1- Un process ne peut contenir qu’une seule
horloge : conception synchrone.
pour une combinaison d'entrée se verra
affecter un verrou ou une bascule D pour
conserver sa valeur précédente
(mémorisation).
3- Tout système logique doit être initialisé par
une entrée asynchrone.
4- L’instruction CASE avec sa clause WHEN
OTHERS et l’instruction IF avec sa clause
ELSE se prêtent bien à la description d’une
machine d’état.
34
Annexes

Mots réservés du VHDL

35
Annexes

Création d’un paquetage : documentation ISE fundation

Projet
 New source
 VHDL package
<nom du fichier et emplacement de ce fichier>

-- Package File Template

--
-- Purpose: This package defines supplemental types, subtypes,
-- constants, and functions

library IEEE;
use IEEE.STD_LOGIC_1164.all;

package <Package_Name> is

type <new_type> is
record
<type_name> :std_logic_vector( 7 downto 0);
<type_name> :std_logic;
end record;

-- Declare constants

constant <constant_name> : time := <time_unit> ns;

constant <constant_name> : integer := <value>;

-- Declare functions and procedure

function <function_name> (signal <signal_name> : in <type_declaration>) return

<type_declaration>;
procedure <procedure_name> (<type_declaration><constant_name> : in
<type_declaration>);

end <Package_Name>;

package body <Package_Name> is

-- Example 1
function <function_name> (signal <signal_name> : in <type_declaration> ) return
<type_declaration> is
variable <variable_name> :<type_declaration>;
begin
36
Annexes

<variable_name> := <signal_name>xor<signal_name>);
return <variable_name>;
end <function_name>;
-- Example 2
function <function_name> (signal <signal_name> : in <type_declaration>;
signal <signal_name> : in <type_declaration> ) return <type_declaration> is
begin
if (<signal_name> = '1') then
return <signal_name>;
else
return 'Z';
end if;
end <function_name>;

-- Procedure Example
procedure <procedure_name> (<type_declaration><constant_name> : in
<type_declaration>) is

begin

end <procedure_name>;

end <Package_Name

37