Telechargé par riali_abderrazzak

cours vhdl

publicité
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
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Introduction
Vahid MEGHDADI
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
•Parallélisme compliqué (mais
faisable)
•Intégration encore limitée
Mémoire
Pér
iph
éri
que
•Adapté à des opérations
séquentielles
Formation VHDL
Introduction
Vahid MEGHDADI
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
Formation VHDL
Introduction
Vahid MEGHDADI
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
Formation VHDL
Introduction
Vahid MEGHDADI
7
ASIC ou FPGA ?
ASICs
FPGAs
High performance
Low development cost
Low power
Short time to market
Low cost in
high volumes
Formation VHDL
Reconfigurability
Introduction
Vahid MEGHDADI
8
Evolution : Méthodes de CAO
Conception physique (layout)
Conception structurelle TTL
Conception logique
Conception fonctionnelle RTL
Programmation Verilog/VHDL
Synthèse comportemental
Formation VHDL
Introduction
Vahid MEGHDADI
9
Démonstrateurs
Circuit de développement Nexys3
Formation VHDL
Introduction
Vahid MEGHDADI
10
Exemple
Une carte polyvalente et reconfigurable
Connecteur
d’extension
VGA
Formation VHDL
Introduction
Vahid MEGHDADI
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
FPGA
DSP
Formation VHDL
Introduction
Vahid MEGHDADI
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
Formation VHDL
Introduction
Vahid MEGHDADI
13
Architecture des FPGA
Feild Programmable Gate Array
CLB= Configurable Logic
Block
Formation VHDL
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
CLB
Introduction
Vahid MEGHDADI
14
FPGA architecture interne
BLE= Basic Logic Element
Inputs
Programmable
IO
K
LUT
Out
D FF
Clock
Programmable
Logic (CLB)
BLE
#1
N
Outputs
I
I
Inputs
N
BLE
#N
Clock
Programmable
Routing
Formation VHDL
Introduction
Vahid MEGHDADI
15
Architecture simplifiée de CLB
Inputs
Look-Up
Table
(LUT)
Out
Out = f (in0, in1, in2, in3)
State
Clock
Enable
Formation VHDL
Introduction
Vahid MEGHDADI
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)
Formation VHDL
Introduction
Vahid MEGHDADI
17
Remarque
Spartan (depuis 1998)
Le nombre de broches I/O, le nombre de CLB
différentie les FPGA de la famille.
Formation VHDL
Introduction
Vahid MEGHDADI
18
Remarque
Spartan II
Ajout de la RAM
Formation VHDL
Introduction
Vahid MEGHDADI
19
Remarque
Formation VHDL
La famille Spartan II
Introduction
Vahid MEGHDADI
20
Remarque
Formation VHDL
Spartan 3
Vahid MEGHDADI
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)
Formation VHDL
Introduction
Vahid MEGHDADI
22
Remarque
Formation VHDL
La famille Virtex
Introduction
Vahid MEGHDADI
23
Remarque
Formation VHDL
La famille Virtex-II pro
Introduction
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
25
Remarque
Formation VHDL
Virtex 5 et les blocs DSP
Vahid MEGHDADI
26
Remarque
Formation VHDL
Série 7 (depuis 2010)
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
28
Conception circuit
o
o
EPROM
o
Les blocs reconfigurables
Structure régulière de “logic cells”, connectée par un réseau d’interconnexions
La configuration est stocké dans un SRAM, qui doit être chargé au démérrage
Formation VHDL
Introduction
Vahid MEGHDADI
29
Design flow
HDL
(VHDL /
Verilog)
Synthesize
Hardware design is traditionally done by modeling
the system in a hardware description language
o An FPGA “compiler” (synthesis tool) generates a
netlist,
o
Netlist
Map
Place
Route
which is then mapped to the FPGA technology,
o the inferred components are placed on the chip,
o and the connecting signals are routed through the
interconnection network.
o
Bitstream
Formation VHDL
Introduction
Vahid MEGHDADI
30
Synthèse HDL
HDL
(VHDL /
Verilog)
process(clk, reset)
begin
if reset = ‚1‘ then
output <= ‚0‘;
elsif rising_edge(clk) then
output <= a XOR b;
end if;
Synthesize
Netlist
end process;
Map
Place
Route
Register
a
b
⊕
D
clk
Bitstream
Q
output
clear
reset
Formation VHDL
Introduction
Vahid MEGHDADI
31
Technology Mapping
HDL
(VHDL /
Verilog)
Register
a
b
⊕
D
clk
Synthesize
Q
output
clear
reset
Netlist
Map
Place
Route
Bitstream
Formation VHDL
Introduction
Vahid MEGHDADI
32
Placement & Routage
HDL
(VHDL /
Verilog)
Synthesize
Netlist
Map
Place
Route
Bitstream
Formation VHDL
Introduction
Vahid MEGHDADI
33
Système embarqué traditionnel
Ethernet
MAC
Audio
Codec
Power Supply
CLK
CLK
Interrupt
Controller
GP I/O
Address
Decode
Unit
CPU
UART
(uP / DSP)
CLK
SRAM
Memory
Controller
SRAM
SRAM
SDRAM
Timer
CoProc.
SDRAM
custom
IF-logic
L
C
Display
Controller
Images by H.Walder
Formation VHDL
Introduction
Vahid MEGHDADI
34
Système embarqué traditionnel
Ethernet
MAC
Audio
FPGA Codec
Power Supply
CLK
CLK
Interrupt
Controller
GP I/O
Address
Decode
Unit
CPU
UART
(uP / DSP)
CLK
SRAM
Memory
Controller
SRAM
SRAM
SDRAM
Timer
CoProc.
SDRAM
custom
IF-logic
L
C
Display
Controller
Images by H.Walder
Formation VHDL
Introduction
Vahid MEGHDADI
35
System on Chip Configurable (CSoC)
Audio
Codec
EPROM
Power Supply
L
C
SRAM
SRAM
SRAM
SDRAM
SDRAM
Images by H.Walder
Formation VHDL
Introduction
Vahid MEGHDADI
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
Formation VHDL
Introduction
Vahid MEGHDADI
37
Chapitre : Introduction A VHDL
Introduction au langage
VHDL
Formation VHDL
Introduction A VHDL
Vahid MEGHDADI
38
VHDL
V
H
D
L
Formation VHDL
VHSIC
(Very High Speed Integradted Circuit)
Hardware
Description
Language
Introduction A VHDL
Vahid MEGHDADI
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
Formation VHDL
Introduction A VHDL
Vahid MEGHDADI
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
Formation VHDL
Introduction A VHDL
Vahid MEGHDADI
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 »
Formation VHDL
Introduction A VHDL
Vahid MEGHDADI
42
Niveau d’abstraction
Synthèse
comportemental
Synthèse
logique
Placement
routage
Comportemental
RTL
VHDL
Logique
Layout
Formation VHDL
Introduction A VHDL
Vahid MEGHDADI
43
Chapitre : Structure du VHDL
Il existe 5 catégories d’unité de conception
Circuit
principal
•L’entité (mot clé entity)
Décrit un système vu extérieur (boîte noire)
•L’architecture (mot clé architecture)
Décrit l’intérieur (le fonctionnement) d’une boîte noire.
•La configuration (mot clé configuration)
Package
(librairie)
Formation VHDL
•La déclaration de paquetage (mot clé package)
•Le corps de paquetage (mot clé package body)
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
Formation VHDL
Vahid MEGHDADI
45
Exemple simple: entité
L’entité déclare la vue externe
du circuit : les ports d’entréesorties 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;
F : out std_logic);
end AOI;
Formation VHDL
AOI
Vahid MEGHDADI
46
Entité décortiquée
Entity name
Port names
Port type
ENTITY nand_gate IS
PORT(
a
: IN STD_LOGIC;
b
: IN STD_LOGIC;
z
: OUT STD_LOGIC
);
END nand_gate;
Reserved words
Semicolon
No Semicolon
after last port
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.
Formation VHDL
Vahid MEGHDADI
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;
Formation VHDL
Vahid MEGHDADI
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".
Formation VHDL
Vahid MEGHDADI
50
Exemple simple: architecture bis
architecture v2 of AOIis
signal I1,I2,I3: std_logic;
begin
I1 <= A and B;
I2 <= C and D;
I3 <= I1 or I2;
F <= not I3;
end v2;
Formation VHDL
I1, I2 et I3 sont des
signaux internes.
Vahid MEGHDADI
51
Principe de concurrence
Tous les mêmes !
architecture v2 of AOI is
signal I1,I2,I3: std_logic;
begin
I1 <= A and B;
F <= not I3;
I2 <= C and D;
I3 <= I1 or I2;
end v2;
Formation VHDL
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;
architecture v4 of AOI is
signal I1,I2,I3: std_logic;
begin
F <= not I3;
I3 <= I1 or I2;
I2 <= C and D;
I1 <= A and B;
end v4;
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
56
Résultat obtenu en simulation
Formation VHDL
Vahid MEGHDADI
57
Exemple
A
Demiadditionneur
B
A
SUM
B
C
Formation VHDL
Architecture
SUM
C
A
B
SUM
C
0
0
0
0
0
1
1
0
1
0
1
0
1
1
0
1
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
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
61
Exemple : multiplexeur 2 voies
Si SEL=‘0’, Y <=X1, et si SEL=‘1’, Y<=X2
Formation VHDL
Vahid MEGHDADI
62
Déclaration de component
Déclaration du component
Formation VHDL
Vahid MEGHDADI
63
Déclaration de signaux
Formation VHDL
Vahid MEGHDADI
64
Instanciation du component
Instanciation du component
Formation VHDL
Vahid MEGHDADI
65
Instructions Concurrentes / séquentielles
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
67
Exemple
A
B
C
Formation VHDL
I
S
I <= A or B;
S <= I and C
S <= I and C
I <= A or B;
Zone concurrente
Vahid MEGHDADI
68
Instruction concurrente conditionnelle
Exemple d’instructions concurrentes:
Affectation conditionnelle: when – else (équivalent de ifthen-else dans d’autre langages)
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
71
Exemple instruction « with-select »
Codeur sept-segment
with HEX select
LED<= "1111001"
"0100100"
"0110000"
"0011001"
"0010010"
"0000010"
"1111000"
"0000000"
"0010000"
"0001000"
"0000011"
"1000110"
"0100001"
"0000110"
"0001110"
"1000000"
Formation VHDL
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
"0001",
"0010",
"0011",
"0100",
"0101",
"0110",
"0111",
"1000",
"1001",
"1010",
"1011",
"1100",
"1101",
"1110",
"1111",
others;
--1
--2
--3
--4
--5
--6
--7
--8
--9
--A
--b
--C
--d
--E
--F
--0
Zone concurrente
7
Circuit
combinatoire
4
Vahid MEGHDADI
72
Remarque
Exemple ALU
entity ADDER
port (A,B
SEL
S :
end ADDER;
is
:in std_logic_vector(7 downto 0);
: in std_logic;
out std_logic_vector(7 downto 0));
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;
Formation VHDL
Zone concurrente
Vahid MEGHDADI
73
Process
Formation VHDL
Vahid MEGHDADI
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é,
Formation VHDL
Process
Vahid MEGHDADI
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)
Formation VHDL
Process
Vahid MEGHDADI
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
Formation VHDL
Process
Vahid MEGHDADI
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';
Instructions
wait for 5 ns;
CLK_TB <= '0';
séquentielles
wait for 5 ns;
end process;
--------------------------------------reset_gen: process
begin
RST_TB <= ‘0’; wait for 5ns;
Instructions
RST_TB <= ‘1’; wait for 15ns;
séquentielles
RST_TB <= ‘0’;
wait;
end process;
--------------------------------------inst: counter
port map ( CLK => CLK_TB, RST => RST_TB, Q => DATA_OUT );
Formation VHDL
Instructions
concurrentes
Vahid MEGHDADI
79
Instructions conditionnelle
if condition then
sequential statements
[elsif condition then
sequential statements ]
[elsif condition then
sequential statements ]
[else
sequential statements ]
end if;
Formation VHDL
Process
Vahid MEGHDADI
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
=>
when VAL2|VAL3|VAL4 =>
when VAL5 to VAL7 =>
when others
=>
end case;
suite d’instructions séquentielles
suite d’instr séquentielles
suite d’instr séquentielles
suite d’instr séquentielles
•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.
Formation VHDL
Process
Vahid MEGHDADI
81
Remarque
Exemple
Multiplexeur 4 voies
S1
S0
A
B
C
D
Formation VHDL
M
U
X
4
Process
Z
Vahid MEGHDADI
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;
Formation VHDL
Process
Vahid MEGHDADI
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;
Formation VHDL
Process
Vahid MEGHDADI
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’;
B <= A;
end process;
Formation VHDL
--ici le signal A ne recevra pas ‘0’
--ici donc, B recevra l’ancienne valeur de A mais
--au moment où le process sera suspendu
--c’est ici que A reçoit ‘0’ et B reçoit
--l’ancienne valeur de A
Vahid MEGHDADI
85
Remarque
Attention !
Le process ci-dessous ne
produira pas le signal cicontre
SIG
Process (x)
begin
SIG <= '0';
SIG <= '1';
SIG <= '0';
end process;
Formation VHDL
SIG
Process
Vahid MEGHDADI
86
Circuits séquentiels
Trois types de circuit
• Combinatoire
• Séquentiel
• Synchrone
Formation VHDL
Vahid MEGHDADI
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;
Formation VHDL
architecture A of L is
begin
process (D,EN)
begin
if EN='1' then
Q <= D;
end if;
end process;
end A;
Circuits séquentiels
Ce qu’on préfère !
architecture A of L is
begin
process
begin
wait on D,EN;
if EN='1' then Q <= D;
end if;
end process;
end A;
Vahid MEGHDADI
89
Registre (latch synchrone)
Un circuit synchrone sur le front d’un signal (CLK)
process (CLK)
begin
if CLK'event and CLK='1' then
Q <= D;
end if
end process;
process (CLK)
begin
if rising_edge(CLK) then
Q <= D;
end if
end process;
Formation VHDL
D
Q
CLK
Bascule D
8
D
Q
8
CLK
Registre de taille 8 dépendant
du type de Q et D
Circuits séquentiels
Vahid MEGHDADI
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
begin -- set asynchrone
process (SET,CLK)
begin
if SET = '1' then Q <= '1';
elsif CLK'event and CLK='1'
then Q <= D;
end if;
end process;
end A;
Formation VHDL
architecture A of R is
begin -- set synchrone
process (CLK)
begin
if CLK'event and CLK='1' then
if SET = '1' then Q <= '1';
else Q <= D;
end if;
end if;
end process;
end A;
Circuits séquentiels
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
92
Exemple
Créer le signal “trig” à partir du signal d’horloge CLK
CLK
trig
0 1 2 3 0 1 2 3 0 1 2
/4
-- signal cmp: integer range 0 to ?;
process(CLK)
begin
if CLK’event and CLK=‘1’ then
trig <= ‘0’; cmp <= cmp + 1;
if cmp = ? Then
cmp <= 0; trig <= ‘1’;
end if;
end if;
end process;
Formation VHDL
Vahid MEGHDADI
93
Objets en VHDL
Formation VHDL
Vahid MEGHDADI
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é.
Formation VHDL
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
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 "<=" :
•
Formation VHDL
current_bit := not current_bit;
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
100
Types en VHDL
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
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;
Formation VHDL
Vahid MEGHDADI
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);
Formation VHDL
Types en VHDL
Vahid MEGHDADI
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
Formation VHDL
Types en VHDL
Vahid MEGHDADI
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’;
Formation VHDL
Types en VHDL
Vahid MEGHDADI
107
Le type std_logic
‘L’
Le type std_logic :
‘U’
non initialisé
‘X’
non connu
‘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
Formation VHDL
‘H’
VDD
‘0’
‘1’
‘0’
Types en VHDL
Vahid MEGHDADI
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’.
Formation VHDL
Vahid MEGHDADI
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);
Formation VHDL
Types en VHDL
Vahid MEGHDADI
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);
Formation VHDL
Types en VHDL
Vahid MEGHDADI
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;
Formation VHDL
Types en VHDL
Vahid MEGHDADI
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
Formation VHDL
Types en VHDL
Vahid MEGHDADI
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);
Formation VHDL
Types en VHDL
Vahid MEGHDADI
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;
Formation VHDL
Vahid MEGHDADI
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";
Formation VHDL
Types en VHDL
Vahid MEGHDADI
116
Opérateurs en VHDL
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Vahid MEGHDADI
120
Circuits combinatoires : équation logique
Architecture COMB1 of NONET is
begin
--équation logique
S <= A nand B;
end COMB1;
Architecture COMB2 of NONET is
begin
--Traduction de la table
--de vérité dans un process
S <= '0' when A='1' and B='1'
else '1';
end COMB2;
Formation VHDL
Architecture COMB3 of NONET is
begin
--Traduction de la table
--de vérité dans un process
process(A,B)
begin
if A='1' and B='1' then
S <= '0';
else
S <= '1';
end if;
end process;
end COMB3;
Vahid MEGHDADI
121
Exemple
Transcription d’une table de vérité
A(2)
0
0
0
0
1
1
1
1
Formation VHDL
A(1)
0
0
1
1
0
0
1
1
A(0)
0
1
0
1
0
1
0
1
S(2)
0
0
0
0
1
1
1
1
S(1)
0
0
1
1
1
1
0
0
S(0)
0
1
1
0
0
1
1
0
Vahid MEGHDADI
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;
Formation VHDL
Vahid MEGHDADI
123
Affectation sélective séquentielle
Dans une zone séquentielle (process)
Architecture AVEC_CASE of CIRCUIT
signal A,S : std_logic_vector (2 downto 0);
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
signal A,S : std_logic_vector (2 downto 0);
begin
with A select
S <= "000" when "000" ,
"001" when "001" ,
"011" when "010" ,
"110" when "100" ,
…
"000" when others;
end AVEC_WITH;
Formation VHDL
Circuits combinatoires
Vahid MEGHDADI
125
Remarque
Affectation non conditionnelle
Dans une zone concurrente (architecture)
Architecture DIRECT of CIRCUIT
signal A,S : std_logic_vector (2 downto 0);
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));
…
Formation VHDL
Circuits combinatoires
Vahid MEGHDADI
126
Remarque
Affectation conditionnelle concurrente
Dans une zone concurrente (architecture)
Architecture AVEC_WHEN of CIRCUIT
signal A,S : std_logic_vector (2 downto 0);
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;
Formation VHDL
Circuits combinatoires
Vahid MEGHDADI
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;
Formation VHDL
Vahid MEGHDADI
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;
Formation VHDL
Vahid MEGHDADI
129
Remarque
Exemple : Multiplieur
Le but est de réaliser un multiplieur 4 bits fois 4 bits
A
1001
B
*1101
--------0000 1001
+0000 0000
+0010 0100
+0100 1000
---------0111 0101
A
0
0
B(0)
4
0
4
4
B(1)
0
4
B(2)
5
0
4
res(0)
(4 downto 1)
res(1)
B(3)
5
(4 downto 1)
res(2)
5
(4 downto 1)
res(7 downto 3)
Formation VHDL
Vahid MEGHDADI
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;
Formation VHDL
Vahid MEGHDADI
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
front de l’horloge
E1E2="0-"
s1
s2
•L’horloge est implicite
E1E2= "1-"
Formation VHDL
Vahid MEGHDADI
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)
Formation VHDL
Machine à états finis
Vahid MEGHDADI
134
Implantation par un seul process
État courant
type T_ETAT is (E1, E2, E3);
signal etat : T_ETAT;
D
Q
Logique
...
combinatoire
ENTREE
Process(CLK)
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
• Très simple à écrire
if <cond> then ETAT <= E1;
elsif <cond> then ETAT <= E2;
• Ne convient pas aux
end if;
machines complexes
end case;
end if;
end process;
Formation VHDL
Machine à états finis
Vahid MEGHDADI
135
Implantation par des process séparés (plus robuste)
E1
Moore Mealy
Fonction
combinatoire
E2
S1
S2
F
Fonction
combinatoire
G
ETAT_FUTUR
Registre
d'états
ETAT_COUR
H
RAZ
Formation VHDL
Machine à états finis
Vahid MEGHDADI
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)
Formation VHDL
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;
Machine à états finis
Vahid MEGHDADI
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 =>
Attention aux
-- suivant la valeur de E1 et E2 on
conditions
-- affecte à ETAT_FUTUR une valeur
nécessaires pour
when ETAT3 =>
qu’un process soit
-- suivant la valeur de E1 et E2 on
combinatoire !
-- affecte à ETAT_FUTUR une valeur
end case;
end process;
Formation VHDL
Machine à états finis
Vahid MEGHDADI
138
Programmation de la partie combinatoire F
F : 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 aux sorties les valeurs correspondantes
when ETAT2 =>
-- suivant la valeur de E1 et E2 on
-- affecte aux sorties les valeurs correspondantes
when ETAT3 =>
-- suivant la valeur de E1 et E2 on
-- affecte aux sorties les valeurs correspondantes
end case;
end process;
Peut être intégré dans G !
Formation VHDL
Machine à états finis
Vahid MEGHDADI
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,
Formation VHDL
Machine à états finis
Vahid MEGHDADI
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.
Formation VHDL
Machine à états finis
Vahid MEGHDADI
141
Remarque
Exemple de la partie combinatoire F
F : process (E1,E2,ETAT_COUR) -- Tous les signaux
-- d’entrée sont dans la liste de sensibilité
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;
Formation VHDL
Machine à états finis
Vahid MEGHDADI
142
Remarque
CLK
Exemple écran VGA
HS
fclk=25MHz
Formation VHDL
Vahid MEGHDADI
143
Remarque
Ecran VGA: Conception RTL
HS <= '1' when etat_cour = PW else '0';
Formation VHDL
Vahid MEGHDADI
144
Remarque
Ecran VGA Programme VHDL
FSM: process(etat_cour, count)
begin
case etat_cour is
when PW =>
if count = 96 then
etat_futur <= BP;
else
etat_futur <= PW;
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;
Formation VHDL
when others =>
if count = 0 then
etat_futur <= PW;
else
etat_futur <= FP;
end if;
end case;
end process;
type t_etat is (PW, BP, DISP, FP);
signal etat_cour, etat_futur : t_etat:=PW;
Vahid MEGHDADI
145
Techniques de programmation
Formation VHDL
Vahid MEGHDADI
146
Utilisation de « Clock Enable »
E
• Tous les évènements sont
synchronisés sur le front (montant) de
l’horloge.
• Pour exécuter une partie du code à
des fréquences moins rapides que
l’horloge, on utilise les signaux
« clock enable ».
• Ce sont des impulsions dont la durée
de ‘1’ est exactement une seule
période d’horloge.
• La répétition de ces impulsions donne
la fréquence d’exécution du code.
Formation VHDL
S
EN
CLK
CLK
EN1
process(CLK)
begin
if CLK'event and CLK='1' then
if EN = '1' then
--suite d’instructions
end if;
end if;
end process;
Vahid MEGHDADI
147
Periodic Clock Enable Generation
CLK
T=10 ns
EN1
T=80 ns
EN2
T=210 ns
EN1
CLK
Timing
generator
EN2
process (CLK)
begin
if rising_edge(CLK) then
EN1 <= ‘0’; EN2<=‘0’;
cmp1 <= cmp1 + 1;cmp2 <= cmp2 + 1;
if cmp1 = 7 then EN1 <= ‘1’;
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.
CLK
EN
A process
repeated every
80 ns
process (CLK)
begin
if rising_edge(CLK) then
if EN = ‘1’ then
--- 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
Event that should make
the counter to
increment.
CLK
CLK
Timing
generator
en
2-digit
counter
8
process (CLK)
begin
if rising_edge(CLK) then
en <= '0';
cmp <= cmp + 1;
if cmp = 999_999 then
en <= ‘1’;
cmp <= 0;
end if;
end if;
end process;
en
process (CLK)
Begin
if rising_edge(CLK) then
if en = '1' then
counter <= counter + 1;
end if;
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
red
If timer=27,
Next_state = red
yellow
Red 14 sec
If timer=13,
next-state = green
green
If
timer=25
Next_state = yelllow
13 14 15
Green 12 sec
process (CLK)
begin
if rising_edge(CLK) then
if en = '1' then
timer <= timer + 1;
if timer = 27 then
timer <= 0;
end if;
end if;
end if;
end process;
25 26 27
Yellow
2 sec
Example : Traffic light (continue …)
State machine creation
-- type definition
type traffic_light_T is (red, green, yellow);
Signal state, next_state : traffic_light_T := red;
-- state machine (combinatory)
process(state, timer)
begin
case state is
when red =>
if timer = 13 then next_state = green;
else next_state = red;
end if;
when green =>
if timer = 25 then next_state = yellow;
else next_state = yellow;
end if;
when others =>
if timer = 27 then next_state = red;
else next_state = yellow;
end if;
end case;
end process;
process (CLK)
begin
if rising_edge(CLK) then
if en = '1' then
state <= next_state;
end if;
end if;
end process;
next_state
EN
State Register
state
CLK
state
Timer
Comb
next_state
Example : Traffic light, timing diagram
CLK
en
timer
12
13
14
15
state
red
red
green
green
process (CLK)
begin
if rising_edge(CLK) then
if en = '1' then
state <= next_state;
end if;
end if;
end process;
R
next_state
red
green
green
process(state, timer)
begin
case state is
when red =>
if timer = 13 then next_state = green;
else next_state = red;
end if;
. . .
green
CLK
Traffic_light
The entity
Y
G
R <= '1' when state = red
else '0';
Y <= '1' when state = yellow else '0';
G <= '1' when state = green else '0';
Exemples
process(CLK)
begin
if CLK’event and CLK=‘1’ then
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));
Formation VHDL
Vahid MEGHDADI
154
Exemple 4, affichage multiplexé
Formation VHDL
Vahid MEGHDADI
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
CLK_EN_Gene : Process(CLK)
Begin
if CLK’event and CLK=‘1’ then
CLK_EN <= ‘0’;
cmp <= cmp + 1;
if cmp = 1999 then
CLK_EN <= ‘1’;
cmp <= 0;
end if;
end if;
End process;
Programme VHDL
CLK_EN
CLK
CLK
CLK_EN
CLK_EN_Gene
cmp
Formation VHDL
Vahid MEGHDADI
156
Machine à états
type T_ETAT is (SEG1, SEG2, SEG3, SEG4);
signal etat : T_ETAT;
process(CLK)
begin
if CLK’event and CLK=‘1’ then
if CLK_EN = ‘1’ then
case ETAT is
when SEG1 => etat <= SEG2;
when SEG2 => etat <= SEG3;
when SEG3 => etat <= SEG4;
when SEG4 => etat <= SEG1;
when others => etat <= SEG1;
end case;
end if;
end if;
end process;
Formation VHDL
-- une autre alternative
signal etat : integer range 0 to 3;
process(CLK)
begin
if CLK’event and CLK=‘1’ then
etat <= etat + 1;
end if;
end process;
Vahid MEGHDADI
157
Circuit complet
with etat select
An <= "0111" when
"1011" when
"1101" when
"1110" when
SEG1,
SEG2,
SEG3,
others;
with etat select
HEX <= "0001" when
"1001" when
"0100" when
"0101" when
SEG1,
SEG2,
SEG3,
others;
Formation VHDL
with HEX select
SEG<= "1111001"
"0100100"
"0110000"
"0011001"
"0010010"
"0000010"
"1111000"
"0000000"
"0010000"
"0001000"
"0000011"
"1000110"
"0100001"
"0000110"
"0001110"
"1000000"
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
when
"0001",
"0010",
"0011",
"0100",
"0101",
"0110",
"0111",
"1000",
"1001",
"1010",
"1011",
"1100",
"1101",
"1110",
"1111",
others;
--1
--2
--3
--4
--5
--6
--7
--8
--9
--A
--b
--C
--d
--E
--F
--0
Vahid MEGHDADI
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.
Formation VHDL
Vahid MEGHDADI
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)
Formation VHDL
Vahid MEGHDADI
160
Remarque
Exemple 7- AD5541A contraintes de Timing
Fclk=25MHz
On fixe à 1/25MHz=40ns
Formation VHDL
Vahid MEGHDADI
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).
Formation VHDL
Vahid MEGHDADI
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’)
Formation VHDL
Vahid MEGHDADI
163
Remarque
Exemple 7- Programmation un seul process
signal cmp : integer range 0 to 15;
signal reg : std_logic_vector (15 downto 0);
type T_etat is (repos, envoi, tempo, fin);
signal etat : T_etat := repos;
process(CLK)
begin
if CLK'event and CLK='0' then
case etat is
when repos =>
CS <= '1';
LDAC <= '1';
cmp <= 15;
DIN <= 'Z';
if STRB = '1' then
reg <= DATA;
etat <= envoi;
end if;
Formation VHDL
when envoi =>
CS <= '0';
DIN <= reg(cmp);
cmp <= cmp - 1;
if cmp = 0 then
etat <= tempo;
end if;
when tempo =>
DIN <= 'Z';
CS <= '1';
etat <= fin;
when others => -- etat = fin
LDAC <= ‘0';
cmp <= 15;
etat <= repos;
end case;
end if;
end process;
Vahid MEGHDADI
164
Remarque
Formation VHDL
Exemple 7- Conception robuste
Vahid MEGHDADI
165
Remarque
Exemple 7- Programme
entity AD5541A is
Port ( CLK : in STD_LOGIC;
DATA : in STD_LOGIC_VECTOR (15 downto 0);
STRB : in STD_LOGIC;
CS : out STD_LOGIC;
DIN : out STD_LOGIC;
LDAC : out STD_LOGIC;
SCLK : out STD_LOGIC);
end AD5541A;
architecture Behavioral of AD5541A is
type t_etat is (repos, e_cs, envoie, tempo, e_ldac);
signal etat_cour, etat_futur : t_etat:= repos;
signal count : integer range 0 to 31:=0;
signal raz : std_logic;
signal reg : std_logic_vector(15 downto 0);
Begin
SCLK <= not CLK;
DIN <= reg(16-count) when etat_cour = envoie else 'Z';
CS <= '1' when etat_cour = e_CS else '0';
LDAC <= '0' when etat_cour=e_ldac else '1';
Formation VHDL
process(CLK)
begin
if CLK'event and CLK='1' then
if STRB = '1' then
reg <= DATA;
end if;
end if;
end process;
process(CLK)
begin
if CLK'event and CLK='1' then
etat_cour <= etat_futur;
end if;
end process;
process(CLK)
begin
if CLK'event and CLK='1' then
if raz = '1' then
count <= 0;
else
count <= count + 1;
end if;
end if;
end process;
Vahid MEGHDADI
166
Remarque
Exemple 7- Programme
process(etat_cour, count, STRB)
begin
etat_futur <= etat_cour;
raz <= '0';
case etat_cour is
when repos =>
raz <= '1';
if STRB = '1' then
etat_futur <= e_cs;
end if;
when e_cs =>
if count = 0 then
etat_futur <= envoie;
end if;
when envoie =>
if count = 16 then
etat_futur <= tempo;
end if;
Formation VHDL
when tempo =>
if count = 17 then
etat_futur <= e_ldac;
end if;
when others => -- e_ldac
if count = 18 then
etat_futur <= repos;
end if;
end case;
end process;
end Behavioral;
Vahid MEGHDADI
167
Remarque
Formation VHDL
Exemple 7- Résultat de simulation
Vahid MEGHDADI
168
Technique de
programmation
Formation VHDL
Vahid MEGHDADI
169
Attention !
Les instructions suivantes sont
interdites dans une zone concurrente
Architecture x of y is
Begin
A <= not A;
CMPT <= CMPT + 1;
REG <= REG (0) & REG(7 downto 1);
…...
end x;
Formation VHDL
+1
Vahid MEGHDADI
170
Correction
D
On utilise un process
synchronisé sur un front
CLK
process (CLK)
begin
if rising_edge(CLK) then
A <= not A;
-CMPT <= CMPT + 1;
-etc;
end if;
end process;
Formation VHDL
Q
D
Q
+1
CLK
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;
Formation VHDL
Vahid MEGHDADI
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
Formation VHDL
Les sous-programmes
Vahid MEGHDADI
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
Formation VHDL
Les sous-programmes
Vahid MEGHDADI
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;
Formation VHDL
Les sous-programmes
Vahid MEGHDADI
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"
Formation VHDL
Les sous-programmes
Vahid MEGHDADI
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;
Formation VHDL
Les sous-programmes
Vahid MEGHDADI
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);
Formation VHDL
Les sous-programmes
Vahid MEGHDADI
179
Exemple
-------------
Formation VHDL
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
Exemples
Vahid MEGHDADI
180
Programmation concurrente
with HEX select
LED<= "1111001" when "0001",
"0100100" when "0010",
"0110000" when "0011",
"0011001" when "0100",
"0010010" when "0101",
"0000010" when "0110",
"1111000" when "0111",
"0000000" when "1000",
"0010000" when "1001",
"0001000" when "1010",
"0000011" when "1011",
"1000110" when "1100",
"0100001" when "1101",
"0000110" when "1110",
"0001110" when "1111",
"1000000" when others;
Formation VHDL
Exemples
--1
--2
--3
--4
--5
--6
--7
--8
--9
--A
--b
--C
--d
--E
--F
--0
Vahid MEGHDADI
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;
Formation VHDL
Exemples
Vahid MEGHDADI
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
Exemple:
subtype OCTET is std_logic_vector(7 downto 0);
subtype MOT is std_logic_vector(15 downto 0);
constant PAQUET_SIZE : integer := 11;
function INT_TO_7SEG (constant CHIFFRE :
in std_logic_vector(3 downto 0)) return OCTET;
end pak_test;
Formation VHDL
Paquetage
Vahid MEGHDADI
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;
Formation VHDL
Paquetage
Vahid MEGHDADI
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>;
Formation VHDL
Paquetage
Vahid MEGHDADI
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;
Formation VHDL
Paquetage
Vahid MEGHDADI
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>
Formation VHDL
Paquetage
Vahid MEGHDADI
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)
Formation VHDL
Configuration
Vahid MEGHDADI
190
Exemple de Configuration
Entity SIM is end;
Entity ADD is
port (A,B : in integer;
S : out integer);
end ADD;
architecture FONCTION of ADD is
begin
S <= A+B;
end FONCTION;
Formation VHDL
architecture ESSAI1 of SIM is
component ADD
port (A,B : in integer;
S : out integer);
end component;
signal X,Y,SUM : integer;
begin
INST1 : ADD port map (X,Y,SUM);
X <= 12, 55 after 100 ns;
Y <= 0, 100 after 200 ns;
end ESSAI1;
configuration CONF of SIM is
for ESSAI1
for INST1 : ADD
use entity work.ADD(FONCTION)
end for;
end for;
end CONF;
Configuration
Vahid MEGHDADI
191
Exemple de Configuration "à la volée"
Entity SIM is end;
Entity ADD is
port (A,B : in integer;
S : out integer);
end ADD;
architecture FONCTION of ADD is
begin
S <= A+B;
end FONCTION;
Formation VHDL
architecture ESSAI1 of SIM is
component ADD
port (A,B : in integer;
S : out integer);
end component;
for all : ADD
use entity work.ADD(FONCTION);
-- ou
-- for INST2 : ADD
-use entity work.ADD(FONCTION);
signal X,Y,SUM : integer;
begin
INST2 : ADD port map (X,Y,SUM);
X <= 12, 55 after 100 ns;
Y <= 0, 100 after 200 ns;
end ESSAI1;
Configuration
Vahid MEGHDADI
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
type t_etat is (S1, S2, S3, S4, S5);
signal etat : t_etat;
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
type t_etat is (S1, S2, S3, S4, S5);
-- 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 …
signal etat : t_etat;
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
Formation VHDL
(param1 : type de param1 := valeur par défaut;
param2 : type de param2 := valeur par défaut;
...);
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;
Formation VHDL
Généricité
Vahid MEGHDADI
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;
Formation VHDL
Généricité
Vahid MEGHDADI
200
If Generate
If-generate permet de
synthétiser un circuit
suivant une condition
Exemple :
entity generate_test is
generic ( CLK_DIV : boolean :=TRUE);
Port ( CLK : in std_logic;
sortie : out std_logic);
end generate_test;
architecture A of generate_test is
signal clk_r : std_logic:= '1';
begin
U1: if CLK_DIV generate
process(CLK)
begin
if CLK'event and CLK='1' then
clk_r <= not clk_r;
end if;
end process;
end generate;
U2: if not CLK_DIV generate clk_r <= clk;
end generate;
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
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
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";
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
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
A4
ADD
A1
A2
A3
ADD
Un circuit plus rapide
A4
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
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
complexe
•Utiliser "if" pour favoriser les chemins
lents
entity if_ex is
port (SEL: in std_logic_vector(1 downto 0);
A,B,C,D: in std_logic;
MUX_OUT: out std_logic);
end if_ex;
Formation VHDL
architecture A of if_ex is
begin
IF_PRO: process (SEL,A,B,C,D)
begin
if (SEL=”00”) then MUX_OUT <= A;
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';
end if;
end process; --END IF_PRO
end BEHAV;
Conseils de synthèse
Vahid MEGHDADI
206
Circuit résultant
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
207
Utilisant "case"
entity case_ex is
port (SEL: in std_logic_vector
(1 downto 0);
A,B,C,D: in std_logic;
MUX_OUT: out std_logic);
end case_ex;
Formation VHDL
architecture BEHAV of case_ex is
begin
CASE_: process (SEL,A,B,C,D)
begin
case SEL is
when “00” => MUX_OUT <= A;
when “01” => MUX_OUT <= B;
when “10” => MUX_OUT <= C;
when “11” => MUX_OUT <= D;
when others=> MUX_OUT <= '0';
end case;
end process;
end BEHAV;
Conseils de synthèse
Vahid MEGHDADI
208
Circuit résultant
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
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;
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
210
Partage des ressources
Process (A,B,C,COND)
Variable Z1,Z1 : ….. ;
begin
Z1 := A+B;
Z2 := A+C;
if COND='1' then
Z <= Z1;
else Z <= Z2;
end if;
end process;
Process (A,B,C,COND)
variable TMP : ..... ;
begin
if COND='1' then
TMP := B;
else TMP := C;
end if;
Z <= TMP + A;
end process;
Formation VHDL
COND
B
A
C
COND
B
C
A
Conseils de synthèse
Vahid MEGHDADI
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;
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
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;
Formation VHDL
Conseils de synthèse
Vahid MEGHDADI
213
Occupation sur le FPGA
CLB
CLB
Chaîne de
retenue
Spartan-II, Virtex
I3
I2
I1
I0
O
Spartan-III, Virtex-II
SET
CE
D
Q
RST
LUT
I3
I2
I1
I0
Formation VHDL
O
SET
CE
D
Q
RST
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.
Formation VHDL
Occupation sur le FPGA
Vahid MEGHDADI
215
Utilisation des LUT
Multiplexeur
A
B
SEL1
SEL2
A
B
I3
I2
I1
I0
O
SEL1 SEL2
Ce multiplexeur demande combien de slice ?
Un seul slice.
Formation VHDL
Occupation sur le FPGA
Vahid MEGHDADI
216
Additionneur complet
A
B
Cin
Cout
+
I3
I2
I1
I0
sum
Sum=f(A,B,Cin)
A
Cout=g(A,B,Cin)
Cin
B
I3
I2
I1
I0
O
O
Cout
Sum
Un slice.
Formation VHDL
Occupation sur le FPGA
Vahid MEGHDADI
217
Additionneur complet Xilinx
LUT
A
Cout
0
1
B
Sum
Cin
Un seul slice pour l'additionneur complet.
Formation VHDL
Occupation sur le FPGA
Vahid MEGHDADI
218
La chaîne de retenu
Connexion rapide
I3
I2
I1
I0
O
SET
CE
D
Q
RST
LUT
I3
I2
I1
I0
Formation VHDL
O
Occupation sur le FPGA
SET
CE
D
Q
RST
Vahid MEGHDADI
219
Addition 8 bits
S8
B7
A7
B6
A6
Il suffit 4 slices pour une
addition sur 8 bits
B5
A5
B4
A4
B3
A3
B2
A2
B1
A1
B0
A0
Formation VHDL
Occupation sur le FPGA
S7
S6
S5
S4
S3
S2
S1
S0
Vahid MEGHDADI
220
Téléchargement
Explore flashcards