Univ er s it é d es S ci en ce s et d e T e chn olo gi e Hou a ri Bo um edi en e

Fa c ult é d’ E le ctr o n iq ue e t d’ In f or ma ti q ue vers2

Les circuits logiques programmables Par A. HALILALI

Le langage VHDL Résumé de syntaxe

1. Notions de base du langage VHDL
1.2 Entity et Architecture
1.1. Noms valides
1.2. Commentaires Tout fichier VHDL nécessite une déclaration d'entité et un
1.3. Entity et Architecture corps d'architecture.
1.4. Ports La déclaration d'entité indique les ports d'entrée et de sortie du
1.5. Signaux et Variables design.
1.6. Type Le corps d'architecture détaille la relation interne entre les
entrées et sorties.
1.6.1. Le type STD_LOGIC
Le nom du fichier VHDL doit être le même que le nom de
1.6.2. Le type énuméré l'entité.
1.7. Librairies et Packages
Syntaxe:
1.1 Noms valides LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
Un nom valide en VHDL se compose d'une lettre suivie
par un certain nombre de lettres ou de chiffres, ENTITY nom_entité IS
sans espaces. VHDL n'est pas sensible à la casse GENERIC(définition des paramètres);
( majuscule, minuscule ) . PORT( définition des entrées-sorties);
Un trait de soulignement ( tiret du 8 ) peut être utilisé
dans un nom, mais mais ni au début ni à la fin du nom. END entity_name;
Deux traits de soulignement consécutifs ne sont pas ARCHITECTURE comportementale OF nom_entité IS
autorisés.
SIGNAL and COMPONENT declarations;

 Exemples : BEGIN
Noms valides : Instructions ;
decode4, just_a_test, What_4. END comportementale ;
Noms invalides :
4decode ( commence par un chiffre ) EXEMPLE
Decodeur 2 vers 4 sorties active-HIGH
in__time ( deux tirets consecutifs)
(decoder.vhd)
_What_4 ( commence par un tiret)
my design ( espace dans le nom ) LIBRARY ieee;
your_words? ( caractère spécial ? USE ieee.std_logic_1164.ALL;
non permis)
ENTITY decoder IS
PORT(
d : IN STD_LOGIC_VECTOR (1 downto 0);
1.2 Commentaires y : OUT STD_LOGIC_VECTOR (3 downto 0));
END decoder;
Un commentaire est un texte explicatif qui est ignoré par le ARCHITECTURE behavioral OF decoder IS
compilateur VHDL. Il est indiqué par deux traits d'union
consécutifs. BEGIN
Exemple : — — ceci est un commentaire. WITH d SELECT
y <= “0001” WHEN “00”,
“0010” WHEN “01”,
“0100” WHEN “10”,
 “1000” WHEN “11”, END IF;
“0000” WHEN others; END PROCESS;
END behavioral; connect <= a and b; --assignement de signal

