circuits logiques programmables

Objectifs du cours
Savoir utiliser les outils de synthèse
logique afin de concevoir un système
matériel numérique sur FPGA
Maitriser les bases du langage VHDL

1
 circuits logiques programmables

Pré-requis :
Cours d’électronique et de logique
logique booléenne, portes logiques
fonctions combinatoires et séquentielles
machine à états, représentation des
nombres en binaire,…

2
 circuits logiques programmables

Objectif

Réaliser une fonction numérique

3
 Vocabulaire

ASIC : Application Specific Integrated

Circuit
PLD : Programmable Logic Device

EPLD : Erasable Programmable Logic

Device
CPLD : Complex Programmable Logic
Device
FPGA : Field Programmable Gate Array 4
 VHDL

L’abréviation VHDL signifie VHSIC Hardware Description

Language (VHSIC : Very High Speed Integrated Circuit).
Ce langage a été écrit dans les années 70 pour réaliser la
simulation de circuits électroniques. On l’a ensuite étendu
en lui rajoutant des extensions pour permettre la
conception (synthèse) de circuits logiques programmables
(P.L.D. Programmable Logic Device).
Actuellement la densité de fonctions logiques (portes et
bascules) intégrée dans les PLDs est telle (plusieurs
milliers de portes voire millions de portes) qu’il n’est plus
possible d’utiliser les outils d’hier pour développer les
circuits d’aujourd’hui.
5
 VHDL

Les sociétés de développement et les ingénieurs ont voulu

s’affranchir des contraintes technologiques des circuits. Ils
ont donc créé des langages dits de haut niveau à savoir
VHDL et VERILOG.
Il faut avoir à l’esprit que ces langages dits de haut niveau
permettent de matérialiser les structures électroniques
d’un circuit. En effet les instructions écrites dans ces
langages se traduisent par une configuration logique de
portes et de bascules qui est intégrée à l’intérieur des
circuits PLDs. C’est pour cela que je préfère parler de
description VHDL ou VERILOG que de langage.

6
2.Structure d'un module VHDL (Unité de conception )

L’unité de conception (design unit) est le plus petit

module compilable séparément. VHDL offre cinq types
d’unités de conception :

la déclaration d’entité,
le corps d’architecture,
la déclaration de configuration
la déclaration de paquetage
le corps de paquetage.

7
2.Structure d’une description VHDL simple

Une description VHDL simple 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.
Déclaration de l'Entity (non générique):
définie les signaux d’entrées-sorties, leur type ainsi que
leur mode (lecture seule, écriture seule, lecture-
écriture)

8
2.Structure d’une description VHDL simple

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; 9
2.Structure d’une description VHDL simple

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.

10
2.Structure d’une description VHDL simple

Le TYPE utilisé pour les signaux d’entrées / sorties est :

le std_logic pour un signal.
le std_logic_vector pour un bus composé de plusieurs
signaux.
Par exemple un bus bidirectionnel de 5 bits s’écrira :
LATCH : inout std_logic_vector (4 downto 0) ;
Où LATCH(4) correspond au MSB et LATCH(0) correspond
au LSB.
Les valeurs que peuvent prendre un signal de type
std_logic sont
‘0’ ou ‘L’ : pour un niveau bas.
‘1’ ou ‘H’ : pour un niveau haut.
‘Z’ : pour état haute impédance.
11
‘-‘ : Quelconque, c’est à dire n’importe quelle valeur.
2.Structure d’une description VHDL simple

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.

12
 2.Structure d’une description VHDL simple

Déclaration de l'Entity (générique):

Syntaxe:
entity NOM_DE_L_ENTITE is
generic ( nom_parametres_générique: type_paramètre := expression_statique ;
…………….. );
port ( Description des signaux d’entrées /sorties …);
end NOM_DE_L_ENTITE;
Exemple
entity opposite_n is
generic (n : integer := 3);
port (x : in std_logic_vector(n-1 downto 0);
inverse : in std_logic;
y : out std_logic_vector (n-1 downto 0));
end opposite_n;
13
2.Structure d’une description VHDL simple

Déclaration de l’architecture correspondante à l’entité

