Cours VHDL

Vahid Meghdadi
http://www.unilim.fr/pages_perso/vahid/
Cours Conception circuits numériques

– 6x1h30 de cours + 1h30 exam
– 17 HTP (5x3h + 2h !)
Notation
– Exam théorique
– Evaluation TP
– Exam pratique
Formation VHDL Vahid MEGHDADI
1
Introduction aux
conceptions
numériques
Une partie de ce cours a été emprunté de DSPedia développé par Dr. Bob Stewart à steepest ascent, Glasgow. 2
Chapitre : Introduction
Implantation des circuits numériques

•Avec des éléments discrets
•Avec des microprocesseurs, micro contrôleurs, DSP
•Avec des circuits à architecture programmable PAL, GAL, FPGA
•Avec des circuits intégrés ASIC
PLD : Programmable Logic Device, CPLD : Complex PLD, PAL: Programmable Array Logic, GAL: Generic Array Logic,
FPGA : Field Programmable Gate Array, ASIC : application-specific integrated circuit
Formation VHDL Introduction Vahid MEGHDADI
3
Circuit avec des éléments discrets
•Circuit figé
•Circuit imprimé difficile à
modifier
•Intégration limitée
•Coût élevé
•Justifié pour de petits
circuits
4
Circuit à fonctionnement programmable
•A base des microprocesseurs, Microcontrôleurs, DSP

•En modifiant le programme on modifie la fonction
•Plus souple que les circuits à éléments discrets
•Vitesse limitée (mais qui

augmente sans cesse) Microprocesseur Pér
•Parallélisme compliqué (mais iph
faisable)
éri
•Intégration encore limitée Mémoire que
•Adapté à des opérations
séquentielles
5
Circuit à architecture programmable
•Une quantité importante de portes logiques

•Des matrices d'interconnections
programmables
•Modification du fonctionnement sur le circuit
(ISP: In-System Programming)
•Souplesse assurée
•Coût de fabrication faible (pour un nombre limité)
•Intégration forte
•Adapté à des applications gourmandes en logique
•Temps de développement dépend de l'application
• Compliqué pour implanter des algorithmes complexes
6
Les ASIC
Application Specific Integrated Circuit
• Coût très bas uniquement pour de gros

tirages
• Temps de développement important
• Pas de modifications une fois fabriqué
• Nécessitant un fondeur pour la fabrication
7
ASIC ou FPGA ?
ASICs FPGAs
High performance
Low development cost

Low power
Short time to market
Low cost in
high volumes Reconfigurability
8
Evolution : Méthodes de CAO
Conception physique (layout)
Conception structurelle TTL
Conception logique
Conception fonctionnelle RTL

Programmation Verilog/VHDL
Synthèse comportemental
9
Démonstrateurs
Circuit de développement Nexys3
10
Exemple
Une carte polyvalente et reconfigurable
Connecteur
d’extension
VGA
11
Logique (FPGA) ou software (µP et DSP) ?
• Vitesse
• Possibilité de parallélisme (calcul dans l’espace ou dans le temps)
• Exemple y=Ax²+Bx+C
DSP FPGA
12
Intérêt de la logique par rapport à µP
• Jeu d’instruction peut ne pas contenir l’opération voulue

• Processeur peut contenir des circuits qui ne servent à rien dans
notre application (Par exemple URAT)
• Processeur a besoin de la mémoire pour garder le programme
et les valeurs intermédiaires
• Le nombre de bits pour présenter les données peut être trop ou
peu
• Parallélisme très limité par software
13
Architecture des FPGA
Feild Programmable Gate Array
CLB CLB CLB CLB CLB CLB CLB
CLB= Configurable Logic

Block CLB CLB CLB CLB CLB CLB CLB
14
FPGA architecture interne
BLE= Basic Logic Element

K Out
Inputs LUT D FF
Clock
Programmable Programmable
IO Logic (CLB)
BLE
#1
N
N
I Outputs
I
Inputs BLE
#N
Clock
Programmable
Routing
15
Architecture simplifiée de CLB
Inputs Look-Up
Out
Table
(LUT)
Out = f (in0, in1, in2, in3)
State
Clock
Enable
16
FPGA Xilinx
Xilinx a été fondée en 1984 pour fabriquer des circuits à logique

programmable.
Plusieurs familles de FPGA
•Série 4000 (les années 90)
•Spartan (1998)
•Spartan (II, III, VI) (depuis 2000) (Spartan 6 depuis 2009)(spartan7
2017)
•Virtex (II, IV, V, VI, VII) (depuis 2001)
•Artix (2010)
•Kintex (2010)
•Zynq (SoC) (2011)
17
Remarque
Spartan (depuis 1998)
Le nombre de broches I/O, le nombre de CLB

différentie les FPGA de la famille.
18
Remarque
Spartan II
Ajout de la RAM
19
Remarque
La famille Spartan II
20
Remarque
Spartan 3
21
Remarque
La famille Virtex
•Les LUT transformables en registre à décalage
•Plus de CLB, plus de mémoire, plus de slices par CLB
•Plus de I/O
•Multiplieurs câblés à partir de Virtex II
•DSP slices
•Microprocesseur embarqué (PowerPC)
22
Remarque
La famille Virtex
23
Remarque
La famille Virtex-II pro
24
Remarque
Virtex 5 et le LUT
LUT à 6 entrées et 2 sorties: permettant de construire des

logiques plus sophistiques dans un seul slice.
25
Remarque
Virtex 5 et les blocs DSP
26
Remarque
Série 7 (depuis 2010)
27
Outil de développement
L’IDE (Integrated development environment)

- jusqu’en 2012 : ISE
- Depuis 2012 VIVADO
- La dernière version d’ISE : 14.7
En TP on utilise ISE qui supporte spartan 6.
Pour la série 7, on doit utiliser Vivado
28
Conception circuit
o Les blocs reconfigurables

o Structure régulière de “logic cells”, connectée par un réseau d’interconnexions
o La configuration est stocké dans un SRAM, qui doit être chargé au démérrage
EPROM
29
Design flow
HDL o Hardware design is traditionally done by modeling

(VHDL / the system in a hardware description language
Verilog)
o An FPGA “compiler” (synthesis tool) generates a
Synthesize netlist,
Netlist
Map
o which is then mapped to the FPGA technology,
Place o the inferred components are placed on the chip,
Route o and the connecting signals are routed through the
interconnection network.
Bitstream
30
Synthèse HDL
HDL
(VHDL / process(clk, reset)
Verilog)
begin
if reset = ‚1‘ then
Synthesize output <= ‚0‘;
elsif rising_edge(clk) then
output <= a XOR b;
Netlist end if;
end process;
Map
Place Register
a
Route ⊕ D Q output
b
clk
clear
Bitstream
reset
31
Technology Mapping
Register
HDL
a
(VHDL / ⊕ D Q output
Verilog) b
clk
clear
Synthesize
reset
Netlist
Map
Place
Route
Bitstream
32
Placement & Routage
HDL
(VHDL /
Verilog)
Synthesize
Netlist
Map
Place
Route
Bitstream
33
Système embarqué traditionnel
Power Supply
Ethernet Audio CLK
CLK
MAC Codec
GP I/O Interrupt
Controller
Timer
Address
Decode
Unit
CPU UART
L
(uP / DSP) Co- C
Memory Proc. custom
CLK Controller IF-logic
SRAM SRAM SRAM Display

SDRAM SDRAM Controller
Images by H.Walder
34
Système embarqué traditionnel
Power Supply
Ethernet Audio CLK
CLK
MAC FPGA Codec
GP I/O Interrupt
Controller
Timer
Address
Decode
Unit
CPU UART
L
(uP / DSP) Co- C
Memory Proc. custom
CLK Controller IF-logic
SRAM SRAM SRAM Display

SDRAM SDRAM Controller
Images by H.Walder
35
System on Chip Configurable (CSoC)
Audio
Codec EPROM
Power Supply
L
C
SRAM SRAM SRAM SDRAM SDRAM

Images by H.Walder
36
Avantages
 Moins de composantes physiques
 Cycle de conception plus rapide
 Programmable sur le circuit (Mise à jour, modification...)
 Plus performant grâce à l’intégration

 Horloge peut être plus rapide dans la puce que sur le circuit imprimé
 Optimisation entre modules possible
37
Chapitre : Introduction A VHDL
Introduction au langage
VHDL
Formation VHDL Introduction A VHDL Vahid MEGHDADI
38
VHDL
V VHSIC
(Very High Speed Integradted Circuit)
H Hardware
D Description
L Language
39
Remarque
Un peu d’histoire
•Début des années 80

•la nécessité d’un langage non ambigu des systèmes
matériels pour intégration à grande échelle
•normalisation pour être indépendant du fournisseur
•Norme définitive adoptée en 1987 : IEEE Std 1076
•La norme a été revue en 93, 2000 et 2002
•Les premiers outils de synthèse en 1995
40
Qu’est ce que on attend de VHDL
• VHDL est utilisé pour
• Décrire des circuits numériques
• Décrire des machines à états
• Préparer des signaux de test pour simuler cette écriture
• Le langage concurrent : Verilog
41
Qu’est ce que on attend des outils de synthèse
•Une fois le programme en VHDL est écrit, il faut maintenant

le réaliser
•Synthèse logique : générer des fonctions logiques à partir
du programme
•Implémentation : adapter la logique synthétisée à la cible
(FPGA, CPLD)
•Génération : Générer un fichier binaire à télé-charger sur
le « device »
42
Niveau d’abstraction
Synthèse Comportemental
comportemental
RTL VHDL
Synthèse
logique
Logique
Placement
routage
Layout
43
Chapitre : Structure du VHDL
Il existe 5 catégories d’unité de conception