1.4 Ports
Un port en VHDL est une connexion à partir d'une entité de
conception VHDL vers le monde extérieur.
La direction ou les directions dans lesquelles un port peut
fonctionner est appelé son mode.
Un port VHDL peut avoir l'un des quatre modes:
IN (entrée seulement),
OUT (sortie uniquement),
INOUT (bidirectionnel) et BUFFER ( sortie, avec un
feedback de la sortie vers l'entité de conception).
END comportementale;
1.6 Type
Le type d'un port, signal, ou variable détermine les valeurs
qu'il peut prendre.
Par exemple, un signal de type bit ne peut avoir que les valeurs
'0 ' ou '1'. Un signal de type INTEGER peut avoir n'importe
quelle valeur entière, dans les limites de la taille en bits du
système informatique particulier pour lequel le compilateur
VHDL est conçu.
Types courants :

Le mode d'un port est déclaré dans la déclaration du port Type Valeurs Ecriture
d'une déclaration d'entité ou d’une déclaration de BIT ‘0’, ‘1’ Simples cotes
composants.
‘U’, ‘X’, ‘0’, ‘1’,
STD_LOGIC
Exemples: ‘Z’, ‘W’, ‘L’, ‘H’, Simples cotes
‘-‘
ENTITY mux IS
PORT(
s1, s0 : IN STD_LOGIC; INTEGER Valeurs entières Sans cotes
y0, y1, y2, y3 : OUT STD_LOGIC);
END mux; Instances multiples Double cotes
BIT_VECTOR
de ‘0’ et de ‘1’ (ex : “00101”)
ENTITY srg8 IS
PORT(
clock, reset : IN STD_LOGIC; STD_LOGIC_VECT Instances multiples Double cotes
q : BUFFER STD_LOGIC_VECTOR (7 downto 0)); OR de ‘U’, ‘X’,… (ex :
END srg8; “11ZZ00”)

1.5 Signaux et Variables

1.6.1 Std_logic
Un signal est comme un fil de connexion entre deux ou
plusieurs points à l'intérieur du corps d’une architecture( ou Le type std_logic (standard logique), également appelé IEEE
circuit). Std.1164 Multi-valued logic, donne un plus large éventail de
Il est déclaré avant l'instruction BEGIN d'un corps valeurs de sortie que les valeurs '0 'et '1'.
d'architecture et est global à l'architecture. Un port, signal ou variable de type std_logic ou
Sa valeur est affectée à l’aide de l'opérateur <= . std_logic_vector peut avoir l'une des valeurs suivantes :
Une variable est un morceau de mémoire de travail, local à un
process spécifique. Elle est déclarée avant l'instruction ‘U’ non initialisé
BEGIN d'un process et elle est assignée à l'aide 'X' Forcé à inconnu
l'opérateur := . '0 ' Forcé à 0
'1 ' Forcé à 1
Exemple: ‘Z’ Haute impédance
‘W’ Inconnu faible
ARCHITECTURE comportementale OF design4 IS 'L', Faible niveau bas
SIGNAL connect : STD_LOGIC_VECTOR ( 7 'H', Faible niveau haut
downto 0); '-', Indifférent
BEGIN
PROCESS check IS Niveau "forçé" veut dire que le niveau est considéré comme
VARIABLE count : INTEGER RANGE 0 TO 255;
BEGIN
l'équivalent de la sortie d'une porte logique.
IF (clock’EVENT and clock = ‘1’) THEN Niveau «faible» revient à un niveau indiqué par une résistance
count := count + 1; --assignement de en pull-up ou pull-down.
variable Le «Z» est utilisé comme l'état de haute impédance d'un
tristate. ( Elément tampon trois états).

Page 2
 2.3. Instruction d'assignation conditionnelle
La majorité des applications peuvent être traitées par les 2.4. Composants
valeurs 'X', '0 ', '1' et 'Z'. 2.4.1. Déclaration de composants
2.4.2. Instanciation de composants
Pour utiliser le type std_logic dans un fichier VHDL, vous 2.4.3. Clause « Generic »
devez inclure la référence suivante à la bibliothèque VHDL 2.5. Déclaration « Generate »
appelée IEEE et le package std_logic_1164 avant la
2.6. Déclaration de Process
déclaration d'entité.

LIBRARY ieee; Une structure concurrente en VHDL agit comme un

USE ieee.std_logic_1164.ALL;
1.6.2. Le type énuméré
Un type énuméré est un type défini par l'utilisateur qui
répertorie toutes les valeurs possibles pour un port, signal, ou
variable.
Une utilisation de type énuméré serait de lister les états d'une
machine d'état.
Exemple
TYPE type_etat IS (idle, start, pulse,
read);
SIGNAL state : type_etat ;
1.7 Librairies et Packages
Une librairie est une collection de constructions
VHDL préalablement compilées qui peuvent être utilisés dans
une entité de conception ou design.
Un package est une collection de constructions
VHDL non compilée qui peut être utilisée dans des entités de
conception.
Les noms de la librairie doivent être inclus au début d'un
fichier VHDL, avant la déclaration d'entité, pour utiliser
certains types ou fonctions.
La plus utilisée est la librairie IEEE, qui dans le package
std_logic_1164, définit le type std_logic (logique standard)
composant séparé.
Un changement appliqué à de multiples structures parallèles
agit sur toutes les structures affectées au même moment.
Ceci est similaire à un signal appliqué à plusieurs composants
dans un circuit; un changement du signal sera exploité par tous
les composants simultanément.
2.1. Instruction d'affectation concurrente
Une instruction d’affectation concurrente attribue à un port
ou à un signal la valeur d'une expression booléenne ou une
constante.
Cette instruction est utile pour l'encodage des équations
booléennes.
Étant donné que les opérateurs AND , OR , NOT et XOR ont
la même priorité en VHDL, l'ordre de priorité doit être
explicité par des parenthèses.
Syntaxe:
signal <= expression;
Exemples :
sum <= (a xor b) xor c;
c_out <= ((a xor b) and c_in) or (a and b);
2.2. Instruction d'affectation sélective