L’architecture décrit le fonctionnement souhaité pour un
circuit ou une partie du circuit. L’architecture établit à
travers les instructions les relations entre les entrées
et les sorties. On peut avoir un fonctionnement
purement combinatoire, séquentiel voire les deux
séquentiel et combinatoire.
Syntaxe:
architecture nom-architecture of nom-entité is
{ déclaration_de_composant | déclaration_de_constante
| déclaration_de_signal_interne| déclaration_de_type
| déclaration_de_type| déclaration_d'alias}
14
begin
{ instruction-concurrente:
instruction_concurrente_d'assignation_de_signal
instruction_concurrente_d'instanciation_de_composant
instruction_concurrente_de_processus}
end nom-architecture;

15
2.Structure d’une description VHDL simple

Exemples :
-- Opérateurs logiques de base
entity PORTES is
port (A,B :in std_logic;
Y1,Y2,Y3:out std_logic);
end PORTES;
architecture DESCRIPTION of PORTES is
begin
Y1 <= A and B;
Y2 <= A or B;
Y3 <= A xor B;
end DESCRIPTION; 16
4.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.
17
4.Les instructions de base (mode « concurrent »)
logique combinatoire

Exemple : Pour le décodeur 1 parmi 4 l’ordre dans lequel seront

écrites les instructions n’a aucune importance.

18
4.1 Présentation des instructions concurrentes
d’assignation de signal

Instruction d’assignation(affectation) inconditionnelle … <= …

Instruction d’assignation conditionnelle … <= … when … else …

Instruction d’assignation sélective with … select … <= … when …

19
4.1.1 Instruction concurrente d’assignation
inconditionnelle de signal <=

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 ….

20
Instruction concurrente d’assignation inconditionnelle
de signal <=

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

guillemets " …
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

21
 Instruction concurrente d’assignation inconditionnelle
de signal <=

Assignation simples Exemple 2

Exemple 1 library IEEE;
library IEEE; use IEEE.std_logic_1164.all;
use IEEE.std_logic_1164.all;
--librairie pour inclure type std_logic entity example is
port(
--portes ET E:IN std_logic_vector(2 downto 0);
--3 entrées E2 E1 E0 S1:OUT std_logic; --1 fil
-- 1 sortie S0 Bit Poid S2,S3:OUT std_logic_vector(3 downto 1); --3 fils
Bit Poid
entity ET3 is faible S1[3:1]
Fort
port( S4:OUT std_logic_vector(2 downto 0)
E:IN std_logic_vector(2 downto 0); );
S:OUT std_logic end example;
);
end ET3; --definition de l'architecture
architecture arch_example of example is
--definition de l'architecture begin
architecture arch_ET3 of ET3 is S1<='0';
begin S2<='1'& E(1 downto 0);
S<=E(2) and E(1) and E(0); -- E(2) accès au fil 2 -- operateur COLLER (ou CONCATENE) &
end arch_ET3; -- S2(3) S2(2) S2(1)

-- '1' E(1) E(0)

S3<="101";
S4<= "111" XOR E; --manip sur les bus directement
22
end arch_example;
4.1.2 Instruction concurrente d’assignation
conditionnelle de signal … <= … when … else …

Cette instruction modifie l’état d’un signal suivant le

résultat d’une condition logique entre un ou des
signaux, valeurs, constantes.
Syntaxe
SIGNAL <= expression_1 when condition1
.
.
[else expression_n when conditionN]
[else expression_t];

23
Instruction concurrente d’assignation conditionnelle de
signal … <= … when … else …

24
 Instruction concurrente d’assignation conditionnelle de
signal … <= … when … else …
Exemple d’application: encodeur
---- Solution 1: with WHEN/ELSE -------------
LIBRARY ieee;
USE ieee.std_logic_1164.all;
ENTITY encoder IS
PORT ( x: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
y: OUT STD_LOGIC_VECTOR (1 DOWNTO 0));
END encoder;
ARCHITECTURE encoder1 OF encoder IS
BEGIN
y <= "00" WHEN x="0001" ELSE
"01" WHEN x="0010" ELSE
"10" WHEN x="0100" ELSE
"11" WHEN x="1000" ELSE
"ZZ";
END encoder1;
25
4.1.3 Instruction concurrente d’assignation sélective de
signal with …select … <= … when …

Cette instruction permet d’affecter différentes valeurs à

un signal, selon les valeurs prises par un signal dit de
sélection.
Syntaxe
with signal_de_selection select
signal<= expression_1 when valeur_de_selection1,
expression_2 when valeur_de_selection2,
------
expression_n when others ;

26
Instruction concurrente d’assignation sélective de signal
with …select … <= … when …

27
Instruction concurrente d’assignation sélective de signal
with …select … <= … when …

Autre possibilté:
std_logic_vector(1 downto 0)

28
4.2 Instanciation (placement) de composants déjà crées

 Découpage de votre projet en fonctions: création de

composants adéquats
 Assemblage des composants créés pour structurer votre
projet
 MOT CLE: PORTMAP
Ma Référence :port map ( liste ordonnée de
signaux) ;
• ou
Ma Référence : port map ( port=> signal ,
port => signal ) ;
Déclaration et instanciation de composants non
génériques

Déclaration
Les déclarations des composants non génériques ne comportent que des
données dont les dimensions sont fixées à l’avance
Syntaxe
component nom_composant
port (Description des signaux d’entrées /sorties );
end component;

Remarque:
La déclaration est faite dans la zone de déclaration d'une architecture
Le mot clé component sert à déclarer le prototype d'interconnexion. La
syntaxe est presque identique à celle de l'entité

30
Déclaration et instanciation de composants non
génériques

Exemple
component AND_2
port ( a : in STD_LOGIC;
b : in STD_LOGIC;
s : out STD_LOGIC);
end component;

31
Déclaration et instanciation de composants non
génériques

Instanciation d'un composant non générique, avec

association des signaux par la position
étiquette : nom_composant port map (
nom_de_signal_1,
…
nom_de_signal_n);

Remarque :Pour chaque instance, il convient de lister les

signaux dans l'ordre défini dans la déclaration
(component).

32
Déclaration et instanciation de composants non
génériques

Instanciation d’un composant non générique - association des

paramètres et des signaux par leur nom
étiquette : nom_composant port map (
nom_de_signal_ component => nom_de_signal_circuit,
…
);
Exemple 1
Dans cet exemple , 2 instances de composant "and2" sont appelées pour
créer une porte ET à 3 entrées.
L'association des ports du composants aux signaux de l'instance se fait
à l'aide de la clause port map.
La syntaxe des associations est soit par
nom où chaque broche du composant est associée à un signal : cas de
inst_1
positionnelle où l'ordre des signaux correspond à l'ordre des broches :
cas de inst_2
33
Déclaration et instanciation de composants non
génériques

entity AND_3 is
port(
e1 : in STD_LOGIC; e2 : in STD_LOGIC; e3 : in STD_LOGIC;
s : out STD_LOGIC );
end AND_3 ;
architecture arc of AND_3 is
signal z : STD_LOGIC;
component and2
port ( a : in STD_LOGIC; b : in STD_LOGIC; s : out STD_LOGIC);
end component;
begin
inst1 : and2 port map (a=>e1, b=>e2 , s=>z);
inst2 : and2 port map (z, e3, s);
end arc

34
Déclaration et instanciation de composants non
génériques

exemple: applicatif: Comment faire un additionneur 4 bits?

etape 1: je crée un composant ADDITIONNEUR 1 bits

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY fa IS
PORT (
Ci, X, Y: IN STD_LOGIC;
S, Cout: OUT STD_LOGIC);
END fa;
ARCHITECTURE Dataflow OF fa IS
BEGIN
Full Adder
Cout <= (X AND Y) OR (Ci AND (X XOR
Y));
S <= X XOR Y XOR Ci;
END Dataflow;
35
 Déclaration et instanciation de composants non
génériques

étape 2: je valide le composant ( compilation /simulation)

étape3: je structure mon niveau supérieur ( comment faire 4 bits avec 1 bit?)

architecture arch_add4full of add4full is

-- declaration du composant add1full
component add1full is
port(
Ci:IN std_logic;
X,Y:IN std_logic;
--librairie pour inclure type std_logic S,Cout:OUT std_logic
library IEEE; );
use IEEE.std_logic_1164.all; end component add1full;
-- declaration des fils internes pour le report carry
entity add4full is signal Fil1,Fil2,Fil3:std_logic;
port( begin
Cin:IN std_logic; -- placement des 4 aditionneurs complets
A:IN std_logic_vector(3 downto 0); U0: add1full port map (Cin,A(0),B(0),Res(0),Fil1);
B:IN std_logic_vector(3 downto 0); U1: add1full port map (Fil1,A(1),B(1),Res(1),Fil2);
Res:OUT std_logic_vector(3 downto 0); U2: add1full port map
Cout:OUT std_logic (X=>A(2),Rin=>Fil2,Y=>B(2),Cout=>Fil3,S=>Res(2));
); U3: add1full port map (Fil3,A(3),B(3),Res(3),Cout);
end add4full; 36
end arch_add4full;
Déclaration et instanciation de composants

Instanciation de multiples composants

on peut aussi vouloir instancier un nombre variable de composants (en
fonction d'un paramètre, par exemple). Ceci est fait au moyen des mot-
clef for generate et if generate.
Exemple
G: for I in 0 to N-1 generate
inst: FA port map(A(I), B(I), C(I), sum(I), C(I+1));
end generate G;

37
4.Les instructions de base (mode « concurrent »)
d’appel de processus (logique séquentielle)

Propriétés générales des processus

Du point de vue d’une architecture utilisatrice, un processus prend la place
d’une instruction concurrente
D’un point de vue « interne », un processus est constitué d'instructions
séquentielles, comme les instructions d'un langage classique (C, …)
Pour le concepteur, ces instructions séquentielles permettent l’élaboration
d’un raisonnement (algorithme), « comme si » la logique décrite était
exécutée par un simulateur sur un ordinateur
Les variables d’un processus ne sont pas toutes synthétisables, certaines
(par ex. des compteurs) peuvent être transformées par le compilateur en
signaux réels (registres), d’autres (par ex. les indices de boucle, les états
intermédiaires) ne sont pas matérialisées car elles ne servent qu’à la
logique de l’algorithme

38
4.Les instructions de base (mode « concurrent »)
d’appel de processus (logique séquentielle)

Structure d'un processus

étiquette : process (liste_de_sensibilité)
{ déclaration_de_type | déclaration_de_constante | déclaration_de_variable
| déclaration_d’alias}
begin
{ instruction_d’assignation_de_signal |
instruction_d’assignation_de_variable
| instruction_if | instruction_case | instruction_for_loop}
| instruction_while_loop}
end process [étiquette];

39
4.Les instructions de base (mode « concurrent »)
d’appel de processus (logique séquentielle)

Exemple 1

40
4.Les instructions de base (mode « concurrent »)
d’appel de processus (logique séquentielle)

EXEMPLE 2

41
4.Les instructions de base (mode « concurrent »)
d’appel de processus (logique séquentielle)

Il faut raisonner comme si le processus correspondait à un programme

d'instructions séquentielles exécutées par un simulateur
Un processus est activé à chaque changement d’état de l'un quelconque
des signaux auxquels il est déclaré sensible
Une liste de sensibilité est constituée
pour les fonctions combinatoires : de tous les signaux lus (les entrées qui
peuvent changer) pour les fonctions séquentielles : de l'horloge et tous
les signaux asynchrones (set, reset)
Le processus se déroule à partir de la première instruction qui suit le mot
clé begin

42
- L’instruction if (CLK'event and CLK='1') then permet de détecter un front montant
du signal CLK. La détection de front est réalisée par l’attribut event appliqué à
l’horloge CLK. Si on veut un déclenchement sur un front descendant, il faut écrire
l’instruction suivante : if(CLK'event and CLK='0').
- Les bibliothèques IEEE possèdent deux instructions permettant de détecter les fronts
montants ) rising_edge(CLK)ou descendants falling_edge(CLK).
43
44
45
46
47
48
49
50
51
52
CMP<= "0000";
une autre façon d’écrire cette instruction est :
CMP<= (others => ’0’) ;

53
54
55
56
57