•L’entité (mot clé entity)
Circuit Décrit un système vu extérieur (boîte noire)
principal
•L’architecture (mot clé architecture)
Décrit l’intérieur (le fonctionnement) d’une boîte noire.
•La configuration (mot clé configuration)
Package •La déclaration de paquetage (mot clé package)

(librairie) •Le corps de paquetage (mot clé package body)
Formation VHDL Structure du VHDL Vahid MEGHDADI
44
Minimum design en VHDL
Deux unités obligatoires

• une entité
• une architecture
Un circuit décrit en VHDL
Déclaration d’entité
Architecture
45
Exemple simple: entité
L’entité déclare la vue externe

du circuit : les ports d’entrée-
sorties et leur type. Elle peut
aussi déclarer des paramètres.
Exemple: L’entité du circuit ci-contre qu’on appellera « AOI»
entity AOI is
Port(
A,B,C,D: in std_logic; AOI
F : out std_logic);
end AOI;
46
Entité décortiquée
Entity name Port names Port type

Semicolon
ENTITY nand_gate IS
PORT(
a : IN STD_LOGIC; No Semicolon
b : IN STD_LOGIC; after last port
z : OUT STD_LOGIC
);
END nand_gate;
Reserved words
Port modes (data flow directions)
Même chose mais en moins lisible, non recommandée !!

ENTITY nand_gate IS PORT(a,b: IN STD_LOGIC;z : OUT STD_LOGIC
);END nand_gate;
Formation VHDL Entité Vahid MEGHDADI
47
Remarque
std_logic définit un type plus que binaire. En fait, un objet

de type std_logic peut recevoir des valeurs ‘0’ et ‘1’ mais
aussi autres valeurs comme par exemple « haute
impédance ».
On verra les types bien tôt.
On remarque aussi les modes des signaux: in, out. Il y en a

d’autres: buffer, inout.
48
Exemple simple: architecture
L’architecture définit le fonctionnement du circuit.
architecture v1 of AOI is
-- les déclarations
begin
F <= not((A and B) or (C and D));
end v1;
49
Remarque
On remarque l’opérateur d’affectation <=

Les opérateurs logiques "and", "or", "nor", "nand" et "not"
font parti des opérateurs connus du langage.
On remarque aussi que -- est utilisé pour des commentaires.
Il existe deux parties dans l’architecture
- avant begin : zone des déclarations
- Après begin : la partie "exécutable".
50
Exemple simple: architecture bis
architecture v2 of AOIis
signal I1,I2,I3: std_logic;
begin
I1, I2 et I3 sont des
I1 <= A and B;
I2 <= C and D; signaux internes.
I3 <= I1 or I2;
F <= not I3;
end v2;
51
Principe de concurrence
architecture v3 of AOI is
signal I1,I2,I3: std_logic;
begin
I1 <= A and B;
I2 <= C and D;
I3 <= I1 or I2;
F <= not I3;
end v3;
Tous les mêmes !
architecture v2 of AOI is architecture v4 of AOI is
signal I1,I2,I3: std_logic; signal I1,I2,I3: std_logic;
begin begin
I1 <= A and B; F <= not I3;
F <= not I3; I3 <= I1 or I2;
I2 <= C and D; I2 <= C and D;
I3 <= I1 or I2; I1 <= A and B;
end v2; end v4;
52
Remarque
Dans une architecture, toutes les instructions sont exécutées

en parallèle : elles sont concurrentes et non pas
« séquentielles ».
La partie après "begin" dans une architecture est une zone

concurrente.
53
Décrire des délais
Dans des circuits réels, les portes logiques présentent des délais.
On pourra aussi les décrire.
54
Délai dans les affectations
- Une affectation sera déclenchée quand un évènement arrive

- Un évènement est un changement de valeur d’un signal
- Pour l’instruction ci-dessous, cet évènement est le passage de A de 0 à 1.
- Cependant, l’affectation se concrétise après 2 ns.
55
TRES IMPORTANT
Attention: l’instruction d’affectation retardé est

importante en simulation, par contre n’a aucun effet en
synthèse. L‘outil de synthèse ignore « after »:
Pour la synthèse :
I1 <= A and B after 2 ns; ≡ I1 <= A and B;
Le circuit qui sera réalisé présentera un délai qui

dépendra de la technologie utilisé, longueur des câblage,
etc.
56
Résultat obtenu en simulation
57
Exemple
A SUM
Demi-
additionneur
B C
A SUM
A B SUM C
B 0 0 0 0
C 0 1 1 0
1 0 1 0
1 1 0 1
Formation VHDL Architecture Vahid MEGHDADI
58
Programme VHDL correspondant
entity DEMI_ADD is
port (A,B: in std_logic;
SUM,C: out std_logic);
end DEMI_ADD;
architecture COMPORT of DEMI_ADD is

begin
SUM <= A xor B; --instruction concurrente
C <= A and B; --instruction concurrente
end COMPORT;
Formation VHDL Architecture Vahid MEGHDADI
59
Hiérarchisation en VHDL
60
Hiérarchie in VHDL
- Un bloc conçu, testé, et fonctionnel peut être réutilisé. On

l’appelle component.
- Dans un design qui utilise ce component
- On déclare entité du component
- On instancie un exemplaire de ce component dans la
zone concurrente
- On procède au câblage de ce component
61
Exemple : multiplexeur 2 voies
Si SEL=‘0’, Y <=X1, et si SEL=‘1’, Y<=X2
62
Déclaration de component
Déclaration du component
63
Déclaration de signaux
64
Instanciation du component
Instanciation du component
65
Instructions Concurrentes / séquentielles
66
Instructions concurrentes ou séquentielles
En VHDL, il existe deux types d’instructions

• Instructions concurrentes
• à écrire dans la zone concurrente de l’architecture
• elles sont exécutées simultanément
• l’ordre de l’écriture n’a pas d’importance
• Instruction séquentielles
• à écrire dans les « process »
• elles sont exécutées dans l’ordre
67
Exemple
A
B I S
C
I <= A or B; S <= I and C

S <= I and C I <= A or B;
Formation VHDL Zone concurrente Vahid MEGHDADI
68
Instruction concurrente conditionnelle
Exemple d’instructions concurrentes:

Affectation conditionnelle: when – else (équivalent de if-
then-else dans d’autre langages)
69
Instruction concurrente sélective
• La condition se fait sur un seul objet (comme le signal sel ci-dessous)

• Le mot clé others doit être utilisé pour couvrir les cas non spécifiés
70
Remarque
L’affectation sélective produit très souvent un circuit plus simple (par rapport à l’affectation
conditionnelle) parce qu’il n’y a pas de priorité dans différentes branches. De plus, la
condition est à tester sur un seul objet.
Exemple
71
Exemple instruction « with-select »
Codeur sept-segment
with HEX select

LED<= "1111001" when "0001", --1
"0100100" when "0010", --2
"0110000" when "0011", --3
"0011001" when "0100", --4
"0010010" when "0101", --5
"0000010" when "0110", --6
"1111000" when "0111", --7
"0000000" when "1000", --8 7
"0010000" when "1001", --9
"0001000" when "1010", --A
"0000011" when "1011", --b Circuit
"1000110" when "1100", --C combinatoire
"0100001" when "1101", --d
"0000110" when "1110", --E
4
"0001110" when "1111", --F
"1000000" when others; --0
72
Remarque
Exemple ALU
entity ADDER is
port (A,B :in std_logic_vector(7 downto 0);
SEL : in std_logic;
S : out std_logic_vector(7 downto 0));
end ADDER;
architecture COMPORT of ADDER is
Begin
with SEL select
S <= A+B when '0',
A-B when others;
-- ou on peut utiliser when-else
-- S <= A+B when SEL=‘0’ else A-B;
end COMPORT;
73
Process
74
Process
• Process est une instruction concurrente : donc à

écrire dans une architecture (après begin),
• Les différents process d'une architecture s'exécutent

tous en parallèle
•Process génère une zone séquentielle
Formation VHDL Process Vahid MEGHDADI
75
Syntaxe de process
•Syntaxe de process :
label : -- optionnel
process (liste de sensibilité)
{partie déclarative}
begin
suite d’instructions séquentielles
end process;
•Notion très importante : Un process s'exécute (se
réveille) quand un des signaux de la liste de sensibilité
change de valeur.
•Un fois on arrive à la fin du process, celui-ci rendort jusqu’à
l’arrivée d’un évènement sur un des signaux de sa liste de
sensibilité,
76
Instructions séquentielles
•Ils s'écrivent uniquement dans une zone séquentielle: après

le « begin » d’un process
• instruction d'attente (wait)
• instruction d'affectation (temporisée)
• instruction conditionnelle (if)
• instruction sélective (case)
77
Instructions wait
L’exécution des lignes d’un process s’arrête quand on arrive à la

commande « wait », on dit que le process est suspendu ! Le process
pourra redémarrer suivant une condition.
•Wait
•wait until condition;

•wait until A=‘ 1 ’;
•wait until CLK’event and CLK=’1’;
• wait for time expression;

•wait for 5 ns;
• wait on signal;
•wait on A , B
78
Remarque
La génération de l’horloge et en même temps d’un signal Reset.