Syntaxe:
LIBRARY nom_librairie ;
Une instruction d’affectation sélective de signal affecte à un
USE nom_librairie.Nom_package.ALL; port (ou à un signal) l'une parmi plusieurs valeurs alternatives,
sur la base de la valeur d'un signal de sélection.
Exemples Elle peut être utilisée pour l’implémentation d’une table de
vérité ou d'un circuit de sélection comme un multiplexeur.
LIBRARY ieee;
USE ieee.std_logic_1164.ALL; --Definie le Syntaxe:
Type STD_LOGIC
USE ieee.std_logic_arith.ALL; -- Definie les label: WITH expression SELECT
Les fonctions signal <= expression_1 WHEN valeur_1,
arithmétiques expression_2 WHEN valeur_2,
expression_… WHEN valeur_…,
LIBRARY altera; -- Déclaration des expressionN WHEN valeur_N;
composantes primitives
MAX+PLUS II
USE altera.maxplus2.ALL; Exemples:
2. Structures Concurrentes
Décodeur implémenté comme une table de vérité
2.1. Instruction d'affectation concurrente de
(2 entrées, 4 sorties)
signal. Sel est défini comme STD_LOGIC_VECTOR (1 downto 0)
2.2. Instruction d'affectation sélective Y est définie comme STD_LOGIC_VECTOR (3 downto 0)

Page 3
 component déclaration(s);
WITH Sel SELECT signal déclaration(s);
y <= “0001” WHEN “00”, BEGIN
“0010” WHEN “01”, Component instantiation(s);
“0100” WHEN “10”, Autres instruction(s) ;
“1000” WHEN “11”, END nom_archi;
“0000” WHEN others;

Multiplexeur 2.4.1. Déclaration de composants

Signal d’entrée affecté à Y selon les valeurs Une déclaration de composant est de forme similaire à une
de S1 et S0 déclaration d'entité du fait qu’elle inclue les ports requis et les
M: WITH S SELECT paramètres du composant.
y <= d0 WHEN “00”,
La différence est qu'elle se réfère à une conception décrite
d1 WHEN “01”,
d2 WHEN “10”, dans un fichier VHDL séparé.
d3 WHEN “11”; Les ports et les paramètres dans la déclaration composant
peuvent être un sous-ensemble de ceux dans le fichier de
composant, mais ils doivent avoir les mêmes noms.
2.3. Instruction d'assignation conditionnelle.
Syntax:
Une instruction d’affectation conditionnelle affecte à un port
(ou à un signal) une valeur basée sur une série de conditions COMPONENT component_name
liées. GENERIC(
La structure de base attribue une valeur si la première parameter_name : string := default_value;
condition est vraie. parameter_name : integer := default _value);
Sinon, une autre valeur est attribuée si une deuxième PORT(
condition est vraie, et ainsi de suite, jusqu'à ce qu'une input name, input_name : IN STD_LOGIC;
condition par défaut est atteinte. bidir name, bidir_name : INOUT STD_LOGIC;
C’est une structure idéale pour un codeur de priorité. output name, output_name : OUT STD_LOGIC);
END COMPONENT;
Syntaxe:
signal <= expression WHEN boolean_expression_1 Exemple :
ELSE expression WHEN boolean_expression_2 ARCHITECTURE adder OF add4par IS
ELSE expression ; COMPONENT full_add
PORT(
Exemple: Codeur de priorité a, b, c_in : IN BIT;
q défini comme INTEGER RANGE 0 TO 7 c_out, sum : OUT BIT);
d défini comme STD_LOGIC_VECTOR (7 downto END COMPONENT;
0) SIGNAL c : BIT_VECTOR (3 downto 1);
BEGIN
q <= 7 WHEN d(7)=‘1’ ELSE Instructions
6 WHEN d(6)=‘1’ ELSE END adder;
5 WHEN d(5)=‘1’ ELSE
4 WHEN d(4)=‘1’ ELSE 2.4.2. Instanciation de composants
3 WHEN d(3)=‘1’ ELSE
2 WHEN d(2)=‘1’ ELSE
1 WHEN d(1)=‘1’ ELSE Chaque instance d'un composant nécessite une déclaration
0; d'instanciation du composant.
Les ports peuvent être assignés implicitement par l'insertion
du nom du port d'utilisateur dans la position du nom de port
correspondant dans la déclaration de composant ou
explicitement avec l'opérateur => ,.
2.4. Composants ( Components)
Syntax:
instance_name: component_name
Un fichier VHDL peut utiliser un autre fichier VHDL GENERIC MAP( parameter_name => parameter_value,
comme un composant. La forme générale d'une entité de parameter_name => parameter_value)
conception utilisant des composants est la suivante: PORT MAP ( component_port => connect_port,
component_port => connect_port);
ENTITY nom_entite IS
PORT ( definition des entrées sorties);
END nom_entite;

ARCHITECTURE nom_archi OF nom_entite IS

Page 4
Exemples : —— Four Component Instantiation
—— Affectation implicite des ports
__instance_name: __component_name
GENERIC MAP (__parameter_name =>
__parameter_value,
__parameter_name => __parameter_value)
PORT MAP (port instantiations);

adder1:full_add
PORT MAP(a(1),b(1),c0,c(1),sum(1));
adder2: full_add
PORT MAP(a(2),b(2),c(1),c(2),sum(2));
adder3: full_add
PORT MAP(a(3),b(3),c(2),c(3),sum(3));
adder4: full_add
PORT MAP(a(4),b(4),c(3),c4,sum(4));
—— Affectation explicite des ports
Exemple : —— Component: description
comportemental d’un registre à décalage avec
une capacité par défaut de 4 bits.
ENTITY srt_bhv IS
GENERIC (width : POSITIVE := 4);
PORT(
serial_in, clk : IN STD_LOGIC;
q : BUFFER STD_LOGIC_VECTOR(width-1 downto 0));
END srt_bhv;

ARCHITECTURE right_shift of srt_bhv IS

adder1: full_add BEGIN
PORT MAP (a=>a(1), b=>b(1), c_in=>c0, PROCESS (clk)
c_out=>c(1), sum => sum(1)); BEGIN
adder2: full_add IF (clk’EVENT and clk = ‘1’) THEN
PORT MAP ( a => a(2),b => b(2),c_in => c(1), q(width-1 downto 0) <= serial in & q(width-1
c_out => c(2),sum => sum(2)); downto 1);
adder3: full_add END IF;
PORT MAP ( a => a(3),b => b(3),c_in => c(2), END PROCESS;
c_out => c(3), sum => sum(3)); END right_shift;
adder4: full_add
PORT MAP ( a => a(4), b => b(4),c_in=> c(3),
c_out => c4, sum => sum (4)); 2.5 L’instruction Generate

Une instruction generate est utilisée pour créer plusieurs

2.4.3 La clause Generic instances d'une structure matérielle particulière. Elle s'appuie
sur la valeur d'un ou plusieurs variables d'index pour créer le
Une clause generic permet à un composant d’être nombre de répétitions.
conçu avec une ou plusieurs propriétés non spécifiées
("paramètres") qui sont spécifiés lorsque le composant est Syntaxe:
instancié. __generate_label:
Un paramètre spécifié dans une clause générique doit être FOR __index_variable IN __range GENERATE
donné par une valeur par défaut avec l'opérateur : = . __statement;
Syntaxe: __statement;
paramètres définis dans la déclaration END GENERATE;
d’entité du fichier component.

ENTITY entity_name IS Exemples: —— Instantiate four full adders

GENERIC( nom_parametre : type := adders:
valeur_defaut ); FOR i IN 1 to 4 GENERATE
nom_parametre : type := adder: full_add PORT MAP (a(i), b(i), c(i-1),
valeur_defaut ); c(i), sum(i));
PORT ( déclarations de port); END GENERATE;
END entity name; —— Instantiate four latches from MAX+PLUS II
primitives
—— Component declaration in top-level file —— Requires the statements LIBRARY altera; and
also has generic clause. —— USE altera.maxplus.ALL;
—— Default values of parameters not specified. latch4:
FOR i IN 3 downto 0 GENERATE
COMPONENT component_name IS latch_primitive: latch
GENERIC(__parameter_name : type; PORT MAP (d => d_in(i), ena => enable, q =>
__parameter_name : type); q_out (i));
PORT (port declarations); END GENERATE;
END COMPONENT;