clock_gen: process
begin
CLK_TB <= '1';
wait for 5 ns; Instructions
CLK_TB <= '0'; séquentielles
wait for 5 ns;
end process;
---------------------------------------
reset_gen: process
begin Instructions
RST_TB <= ‘0’; wait for 5ns; concurrentes
RST_TB <= ‘1’; wait for 15ns; Instructions
RST_TB <= ‘0’; séquentielles
wait;
end process;
---------------------------------------
inst: counter
port map ( CLK => CLK_TB, RST => RST_TB, Q => DATA_OUT );
79
Instructions conditionnelle
if condition then
sequential statements
[elsif condition then
sequential statements ]
[elsif condition then
[else
end if;
80
Instruction sélective
Permet de sélectionner une suite d’instructions à exécuter

en fonction de la valeur d’une expression.
case EXPRESSION is
when VAL1 => suite d’instructions séquentielles
when VAL2|VAL3|VAL4 => suite d’instr séquentielles
when VAL5 to VAL7 => suite d’instr séquentielles
when others => suite d’instr séquentielles
end case;
•L’ordre des branches n’a pas d’importance (sauf others)

•La branche « others » est obligatoire si toutes les valeurs
de l’expression ne sont pas énumérées.
81
Remarque
Exemple
Multiplexeur 4 voies
S1 S0
A
M
B Z
U
C X
4
D
82
Remarque
Exemple (avec if)
entity MUX_4 is
port (S1, S0, A, B, C, D: in std_logic;
Z: out std_logic);
end MUX_4;
architecture behav_MUX_4 of MUX_4 is

begin
P1: process (S1, S0, A, B, C, D) - - la liste de sensibilité
begin
if (( not S1 and not S0 )=’1’) then Z <= A;
elsif (( not S1 and S0) = ‘1’) then Z <=B;
elsif ((S1 and not S0) =’1’) then Z <=C;
else Z <=D;
end if;
end process P1;
end behav_MUX_4;
83
Remarque
Exemple (avec case)
entity MUX_4 is
port ( S : in std_logic_vector(1 downto 0);
A, B, C, D: in std_logic; Z: out std_logic );
end MUX_4;
architecture behav_MUX_4 of MUX_4 is

begin
P1: process (S, A, B, C, D) - - la liste de sensibilité
begin
case S is
when "00" => Z <= A;
when "01" => Z <= B;
when "10" => Z <= C;
when "11" => Z <= D; -- ou when others => Z <= D;
end case;
end process P1;
end behav_MUX_4;
84
Affectation séquentielle
Attention : affectation d’une valeur à un signal dans un process n’est pas

immédiate !
L’affectation se réalise quand le process est suspendu, ou quand on arrive à la
fin du process.
Dans un process tous les signaux sont constants, ils sont actualisés quand le
process est suspendu (end de process, ou wait)
Exemple:
process(A)
begin
A <= ‘0’; --ici le signal A ne recevra pas ‘0’
B <= A; --ici donc, B recevra l’ancienne valeur de A mais
--au moment où le process sera suspendu
end process; --c’est ici que A reçoit ‘0’ et B reçoit
Formation VHDL
--l’ancienne valeur de A Vahid MEGHDADI
85
Remarque
Attention !
Le process ci-dessous ne
produira pas le signal ci-
contre
SIG
Process (x)
begin
SIG <= '0';
SIG <= '1'; SIG
SIG <= '0';
end process;
86
Circuits séquentiels
Trois types de circuit

• Combinatoire
• Séquentiel
• Synchrone
87
process combinatoire
Un process n’est plus combinatoire si au moins une des

conditions suivantes est vérifiée :
• la liste de sensibilité ne comprend pas tous les signaux
lus
• les signaux ne sont pas affectés quelle que soit la
branche
• une variable est lue avant d'être affectée
Le circuit généré aura donc quelque part une mémoire !
Formation VHDL Circuits séquentiels Vahid MEGHDADI
88
Exemple: Verrou ou Latch
Bascule à verrouillage
entity L is
port (D,EN : in std_logic;
Q : out std_logic);
end L;
architecture A of L is architecture A of L is
Ce qu’on préfère !
begin begin
process process (D,EN)
begin begin
wait on D,EN; if EN='1' then
if EN='1' then Q <= D; Q <= D;
end if; end if;
end process; end process;
end A; end A;
89
Registre (latch synchrone)
Un circuit synchrone sur le front d’un signal (CLK)
process (CLK)
begin D
if CLK'event and CLK='1' then Q
Q <= D; CLK
end if
end process; Bascule D
process (CLK) 8
begin D 8
if rising_edge(CLK) then Q
Q <= D; CLK
end if
Registre de taille 8 dépendant
end process; du type de Q et D
90
Registre avec SET ou RESET
entity R is
port (D,CLK,SET: in std_logic;
Q: out std_logic);
end R;
architecture A of R is
architecture A of R is
begin -- set synchrone
begin -- set asynchrone
process (CLK)
process (SET,CLK)
begin
begin
if CLK'event and CLK='1' then
if SET = '1' then Q <= '1';
if SET = '1' then Q <= '1';
elsif CLK'event and CLK='1'
else Q <= D;
then Q <= D;
end if;
end if;
end if;
end process;
end process;
end A;
end A;
91
Exemple : compteur
Création d’un compteur 3 bits:

000-001-010-011-100-101-110-111-000-001-…
Supposons que le FPGA reçoit un signal CLK à l’entrée et qu’il sort 3

fils représentant les 3 bits du compteur.
-- signal cmp: std_logic_vector(2 downto 0);
process(CLK)
begin
if CLK’event and CLK=‘1’ then
cmp <= cmp+1;
end if;
end process;
Exercice: tracer les chronogrammes des signaux CLK et cmp.

92
Exemple
Créer le signal “trig” à partir du signal d’horloge CLK

0 1 2 3 0 1 2 3 0 1 2
CLK
trig /4
-- signal cmp: integer range 0 to ?;
process(CLK)
begin
trig <= ‘0’; cmp <= cmp + 1;
if cmp = ? Then
cmp <= 0; trig <= ‘1’;
end if;
end if;
end process;
93
Objets en VHDL
94
Objets en VHDL
En VHDL, il existe 3 classes d’objet pour garder ou représenter

des data.
- signal : représente des fils, des bus, des registres
- variable : comme les variables dans d’autres langages
- constant : dont la valeur ne change pas
Tout objet est typé.
95
Constants
Exemple:
constant NUMBER_OF_BITS: integer :=0;
C’est une
valeur explicite
constant PIN_CODE: bit_vector(3 downto 0) :="0110";
Utilisation des constants rend la modification du programme

plus simple.
96
Variable
variable current_bit: std_logic := ‘0’;
Initialisation
optionnelle
• Les variables sont utilisées uniquement dans les process.
• Elles sont déclarées dans le process avant le mot clé « begin » (c’est
le begin du process).
• Contrairement aux signaux, les variables sont affectées tout de suite,
on n’a pas besoin d’attendre la suspension du process.
• Affectation se fait par ":=" et non pas par "<=" :
• current_bit := not current_bit;
97
Signal
signal carry_out : std_logic := '0';

Initialisation optionnel,
souvent ignoré en synthèse
donc utile seulement pour
simulation
- Les signaux sont comme les câbles (fils) dans un circuit
- Ils sont utilisés pour connecter les éléments concurrents d’un circuit
- L’affectation à un signal peut être retardé (uniquement en simulation,
en synthèse le retard est imposé par le circuit !):
carry_out <= '1' after 10ns;
- Les signaux sont déclarés soit dans l’entité (les ports d’entrée –
sortie), soit avant « begin » d’une architecture.
98
Signaux et variables
Les signaux interconnectent les éléments concurrents
Variables peuvent être utilisées à l’intérieur des process et ne

sont pas visibles en dehors de process.
99
Remarque
Variables:
- Peuvent être utilisées dans le process où ils sont déclarées
- Ne peuvent pas apparaitre dans la liste des sensibilités
- Ne peuvent pas être retardées
- affectation immédiate
Signaux
- Peuvent être utilisés pour relier des process
- Peuvent apparaitre dans la liste des sensibilités des process
- Peuvent être retardés
100
Types en VHDL
101
Types en VHDL
VHDL est un langage très typés.

- Tout élément doit être associé à un type
- Conversion des types est possible moyennant des fonctions
explicites
- Il est possible de définir un sous-type qui héritera les contraintes du
type d’origine
4 catégories de types
- Type scalaire : integer, reals, physique, énuméré
- Type composite: array, records
- Type accès: comme des pointeurs
- Type File
102
Type scalaire
•énuméré
type T_FEU is (ROUGE, ORANGE, VERT);
signal FEU : T_FEU;
•entier
signal COMPT : integer range 0 to 15;
•flottante
signal MASSE : REAL; -- de -1e38 à 1e38
•physique qui est un entier avec l'unité correspondant

type TIME is range … to … --64 bits
units fs; ps=1000 fs; ns=1000 ps; …
hr=60 min;
end units;
T <= 5 ns;
Formation VHDL Types en VHDL Vahid MEGHDADI
103
Remarque
type integer is range -2147483647 to 2147483647;
type real is range -1.0E308 to 1.0E308;
type time is range -2147483647 to 2147483647

units
fs;
ps = 1000 fs;
ns = 1000 ps;
us = 1000 ns;
ms = 1000 us;
sec = 1000 ms;
min = 60 sec;
hr = 60 min;
end units;
subtype natural is integer range 0 to integer’high;
subtype positive is integer range 1 to integer’high;

104
Type énuméré
Les types ci-dessous sont des types prédéfinis

type BOOLEAN is (FALSE, TRUE);
type BIT is ('0' , '1');
type severity_level is (note, warning, error, failiure);
type character is (…,’A’,’B’,…);
On peut définir son propre type. On déclare toutes les

valeurs qu'un objet de ce type peut prendre.
type T_FEU is (ROUGE, ORANGE, VERT);
signal FEU : T_FEU;
type ETAT is (INIT, LECT, ECR, ATT);
105
Type entier (scalaire)
C'est un type prédéfini

type integer is range
-2_147_483_648 to 2_147_483_647
On peut définir un sous type :

subtype nom_de_sous_type is
type_de_base contraintes;
Le type Natural existe dans le library standard:
subtype NATURAL is INTEGER
range 0 to INTEGER'high
106
Logique à valeurs multiples (scalaire)
•Il existe des signaux logiques à plusieurs états:

0, 1, mais aussi haute impédance, don’t care, non déterminé, …
•Le type "std_logic" remplace le type "bit" pour permettre d’avoir 9

états différents
•Utilisation de librairie IEEE.std_logic_1164

•exemple
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
signal SORTIE, Q: std_logic;
…
SORTIE <= ‘Z’; -- haute impédance
Q <= ‘1’;
107
Le type std_logic
‘L’
VDD
Le type std_logic : ‘0’
‘U’ non initialisé
‘X’ non connu ‘H’ ‘1’
‘0’ logique 0 Strong drive
‘1’ logique 1
‘Z’ haute impédance
‘W’ non connu
‘L’ logique 0 weak drive
‘H’ logique 1
‘-’ don’t care ‘0’
108
Haute impédance un type résolu
Les signaux à trois état doivent être

résolus. S’il est fixé à ‘0’ par un circuit et
à ‘Z’ par un autre, le simulateur ne doit
pas s’affoler mais doit savoir que le ‘0’
remporte sur ‘Z’.
109
Type composite
Deux types sont considérés : tableau et record

•Un tableau est un ensemble d’éléments du même type
•Pour un ensemble de std_logic, nous avons le type

prédéfini std_logic_vector : on définit la taille et l'ordre
des éléments
signal BUS1 : std_logic_vector (7 downto 0); -- type prédéfini

signal REG : std_logic_vector (0 to 31);
110
Accès aux éléments
•Déclaration:
A,B: std_logic_vector(15 downto 0);
•Accès direct :
A(3) <= ‘1’;
B(15) <= ‘0’;
•Accès par tranches

A(15 downto 12) <= "1011";
B(0 to 2) <= "111" ; -- erreur
A(10 downto 2) <= B(15 downto 7);
111
Accès aux éléments de tableaux
• Par agrégat
• Notation positionnelle
A(3 downto 1) <= ('0', '1', B(15));
B <= ('1','1',others => '0');
• Notation par nommage

A <= (1 =>'1', 3 =>'1',others =>'0');
• Par concaténation
signal A,B,C,D : std_logic;
signal BYTE : std_logic_vector(7 downto 0);
signal Z_BUS,A_BUS : std_logic_vector(3 downto 0);
Z_BUS <= A & C & D & B;
BYTE <= Z_BUS & A_BUS;
112
Remarque
Exemples
SIGNAL a: STD_LOGIC;
SIGNAL b: STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL c: STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL d: STD_LOGIC_VECTOR(7 DOWNTO 0);
SIGNAL e: STD_LOGIC_VECTOR(15 DOWNTO 0);
SIGNAL f: STD_LOGIC_VECTOR(8 DOWNTO 0);
……….
a <= ‘1’;
b <= ”0000”; -- Base Binaire par défaut
c <= B”0000”; -- Base Binaire explicite
d <= ”0110_0111”; -- Utiliser ‘_’ pour augmenter la lisibilité
e <= X”AF67”; -- Base Hexadecimale
f <= O”723”; -- Base Octale
113
Remarque
Exemples
•type MY_WORD is array (15 downto 0) of std_logic;

•signal mem_addr : MY_WORD;
•mem_addr(10 downto 5) <= "101010";
•type YOUR_WORD is array (0 to 15) of std_logic;

•signal data_word : YOUR_WORD := “1101100101010110”;
•type T_VAR is array (0 to 7) of integer;

•constant setting : T_VAR := (2,4,6,8,10,12,14,16);
•type T_MATRIX is array (0 to 3, 1 to 2) of natural;

•variable data_arr : T_MATRIX :=((0,2), (1,3), (4,6), (5,7));
•data_arr(0,2) := 12;
•type array_name is array (type range <>) of element_type;-- taille est
-- définie quand on déclare l'objet
•type MATRIX is array (integer range <>) of integer;
•variable MATRIX8: MATRIX (2 downto -8) := (3, 5, 1, 4, 7, 9, 12, 14, 20, 18);
114
Déclaration d’un objet de type array
•On peut définir un type tableau d’éléments scalaire

type real_vect is array (natural range <>) of real;
signal temp : real_vect(0 to 4);
Remarque: le type « real_vect » a été créé par vous.

On peut aussi:
type real_vect is array (2 to 7) of real;
signal temp : real_vect;
•On peut définir aussi un tableau de composites

type MEMO is array (0 to 1023) of std_logic_vector(7 downto 0);
signal A,B : MEMO;
115
Enregistrement (record)
Ensemble d'éléments de types différents

type NAME is
record
identifier : type_indication;
:
identifier : type_indication;
end record;
type PAQUET is
record
mot_unique : std_logic_vector (7 downto 0);
data : std_logic_vector (23 downto 0);
CRC : std_logic_vector( 5 downto 0);
num : integer range 0 to 1023;
end record;
signal paq_rec : PAQUET;
paq_rec.CRC <= "111000";
116
Opérateurs en VHDL
117
Les opérateurs
Par ordre de priorité croissante

•Opérateur logique : and, or, nand, nor, xor, xnor,
sll, srl, sra, rol, ror
•Opérateur de comparaison : =, /=, <, <=, >, >=
•Opérateur d’addition : +, -, &
•Opérateur mathématique : *, /, mod, rem
•Opérateur de signe : -
•Opérateur divers : **, abs, not
Formation VHDL Structure du VHDL Vahid MEGHDADI
118
Circuits combinatoires
119
Process combinatoire
Un circuit combinatoire donne toujours les mêmes sorties

pour les mêmes entrées
Un process est combinatoire si les conditions suivantes sont
toutes respectées :
•le process comporte une liste de sensibilité
•la liste de sensibilité comprend tous les signaux lus
•tous les signaux doivent être affectés quelle que soit les
entrées (Attention dans un "if-else" ou dans un "case")
•toutes les variables doivent être affectées avant d'être lues
120
Circuits combinatoires : équation logique
Architecture COMB1 of NONET is

begin
Architecture COMB3 of NONET is
--équation logique begin
S <= A nand B; --Traduction de la table
end COMB1; --de vérité dans un process
process(A,B)
begin
if A='1' and B='1' then
Architecture COMB2 of NONET is S <= '0';
begin else
--Traduction de la table S <= '1';
--de vérité dans un process end if;
S <= '0' when A='1' and B='1' end process;
else '1'; end COMB3;
end COMB2;
121
Exemple
Transcription d’une table de vérité
A(2) A(1) A(0) S(2) S(1) S(0)

0 0 0 0 0 0
0 0 1 0 0 1
0 1 0 0 1 1
0 1 1 0 1 0
1 0 0 1 1 0
1 0 1 1 1 1
1 1 0 1 0 1
1 1 1 1 0 0
122
Affectation conditionnelle
Dans une zone séquentielle (process)
Architecture AVEC_IF of CIRCUIT

signal A,S : std_logic_vector (2 downto 0);
begin
process(A)
begin
if A = "000" then S <= "000";
elsif A ="001" then S <= "001";
elsif ...
end if;
end process;
end AVEC_IF;
123
Affectation sélective séquentielle
Dans une zone séquentielle (process)

Architecture AVEC_CASE of CIRCUIT
begin
process(A)
begin
case A is
when "000" => S <= "000"
when "001" => S <= "001"
when "011" => S <= "010"
…
end case
end process;
end AVEC_CASE;
Formation VHDL Circuits combinatoires Vahid MEGHDADI
124
Remarque
Affectation sélective concurrente
Dans une zone concurrente (architecture)
Architecture AVEC_WITH of CIRCUIT

begin
with A select
S <= "000" when "000" ,
"001" when "001" ,
"011" when "010" ,
"110" when "100" ,
…
"000" when others;
end AVEC_WITH;
125
Remarque
Affectation non conditionnelle

Architecture DIRECT of CIRCUIT
begin
S(2) <= (A(2) and not A(1) and not A(0))
or (A(2) and not A(1) and A(0))
or (A(2) and A(1) and not A(0))
or (A(2) and A(1) and A(0));
S(1) <= (not A(2) and A(1) and not A(0))

or (not A(2) and A(1) and A(0))
or (A(2) and not A(1) and not A(0))
or (A(2) and not A(1) and A(0));
…
126
Remarque
Affectation conditionnelle concurrente

Architecture AVEC_WHEN of CIRCUIT
begin
S <= "000" when A= "000"
else "001" when A= "001"
else "011" when A= "010"
else "010" when A= "011"
else "110" when A= "100"
else "111" when A= "101"
else "101" when A= "110"
else "100" when A= "111"
else "000";
end AVEC_WHEN;
127
Remarque
Exemple : ALU
entity ALU is
port(A : in std_logic_vector(7 downto 0);
B : in std_logic_vector(7 downto 0);
Sel: in std_logic_vector(1 downto 0);
Res: out std_logic_vector(7 downto 0));
end ALU;
-- Sel="00" => Addition
-- Sel="01" => Soustraction
-- Sel="00" => et logique bit à bit
-- Sel="00" => ou logique bit à bit
architecture behv of ALU is
begin
process(A,B,Sel)
….
end process;
end behv;
128
Remarque
Exemple : ALU (suite)
process(A,B,Sel)
begin
case Sel is
when "00" =>
Res <= A + B;
when "01" =>
Res <= A + (not B) + 1; -- ou A - B
when "10" =>
Res <= A and B;
when "11" =>
Res <= A or B;
when others =>
Res <= "--";
end case;
end process;
129
Remarque
Exemple : Multiplieur
Le but est de réaliser un multiplieur 4 bits fois 4 bits

0 A
A 1001
B *1101 0 B(0) 0
4 4 4
--------- B(1)
0
0000 1001 4
5 B(2)
+0000 0000 0
4
+0010 0100 res(0) (4 downto 1) 5 B(3)
+0100 1000
res(1) (4 downto 1) 5
----------
0111 0101 res(2) (4 downto 1)
res(7 downto 3)
130
Remarque
Exemple : Multiplieur (suite)
entity main is
Port ( A : in std_logic_vector(3 downto 0);
B : in std_logic_vector(3 downto 0);
RES : out std_logic_vector(7 downto 0));
end main;
architecture Behavioral of main is

begin
process (A,B)
variable result : std_logic_vector(7 downto 0);
begin
result := (others => '0');
for I in 0 to 3 loop
if B(I)='1' then
result(I+4 downto I) := result(I+4 downto I) + ('0' & A);
end if;
end loop;
RES <= result;
end process;
end Behavioral;
131
Chapitre : Machine à états finis
•Toute information du passé est sauvegardée dans l’état actuel du circuit
•L’état interne est préservé dans des registres (bascules). Une machine à
états comporte au moins log bascules.
•L’état prochain dépend de l’état actuel et des entrées
•Le changement d’état se fait sur le front de l’horloge
•Machine de Moore : les sorties ne dépendent que de l’état courant.
•Machine de Mealy : les sorties dépendent de l’état courant mais aussi des
entrées
Formation VHDL Machine à états finis Vahid MEGHDADI
132
Présentation graphique
•Les cercles présentent les états possibles

d’une machine à états finis
E1E2= "11"
•Les flèches représentent les changements
possible s0
E1E2= "10"
•Les conditions sont présentées sur les flèches
•Les changements d’état se réalisent sur le E1E2="0-"

front de l’horloge s1
s2
•L’horloge est implicite
E1E2= "1-"
133
Séparation des logiques
Dans un automate synchrone il existe

•une logique combinatoire permettant le calcul de l'état suivant
•une logique combinatoire permettant le calcul des sorties
•une partie séquentielle synchrone qui se charge du changement d'état du
système au moment voulu.
Deux types de réalisation

•un seul process regroupant les parties combinatoire et séquentielle
(adapté aux petites machines)
•un process séquentielle synchrone pour changement d’état et deux
process combinatoires (pour calculer l’état prochain et les sorties)
134
Implantation par un seul process
État courant
type T_ETAT is (E1, E2, E3);
signal etat : T_ETAT;
... Logique D Q
Process(CLK) ENTREE combinatoire CLK
begin CLK Registre
if CLK'event and CLK='1‘ then
d’états
case etat is
when E1 => -- mise à jour des sorties pour état E1
if <cond> then ETAT <= E3; end if;
when E2 => -- mise à jour des sorties pour état E2 • Process n’est pas
ETAT <= E3 combinatoire
when E3 => -- mise à jour des sorties pour état E3
if <cond> then ETAT <= E1; • Très simple à écrire
elsif <cond> then ETAT <= E2;
end if; • Ne convient pas aux
end case; machines complexes
end if;
end process;
135
Implantation par des process séparés (plus robuste)
Moore Mealy
E1
Fonction
combin- S1
atoire
E2
S2
F
Fonction
combin-
ETAT_COUR
atoire ETAT_FUTUR Registre
d'états
G H
RAZ
136
Programmation logique séparée
•Déclaration des signaux :

signal E1,E2,S1,S2,H,RAZ : std_logic
•Déclaration des états :

type T_ETAT is (ETAT1, ETAT2, ETAT3);
signal ETAT_COUR, ETAT_FUTUR : ETAT;
•Avancement dans l’état (process synchrone)

REG : process (H, RAZ)
begin
if RAZ = ‘0’ then ETAT_COUR <= ETAT1;
elsif H’event and H = ‘1’ then
ETAT_COUR <= ETAT_FUTUR;
end if;
end process;
137
Programmation de la partie combinatoire G
G : process (E1,E2,ETAT_COUR) -- Tous les signaux

-- d’entrée sont dans la liste de sensibilité
begin
case ETAT_COUR is
when ETAT1 =>
-- suivant la valeur de E1 et E2 on
-- affecte à ETAT_FUTUR une valeur
when ETAT2 =>
-- suivant la valeur de E1 et E2 on Attention aux
-- affecte à ETAT_FUTUR une valeur conditions
when ETAT3 => nécessaires pour
qu’un process soit
combinatoire !
-- affecte à ETAT_FUTUR une valeur
end case;
end process;
138
Programmation de la partie combinatoire F
F : process (E1,E2,ETAT_COUR) -- Tous les signaux

begin
case ETAT_COUR is
when ETAT1 =>
-- affecte aux sorties les valeurs correspondantes
when ETAT2 =>
when ETAT3 =>
end case;
end process;
Peut être intégré dans G !
139
Remarque
Rappels généraux (1)
•Les fonctions F et G peuvent être décrites dans le même process
•Si le process est synthétisé par un circuit séquentiel synchronisé

sur front d’horloge, il ne doit comporter dans la liste de sensibilité
que l’horloge et éventuellement une RAZ synchrone ou asynchrone
et rien d'autre :
process(CLK,RESET) -- avec un Reset Asynchrone

begin
if RESET='0' then ……………..
elsif CLK'event and CLK='1' then……………………….
end if;
end process,
140
Remarque
Rappels généraux (2)
•Si le process est synthétisé pour un circuit

combinatoire, il doit comporter dans la liste de
sensibilité tous les signaux lus.
•S’il y a un test (if ou case) pour un signal dans un

process combinatoire, ce test doit couvrir toues les
possibilités (ne pas oublier le else), et toutes les
sorties doivent être affectées dans toutes les
branches du test.
141
Remarque
Exemple de la partie combinatoire F
F : process (E1,E2,ETAT_COUR) -- Tous les signaux

begin
case ETAT_COUR is
when ETAT1 =>
if E1 = '0' and E2 = '0' then
S1 <= ‘0’; S2 <= ‘0’;
elsif E1 = ’1 ’ then
S1 <= ‘1’ ; S2 <= ‘0’;
else S1 <= ‘0’; S2 <= ‘1’;
end if;
when ETAT2 => -- S1 et S2 <= …...
when ETAT3 => -- S1 et S2 <= …...
end case;
end process;
142
Remarque
Exemple écran VGA
CLK HS
fclk=25MHz
143
Remarque
Ecran VGA: Conception RTL
HS <= '1' when etat_cour = PW else '0';

144
Remarque
Ecran VGA Programme VHDL
FSM: process(etat_cour, count) when others => type t_etat is (PW, BP, DISP, FP);
begin if count = 0 then
case etat_cour is signal etat_cour, etat_futur : t_etat:=PW;
etat_futur <= PW;
when PW => else
if count = 96 then etat_futur <= FP;
etat_futur <= BP; end if;
else end case;
etat_futur <= PW; end process;
end if;
when BP =>
if count = 144 then
etat_futur <= DISP;
else
etat_futur <= BP;
end if;
when DISP =>
if count = 784 then
etat_futur <= FP;
else
etat_futur <= DISP;
end if;
145
Techniques de programmation
146
Utilisation de « Clock Enable »
E
S
• Tous les évènements sont
EN
synchronisés sur le front (montant) de
l’horloge. CLK
• Pour exécuter une partie du code à

des fréquences moins rapides que CLK
l’horloge, on utilise les signaux
« clock enable ». EN1
• Ce sont des impulsions dont la durée process(CLK)

begin
de ‘1’ est exactement une seule
période d’horloge. if EN = '1' then
--suite d’instructions
• La répétition de ces impulsions donne end if;
la fréquence d’exécution du code. end if;
end process;
147
Periodic Clock Enable Generation
CLK T=10 ns
EN1 T=80 ns
EN2 T=210 ns
process (CLK)
begin
if rising_edge(CLK) then
EN1 <= ‘0’; EN2<=‘0’;
EN1 cmp1 <= cmp1 + 1;cmp2 <= cmp2 + 1;
CLK Timing if cmp1 = 7 then EN1 <= ‘1’;
generator EN2 cmp1 <= 0;
end if;
if cmp2 = 20 then EN2 <= ‘1’;
cmp2 <= 0;
end if;
end if;
end process;
Enable usage
CLK T=10 ns
EN T=80 ns
To execute some lines at EN rate, use general CLK in conjunction with EN.
process (CLK)
begin
CLK if rising_edge(CLK) then
A process if EN = ‘1’ then
EN repeated every --
80 ns -- write the code here
--
end if;
end if;
end process;
Example : Two-digit timer
Create a hexa-decimal two-digit timer counting from 00 to FF
Input CLK frequency = 1 MHz
CLK
CLK Event that should make
2-digit 8 the counter to
CLK Timing en counter en increment.
generator
process (CLK)
process (CLK) Begin
begin
if rising_edge(CLK) then if rising_edge(CLK) then
en <= '0'; if en = '1' then
cmp <= cmp + 1;
if cmp = 999_999 then counter <= counter + 1;
en <= ‘1’; end if;
cmp <= 0; end if;
end if; end process;
end if;
end process;
Example : Traffic light
Create a traffic light with Red: 14 sec, Green: 12 sec, and yellow 2 sec.
Input CLK frequency = 1 MHz

For this example we will use a state machine with three states : red, green and yellow.
We use a timer counting from 0 to 27 as below:
0 1 2 13 14 15 25 26 27
red Red 14 sec Green 12 sec Yellow

If timer=27, If timer=13, 2 sec
Next_state = red next-state = green process (CLK)
begin
if en = '1' then
yellow green timer <= timer + 1;
if timer = 27 then
If timer <= 0;
timer=25 end if;
Next_state = yelllow end if;
end if;
end process;
Example : Traffic light (continue …)
State machine creation

-- type definition process (CLK)
type traffic_light_T is (red, green, yellow); begin
Signal state, next_state : traffic_light_T := red; if rising_edge(CLK) then
if en = '1' then
state <= next_state;
-- state machine (combinatory) end if;
process(state, timer) end if;
begin end process;
case state is
when red =>
if timer = 13 then next_state = green; next_state
else next_state = red;
end if;
when green => EN state
if timer = 25 then next_state = yellow; State Register
else next_state = yellow;
CLK
end if;
when others =>
if timer = 27 then next_state = red;
else next_state = yellow; state
end if; next_state
end case; Timer Comb
end process;
Example : Traffic light, timing diagram
CLK process (CLK)

begin
en
if en = '1' then
state <= next_state;
end if;
timer 12 13 14 15 end if;
end process;
state red red green green

R
next_state red green green green CLK Y
Traffic_light
The entity
G
process(state, timer)
begin
case state is
when red =>
if timer = 13 then next_state = green; R <= '1' when state = red else '0';
else next_state = red; Y <= '1' when state = yellow else '0';
end if; G <= '1' when state = green else '0';
. . .
Exemples
process(CLK)
begin
REG <= REG(0) & REG(7 downto 1); -- rotate right
REG <= ‘0’ & REG(7 downto 1); -- shift right logical
REG <= REG(7) & REG(7 downto 1);
end if;
end process
Les valeurs signées

Z <= (X(7) & X(7 downto 0)) + (Y(7) & Y(7 downto 0));
Les valeurs non signées

Z <= (‘0’ & X(7 downto 0)) + (‘0’ & Y(7 downto 0));
154
Exemple 4, affichage multiplexé
155
Préparation de l’horloge
Horloge de la carte est à 100 MHz

Supposons qu’une horloge à approximativement 50 KHz est nécessaire:
Une division par : 100 x 106 / 50 x 103 = 2000
Programme VHDL
CLK_EN_Gene : Process(CLK)
Begin
if CLK’event and CLK=‘1’ then CLK_EN
CLK_EN <= ‘0’; CLK
cmp <= cmp + 1; CLK CLK_EN
if cmp = 1999 then
CLK_EN <= ‘1’; CLK_EN_Gene
cmp <= 0;
end if;
end if;
End process;
cmp
156
Machine à états
type T_ETAT is (SEG1, SEG2, SEG3, SEG4);

signal etat : T_ETAT;
process(CLK) -- une autre alternative

begin
if CLK’event and CLK=‘1’ then signal etat : integer range 0 to 3;
if CLK_EN = ‘1’ then
case ETAT is
when SEG1 => etat <= SEG2; process(CLK)
when SEG2 => etat <= SEG3; begin
when SEG3 => etat <= SEG4; if CLK’event and CLK=‘1’ then
when SEG4 => etat <= SEG1; etat <= etat + 1;
when others => etat <= SEG1; end if;
end case; end process;
end if;
end if;
end process;
157
Circuit complet
with etat select with HEX select

An <= "0111" when SEG1,
SEG<= "1111001" when "0001", --1
"1011" when SEG2,
"0100100" when "0010", --2
"1101" when SEG3,
"0110000" when "0011", --3
"1110" when others;
"0011001" when "0100", --4
"0010010" when "0101", --5
with etat select
"0000010" when "0110", --6
HEX <= "0001" when SEG1,
"1111000" when "0111", --7
"1001" when SEG2,
"0000000" when "1000", --8
"0100" when SEG3,
"0010000" when "1001", --9
"0101" when others;
"0001000" when "1010", --A
"0000011" when "1011", --b
"1000110" when "1100", --C
"0100001" when "1101", --d
"0000110" when "1110", --E
"0001110" when "1111", --F
"1000000" when others; --0
158
Remarque
Exemple 7- CNA AD5541A
Pour que le CNA produise une tension analogique à partir d’une

donnée de 16 bits, il faudra respecter le timing donné par le
constructeur.
159
Remarque
Exemple 7- AD5541A Timing Diagram
Générer une horloge à f=1/t1
DIN change sur le front

descendant de SCLK
Génération de CS
Génération de LDAC
La donnée est à envoyée en série (MSB d’abord)
160
Remarque
Exemple 7- AD5541A contraintes de Timing
Fclk=25MHz
On fixe à 1/25MHz=40ns
161
Remarque
Exemple 7- Interface CNA
Le but est de créer l’interface CNA pour simplifier le dialogue

avec le CAN. Ainsi, pour dialoguer avec l’interface, on n’aura
qu’un bus de 16 bits et un signal STRB (Strobe).
162
Remarque
Exemple 7- Conception
Une machine à état

- État repos (CS<=‘0’; DIN <= ‘Z’; LDAC <= ‘1’);
- Dès qu’on détecte ‘1’ sur STRB
- on envoie ‘1’ sur CS
- État change en envoie
- On envoie les 16 bits de DATA un par un (MSB d’abord)

- 16 bits envoyés, on attend une période d’horloge (état tempo)
- Etat fin pour finaliser (LDAC <= ‘1’)
163
Remarque
Exemple 7- Programmation un seul process
signal cmp : integer range 0 to 15; when envoi =>

signal reg : std_logic_vector (15 downto 0); CS <= '0';
type T_etat is (repos, envoi, tempo, fin); DIN <= reg(cmp);
signal etat : T_etat := repos; cmp <= cmp - 1;
process(CLK) if cmp = 0 then
begin etat <= tempo;
if CLK'event and CLK='0' then end if;
case etat is when tempo =>
when repos => DIN <= 'Z';
CS <= '1'; CS <= '1';
LDAC <= '1'; etat <= fin;
cmp <= 15; when others => -- etat = fin
DIN <= 'Z'; LDAC <= ‘0';
if STRB = '1' then cmp <= 15;
reg <= DATA; etat <= repos;
etat <= envoi; end case;
end if; end if;
end process;
164
Remarque
Exemple 7- Conception robuste
165
Remarque
Exemple 7- Programme
process(CLK)
entity AD5541A is begin
Port ( CLK : in STD_LOGIC; if CLK'event and CLK='1' then
DATA : in STD_LOGIC_VECTOR (15 downto 0); if STRB = '1' then
STRB : in STD_LOGIC; reg <= DATA;
CS : out STD_LOGIC; end if;
DIN : out STD_LOGIC; end if;
LDAC : out STD_LOGIC; end process;
SCLK : out STD_LOGIC);
end AD5541A; process(CLK)
begin
architecture Behavioral of AD5541A is if CLK'event and CLK='1' then
type t_etat is (repos, e_cs, envoie, tempo, e_ldac); etat_cour <= etat_futur;
signal etat_cour, etat_futur : t_etat:= repos; end if;
signal count : integer range 0 to 31:=0; end process;
signal raz : std_logic;
signal reg : std_logic_vector(15 downto 0); process(CLK)
Begin begin
SCLK <= not CLK; if raz = '1' then
DIN <= reg(16-count) when etat_cour = envoie else 'Z'; count <= 0;
CS <= '1' when etat_cour = e_CS else '0'; else
LDAC <= '0' when etat_cour=e_ldac else '1'; count <= count + 1;
end if;
end if;
end process;
166
Remarque
Exemple 7- Programme
process(etat_cour, count, STRB)

begin
etat_futur <= etat_cour;
raz <= '0';
case etat_cour is when tempo =>
when repos => if count = 17 then
raz <= '1'; etat_futur <= e_ldac;
if STRB = '1' then end if;
etat_futur <= e_cs;
end if; when others => -- e_ldac
if count = 18 then
when e_cs => etat_futur <= repos;
if count = 0 then end if;
etat_futur <= envoie;
end if; end case;
end process;
when envoie =>
if count = 16 then end Behavioral;
etat_futur <= tempo;
end if;
167
Remarque
Exemple 7- Résultat de simulation
168
Technique de
programmation
169
Attention !
Les instructions suivantes sont

interdites dans une zone concurrente
Architecture x of y is
Begin +1
A <= not A;
CMPT <= CMPT + 1;
REG <= REG (0) & REG(7 downto 1);
…...
end x;
170
Correction
On utilise un process D Q
synchronisé sur un front CLK

process (CLK)
begin
if rising_edge(CLK) then D Q +1
A <= not A;
-- CMPT <= CMPT + 1; CLK
-- etc;
end if;
end process;
Formation VHDL Circuits

Attention
séquentiels
! Vahid MEGHDADI
171
Process synchrones!
Dans un process synchrone il faut respecter un des deux canevas ci-dessous
process(CLK) uniquement CLK dans la liste de sensibilité

begin
if CLK’event and CLK=‘1’ then process ne contient qu’un grand if
-- suite d’instructions qui peut contenir d’autre if
end if; tout de suite après : end process
end process;
process(CLK, RST) CLK et le signal reset dans la liste de sensibilité

begin
if RST = ‘1’ then process ne contient qu’un grand if-else
-- suite d’instructions qui peut contenir d’autre if
elsif CLK’event and CLK=‘1’ then
-- suite d’instruction qui peut contenir d’autre if
end if; tout de suite après : end process
end process;
172
Les sous-programmes
But des sous-programmes

•Pour écrire des algorithmes réutilisables
•Pour augmenter la lisibilité
Deux classes des sous-programmes
•Les procédures
•Les fonctions
Formation VHDL Les sous-programmes Vahid MEGHDADI
173
Procédure
•Mot clé procedure

•L'appel d'une procédure est une instruction concurrente
ou séquentielle
•Peut retourner plusieurs valeurs
•Peut agir sur les signaux globaux
•Peut se synchroniser (avec wait dedans)
•Corps d'une procédure est une zone séquentielle
174
Fonction
•Mot clé function

•L'appel est à droite d'une affectation
•L'appel peut se faire dans la zone concurrente ou
séquentielle
•Retourne une seule valeur
•Rend immédiatement sa valeur
•Corps d'une fonction est une zone séquentielle
175
Ecriture des sous-programmes
Un sous-programme est constitué

•D'une déclaration : interface
•D'un corps : algorithme
Syntaxe de la déclaration
•procedure <nom> (liste des paramètre);
•function <nom> (liste des paramètre) return type_du_résultat;
176
Déclaration des sous-programmes
Liste_des_paramètre :
{classe_d'objet} PARAM1 :{mode} type{:=valeur_par_défaut}
•class_d'objet : signal, variable, constant
•mode : in, out, inout
Restriction
•pas de paramètres out ou inout dans la déclaration d'une
fonction
•pas de variable transmise à une fonction
•classe d'objet par défaut est "constant" pour les "in" et
"variable" pour les "out" et "inout"
177
Corps de sous-programme
Entête is -- function ou procedure

{zone de déclarations}
begin
{partie instruction séquentielle}
end {nom_de_sous-programme}
Exemple
function MIN (signal A,B : integer) return integer is
begin
if A < B then return A
else return B
end if;
end MIN;
178
Appel de sous-programme
Différentes formes d'appel

•Par position (même ordre que la déclaration)
•RESULTAT <= MIN (SIG1, 5);
•Par nom (ordre non important)
•RESULTAT <= MIN (B=> 5, A=> SIG1);
•RESULTAT <= MIN (A=> SIG1, B=> 5);
179
Exemple
-- HEX-to-seven-segment decoder
-- HEX: in STD_LOGIC_VECTOR (3 downto 0);
-- LED: out STD_LOGIC_VECTOR (6 downto 0);
--
-- segment encoding
-- 0
-- ---
-- 5 | | 1
-- --- <- 6
-- 4 | | 2
-- ---
-- 3
Formation VHDL Exemples Vahid MEGHDADI
180
Programmation concurrente
with HEX select

LED<= "1111001" when "0001", --1
"0100100" when "0010", --2
"0110000" when "0011", --3
"0011001" when "0100", --4
"0010010" when "0101", --5
"0000010" when "0110", --6
"1111000" when "0111", --7
"0000000" when "1000", --8
"0010000" when "1001", --9
"0001000" when "1010", --A
"0000011" when "1011", --b
"1000110" when "1100", --C
"0100001" when "1101", --d
"0000110" when "1110", --E
"0001110" when "1111", --F
"1000000" when others; --0
181
Utilisation de fonction
function DECODE (signal HEX: std_logic_vector(3 downto 0))

return std_logic_vector(6 downto 0) is
begin
case HEX is
when "0001" => return "1111001"; --1
when "0010" => return "0100100"; --2
when "0011" => return "0110000"; --3
when "0100" => return "0011001"; --4
when "0101" => return "0010010"; --5
when "0110" => return "0000010"; --6
when "0111" => return "1111000"; --7
when "1000" => return "0000000"; --8
when "1001" => return "0010000"; --9
when "1010" => return "0001000"; --A
………...
when others => return « 1000000"; -- 0
end case;
end;
182
Paquetage
Il donne la possibilité de
•Regrouper des codes communs dans un travail en équipe
•Déclarer des types et des sous-types
•Déclarer des objets (signaux, constants)
•Déclarer des sous-programmes
•Déclarer des alias
Formation VHDL Paquetage Vahid MEGHDADI
183
Syntaxe de Paquetage
Package <nom_de_paquetage> is
<suite de déclarations>
end {<nom_de_paquetage>};
package pak_test is
subtype OCTET is std_logic_vector(7 downto 0);

subtype MOT is std_logic_vector(15 downto 0);
Exemple:
constant PAQUET_SIZE : integer := 11;
function INT_TO_7SEG (constant CHIFFRE :

in std_logic_vector(3 downto 0)) return OCTET;
end pak_test;
184
Paquetage de composants
Le paquetage permet aussi de grouper la déclaration d'un

ensemble de composants.
Exemple :
package STANDARD_CELL is
component INVERSEUR
port (E : in bit; S : out bit);
end component;
component PORTE_OU
port (A,B : in bit; S : out bit);
end component;
….
end STANDARD CELL;
185
Corps de Paquetage
Décrit l'algorithme des sous-programmes déclarés dans le

package.
Syntaxe :
package body <nom_de_paquetage> is
{corps de sous-programmes}
end <nom_de_paquetage>;
186
Exemple de Corps de Paquetage
package body pak_test is
function INT_TO_7SEG (constant CHIFFRE : in std_logic_vector

(3 downto 0)) return OCTET is
variable SEG : std_logic_vector(7 downto 0);
begin
case CHIFFRE is
when "0001" => SEG := "01111001" ; --1
when "0010" => SEG := "00100100" ; --2
…….
when "1111" => SEG := "00001110" ; --F
when others => SEG := "01000000" ; --0
end case;
return SEG;
end INT_TO_7SEG;
end pak_test;
187
Utilisation de paquetage
•On crée d'abord une librairie

•Sous ISE, new source --> VHDL library
•Ecrire le paquetage et son corps
•Ajouter à la librairie que l'on souhaite
•Sous ISE, sélectionner le fichier et ensuite--> move
to library
•Dans le programme utilisant cette librairie :
library <mon_lib>
use <mon_lib>.<mon_paquetage>
188
Configuration
Une entité peut avoir plusieurs architectures

Un rôle de configuration : choisir l'architecture
correspondante
Exemple : Pour l'entité additionneur on peut
envisager 3 architectures différentes : A, B et C
ADDITIONNEUR(A)
ADDITIONNEUR(B)
ADDITIONNEUR(C)
A chaque instanciation de l'entité, un seul couple
entité/architecture peut être compilé.
Formation VHDL Configuration Vahid MEGHDADI
189
Choix de l'architecture
Deux façons pour relier une architecture précise à une

entité :
•Dans une unité de compilation autonome : la
configuration
•Dans la partie déclarative d'un bloc ou d'une
architecture (configuration "à la volée")
(Par défaut c'est la dernière compilée qui sera prise en
compte)
190
Exemple de Configuration
Entity SIM is end;

architecture ESSAI1 of SIM is
component ADD
Entity ADD is port (A,B : in integer;
S : out integer);
port (A,B : in integer; end component;
S : out integer); signal X,Y,SUM : integer;
end ADD; begin
INST1 : ADD port map (X,Y,SUM);
architecture FONCTION of ADD is X <= 12, 55 after 100 ns;
Y <= 0, 100 after 200 ns;
begin end ESSAI1;
S <= A+B; configuration CONF of SIM is
end FONCTION; for ESSAI1
for INST1 : ADD
use entity work.ADD(FONCTION)
end for;
end for;
end CONF;
191
Exemple de Configuration "à la volée"
Entity SIM is end;

architecture ESSAI1 of SIM is
component ADD
Entity ADD is port (A,B : in integer;
port (A,B : in integer; S : out integer);
S : out integer); end component;
end ADD; for all : ADD
use entity work.ADD(FONCTION);
-- ou
architecture FONCTION of ADD is -- for INST2 : ADD
begin -- use entity work.ADD(FONCTION);
S <= A+B;
signal X,Y,SUM : integer;
end FONCTION;
begin
INST2 : ADD port map (X,Y,SUM);
X <= 12, 55 after 100 ns;
Y <= 0, 100 after 200 ns;
end ESSAI1;
192
Les Attributs
•Attribut sur les signaux:

•signal_name'attribut
•l'attribut synthétisable : event
•If CLK'event and CLK='1' then …
•attribut sur le type array

•type MYARR is array (-2 to 4) of integer;
•MYARR’left returns -2
•MYARR’right 4
•MYARR’high 4
•MYARR'low -2
•MYARR’reverse_range 4 downto to -2
Formation VHDL Les Attributs Vahid MEGHDADI
193
Alias
Intérêt
•Donne un nom différent (plus lisible) à un objet
•l'ancien nom reste utilisable
Syntaxe
•alias nouveau_nom : type_ou_sous_type is ancien_nom
Exemple
variable V32 : std_logic_vector (0 to 31);
alias P_8 : std_logic_vector (0 to 7) is V32(0 to 7);
alias D_8 : std_logic_vector (0 to 7) is V32(24 to 31);
alias SIGNE : std_logic is V32(0);
...
SIGNE := '1'; -- identique que V32(0) <= ‘1’;
Formation VHDL Alias Vahid MEGHDADI
194
Encodage d'état dans une machine à état
•Encodage d'états peut se faire manuellement :

type t_etat is (S1, S2, S3, S4, S5);
-- encodage binaire
attribute enum_code : string;
attribute enum_code of t_etat : type is "000 001 010 011 100";
-- S1 est codé en "000", S2 en "001", S3 en "011" et …
signal etat : t_etat;
•On peut laisser le compilateur choisir le codage

Formation VHDL Encodage d'état dans une machine à état Vahid MEGHDADI
195
Codage one-hot
La méthode préférée pour les circuits énormes est le codage

one-hot
-- encodage binaire
attribute enum_code : string;
attribute enum_code of t_etat : type is "00001 00010 00100 01000
10000";
-- S1 est codé en "00001", S2 en "00010", S3 en "00100" et …
Remarque:
Ne pas oublier d'initialiser l'état avec un signal RESET
Formation VHDL Encodage d'état dans une machine à état Vahid MEGHDADI
196
for Generate
for-generate (à utiliser dans la zone concurrente) permet de

répéter un circuit plusieurs fois.
Exemple : BIT0 : FULL_ADD port map (X(0) , Y(0) , ’0’ , Z(0) , C(0));
BIT1 : FULL_ADD port map (X(1) , Y(1) , C(0) , Z(1) , C(1));
….
BIT7 : FULL_ADD port map (X(7) , Y(7) , C(6) , Z(7) , C(7));
LABEL : for i in 1 to 7 generate

ADDITION : FULL_ADD port map (X(i), Y(i), C(i-1), Z(i), C(i);
end generate
BIT0: FULL_ADD port map (X(0) , Y(0) , ’0’ , Z(0) , C(0));
Formation VHDL For generate Vahid MEGHDADI
197
Généricité
C’est un moyen de transmettre des infos à un component

pour le rendre paramétrable.
Exemples : une porte ET à N entrées, un registre à

décalage de taille N, un multiplexeur N vers 1, …
Syntaxe :
generic (param1 : type de param1 := valeur par défaut;
param2 : type de param2 := valeur par défaut;
...);
Formation VHDL Généricité Vahid MEGHDADI
198
Exemple
Porte ET à N entrées :
entity PORTE_ET is
generic(N : integer := 2);
port(ENTREE : in std_logic_vector(1 to N);
SORTIE : out std_logic);
end entity;
…
process (ENTREE)
variable V : std_logic;
begin
V := '1';
for I in 1 to N loop
V := V and ENTREE(I);
end loop;
SORTIE <= V;
end process;
199
Appel d’un bloc paramétrable
component PORTE_ET
generic(N :integer := 2);
port(ENTREES : in std_logic_vector(1 to N);
SORTIE : out std_logic);
end component;
…
architecture A of B is
begin
INST : PORTE_ET generic map(N => 5)

port map(ENTREES => A,
SORTIE => Z);
…
end A;
200
If Generate
If-generate permet de architecture A of generate_test is

signal clk_r : std_logic:= '1';
synthétiser un circuit begin
suivant une condition U1: if CLK_DIV generate
process(CLK)
begin
Exemple : if CLK'event and CLK='1' then
clk_r <= not clk_r;
end if;
entity generate_test is end process;
generic ( CLK_DIV : boolean :=TRUE); end generate;
Port ( CLK : in std_logic;
U2: if not CLK_DIV generate clk_r <= clk;
sortie : out std_logic); end generate;
end generate_test;
sortie <= clk_r;
end A;
Formation VHDL If generate Vahid MEGHDADI
201
Conseils de synthèse
•Utiliser le nom du fichier le même que le nom de l'entité

•Ne pas mettre plus d'un couple entity/architecture dans un
fichier
•Les noms des signaux peuvent être jusqu'à 256 caractères.
Ne pas hésiter à donner un nom signifiant à des signaux
(constantes, variables, types, etc)
•Quand vous appelez un component, utilisez les paramètres
de passage par nom :
•U1 : HALF_ADD port map(A =>oper1, B=>oper2, SUM =>somme,
C=>retenue);
Formation VHDL Conseils de synthèse Vahid MEGHDADI
202
Conseils (2)
•Ne jamais utiliser des signaux ou des variables pour des

constantes (cela gaspille les ressources énormément),
•Xilinx recommande de n'utiliser que les std_logic ou

std_logic_vector pour les types des ports dans les entités.
•Eviter, si c'est possible, l'utilisation de "buffer" pour les

signaux de sortie qui sont lus dans l'architecture. A la place,
déclarer un signal interne avec la même valeur et utiliser "out"
pour le signal de sortie
203
Conseils (3)
•Privilégier l'utilisation des signaux par rapport aux

variables
•Les instructions wait for xx ns, et after xx ns ne se

synthétisent pas
•Les valeurs initiales ne sont normalement pas tenue

compte en synthèse :
•signal SUM : std_logic_vector(3 downto 0) := "1100";
204
Ordre des opérations
Ordre dans une expression arithmétique

ADD <= A1 + A2 + A3 + A4;
ADD <= (A1+A2) + (A3+A4)
Donnent le même résultat mais pas forcement le même circuit

A1
A2
A3 ADD
A4
A1
A2 ADD
A3 Un circuit plus rapide
A4
205
"if" ou "case", la différence
Pour un circuit de décodage, "if" produit

un circuit à priorité tandis que "case", un
circuit équilibré
•Utiliser "case" pour un décodage architecture A of if_ex is
begin
complexe IF_PRO: process (SEL,A,B,C,D)
begin
•Utiliser "if" pour favoriser les chemins if (SEL=”00”) then MUX_OUT <= A;
lents elsif (SEL=”01”) then MUX_OUT <= B;
elsif (SEL=”10”) then MUX_OUT <= C;
elsif (SEL=”11”) then MUX_OUT <= D;
else MUX_OUT <= '0';
entity if_ex is end if;
port (SEL: in std_logic_vector(1 downto 0); end process; --END IF_PRO
A,B,C,D: in std_logic; end BEHAV;
MUX_OUT: out std_logic);
end if_ex;
206
Circuit résultant
207
Utilisant "case"
architecture BEHAV of case_ex is

begin
CASE_: process (SEL,A,B,C,D)
begin
entity case_ex is case SEL is
port (SEL: in std_logic_vector when “00” => MUX_OUT <= A;
(1 downto 0); when “01” => MUX_OUT <= B;
A,B,C,D: in std_logic; when “10” => MUX_OUT <= C;
MUX_OUT: out std_logic); when “11” => MUX_OUT <= D;
end case_ex; when others=> MUX_OUT <= '0';
end case;
end process;
end BEHAV;
208
Circuit résultant
209
Génération des latch
Une instruction "if" incomplet synthétise un latch (un

verrou):
if A=B then C <= '1';
end if;
Si ce n'est pas ce que l'on souhaite, il faut ajouter la branche

else.
if A=B then C <= '1';
else C<= ‘0’;
end if;
210
Partage des ressources
Process (A,B,C,COND) COND

Variable Z1,Z1 : ….. ;
begin
Z1 := A+B; B
Z2 := A+C;
if COND='1' then A
Z <= Z1;
else Z <= Z2; C
end if;
end process;
COND
Process (A,B,C,COND)
variable TMP : ..... ;
begin
B
if COND='1' then
TMP := B;
else TMP := C;
end if; C
Z <= TMP + A;
end process; A
211
Validation d'horloge
Eviter de générer une horloge par un circuit combinatoire
gate_clk<= (IN1 and IN2 and CLK);

process (gate_clk)
begin
if (gate_clk’event and gate_clk=’1’) then
if (LOAD=’1’) then
OUT1 <= DATA;
end if;
end if;
end process;
212
Validation d'horloge (suite)
ENABLE <= IN1 and IN2 and LOAD;

process (CLOCK)
begin
if (CLOCK’event and CLOCK=’1’) then
if (ENABLE=’1’) then
DOUT <= DATA;
end if;
end if;
end process;
213
Occupation sur le FPGA
CLB CLB
Chaîne de
Spartan-II, Virtex retenue
Spartan-III, Virtex-II
SET
I3 CE
I2 O D Q
I1 RST
I0
LUT
I3 SET
I2 O CE
I1 D Q
I0 RST
Formation VHDL Occupation sur le FPGA Vahid MEGHDADI
214
Registre à décalage
Utilisation des bascules
4
Z-1 Z-1 Z-1 Z-1 Z-1 Z-1
Ce registre à décalage demande combien de slice ?
12 car 2 bascules par slice sont disponibles.
215
Utilisation des LUT
Multiplexeur
A SEL1 I3
B SEL2 I2 O
A I1
B I0
SEL1 SEL2
Ce multiplexeur demande combien de slice ?
Un seul slice.
216
Additionneur complet
Cout
A I3
B + sum I2 O Cout
I1
Cin
I0
I3
A
Sum=f(A,B,Cin) I2 O Sum
B I1
Cout=g(A,B,Cin) Cin I0
Un slice.
217
Additionneur complet Xilinx
LUT Cout
A
0 1
B Sum
Cin
Un seul slice pour l'additionneur complet.

218
La chaîne de retenu
Connexion rapide
SET
I3 CE
I2 O D Q
I1 RST
I0
LUT
I3 SET
I2 O CE
I1 D Q
I0 RST
219
Addition 8 bits
S8
B7
A7 S7
B6
S6
A6
B5
A5 S5
Il suffit 4 slices pour une B4
S4
A4
addition sur 8 bits
B3 S3
A3
B2 S2
A2
B1
A1 S1
B0
A0 S0
220

Cours VHDL

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours VHDL

Transféré par

Droits d'auteur :

Formats disponibles

Vahid Meghdadi

Cours Conception circuits numériques

Formation VHDL Vahid MEGHDADI

Implantation des circuits numériques

Formation VHDL Introduction Vahid MEGHDADI

•A base des microprocesseurs, Microcontrôleurs, DSP

•Vitesse limitée (mais qui

•Une quantité importante de portes logiques

Application Specific Integrated Circuit

• Coût très bas uniquement pour de gros

Formation VHDL Introduction Vahid MEGHDADI

Low development cost

Formation VHDL Introduction Vahid MEGHDADI

Conception physique (layout)

Conception structurelle TTL

Conception fonctionnelle RTL

Circuit de développement Nexys3

Formation VHDL Introduction Vahid MEGHDADI

Une carte polyvalente et reconfigurable

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

• Jeu d’instruction peut ne pas contenir l’opération voulue

Formation VHDL Introduction Vahid MEGHDADI

CLB CLB CLB CLB CLB CLB CLB

CLB CLB CLB CLB CLB CLB CLB

CLB CLB CLB CLB CLB CLB CLB

CLB= Configurable Logic

CLB CLB CLB CLB CLB CLB CLB

CLB CLB CLB CLB CLB CLB CLB

CLB CLB CLB CLB CLB CLB CLB

Formation VHDL Introduction Vahid MEGHDADI

BLE= Basic Logic Element

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

Xilinx a été fondée en 1984 pour fabriquer des circuits à logique

Formation VHDL Introduction Vahid MEGHDADI

Le nombre de broches I/O, le nombre de CLB

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Vahid MEGHDADI

•Les LUT transformables en registre à décalage

•Plus de CLB, plus de mémoire, plus de slices par CLB

•Multiplieurs câblés à partir de Virtex II

•Microprocesseur embarqué (PowerPC)

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

LUT à 6 entrées et 2 sorties: permettant de construire des

Formation VHDL Vahid MEGHDADI

Formation VHDL Vahid MEGHDADI

L’IDE (Integrated development environment)

Formation VHDL Vahid MEGHDADI

o Les blocs reconfigurables

Formation VHDL Introduction Vahid MEGHDADI

HDL o Hardware design is traditionally done by modeling

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

Formation VHDL Introduction Vahid MEGHDADI

SRAM SRAM SRAM Display

SRAM SRAM SRAM Display

SRAM SRAM SRAM SDRAM SDRAM

 Moins de composantes physiques