—— Parameters specified in generic map in

component instantiation

Page 5
2.6 Process Statement instructions;

END IF;
Un process est une instruction concurrente, mais les
instructions à l'intérieur du processus sont séquentielles. Exemple:
Par exemple, un process peut définir un flip-flop, un
composant séparé dont les ports sont affectés PROCESS (reset, load, clock)
simultanément, mais à l'intérieur la bascule fonctionne de
VARIABLE count INTEGER RANGE 0 TO 255;
manière séquentielle.
Le process exécute toutes ses instructions quand il y’a un BEGIN
changement d'un signal de sa liste de sensibilité. IF (reset = ‘0’) THEN
L'étiquette du process est optionnelle. q <= 0;
ELSIF (reset = ‘1’ and load = ‘0’) THEN
Syntax: q <= p;
-- process_label: ELSIF (clock’EVENT and clock = ‘1’) THEN
count := count + 1;
PROCESS ( liste de sensibilité ) q <= count;
déclarations de variables END IF;
BEGIN END PROCESS;

Instructions séquentielles 3.1.1. Evaluation des fonctions d’Horloge

END PROCESS -- process_label; Comme on l’a vu dans les exemples précédents, l'état d'une
horloge système peut être contrôlé avec une instruction IF en
Exemple -- D latch
utilisant l'attribut prédéfini, appelé event.
PROCESS (en)
BEGIN La clause de clock'EVENT est vraie s'il y’a eu activité sur le
IF (en = ‘1’) THEN signal appelé clock.
q <= d; Ainsi (clock'EVENT and clock = '1 ') est vrai, juste après un
END IF; front montant de l'horloge.
END PROCESS;

3.2. L’instruction CASE

3. Structures séquentielles Une instruction Case est utilisée pour exécuter l'un de
plusieurs ensembles d’ instructions, sur la base de l'évaluation
3.1. L’instruction IF d'un signal.
3.1.1. Evaluation des fonctions d’horloge
3.2. L’instruction CASE Syntax:
CASE expression IS
Dans une structure séquentielle en VHDL on tient compte de WHEN valeur1 => instruction ;
instruction ;
l'ordre des instructions car celui affecte le fonctionnement du instruction ;
circuit.
Elle peut être utilisée pour mettre en œuvre des circuits WHEN valeur2 => instruction ;
combinatoires, mais elle est principalement utilisée pour la instruction ;
mise en œuvre des circuits séquentiels tels que les verrous, instruction ;
compteurs, registres à décalage et les machines d'état.
Les instructions séquentielles doivent nécessairement être WHEN OTHERS => instruction ;
instruction ;
contenues dans un process. instruction ;
END CASE;
3.1. L’instruction IF
Exemple : —— Case evaluates 2-bit value of s and
L’ instruction IF exécute une ou un ensemble assigns
—— 4-bit values of x and y according ly
d’instructions si une condition booléenne est vérifiée. —— Default case (others) required if using

Syntaxe : STD_LOGIC
CASE s IS
IF expression1 THEN WHEN “00” => y <= “0001”; x <= “1110”;
instruction; WHEN “01” => y <= “0010”; x <= “1101”;
instruction; WHEN “10” => y <= “0100”; x <= “1011”;
ELSIF expression2 THEN WHEN “11” => y <= “1000”; x <= “0111”;
instructions; WHEN others => y <= “0000”; x <= “1111”;
ELSE END CASE;

Page 6