Vous êtes sur la page 1sur 45

INTRODUCTION VHDL

Structures de bases
Synthèse d’opérateurs standards

ENSET Mohammedia
Université Hassan II de Casablanca
Rappels

Electronique reprogrammable
 Apparition des premiers circuits vers les années 70: premiers PLD-> PAL, GAL
 Evolution vers composants plus complexes: CPLD, FPGA
 Différentes technologies pour la programmation des connexions
 Permanents , Volatiles statiques, Volatiles
 Capacité de programmation In-Situ
• composants dits ISP via interface JTAG
 Contexte de compétitivité mondiale
 Importance du Time-To-Market

2
xPLD

Simple Programme Logic Device


 Composants simples
 réseau ET/OU programmable ou fixe
 PAL (OTP en général), GAL reprogrammable

Différentes familles en
fonction des ressources
rajoutés par le constructeurs

3
FPGA

Field Programmable Grid Array


 Granularité plus fine que les CPLD ( macrocellules - complexes mais + nombreuses)
 Intégration matérielle de composants supplémentaires
 RAM: appelé LUT (Look-Up Table)
 Mutiplexeurs divers
 PLL
 Multiplieurs câblés (FPGA haut de gamme => concurrence avec les DSP)
 Réseau de routage réparti ( non centralisé contrairement Répartition
aux CPLD) des applications
Source Altera

Exemple de référence
Famille Cyclone (FPGA Low Cost
d’ALTERA)
Concurrent: Spartan3 (chez Xilinx)

4
Exemple de réalisation avec FPGA

Specifications
La carte DE2 (utilisé en TP) FPGA
• Cyclone II EP2C35F672C6 FPGA and
EPCS16 serial configuration device
I/O Devices
• Built-in USB Blaster for FPGA configuration
• 10/100 Ethernet, RS-232, Infrared port
• Video Out (VGA 10-bit DAC)
• Video In (NTSC/PAL/Multi-format)
• USB 2.0 (type A and type B)
• PS/2 mouse or keyboard port
• Line-in, Line-out, microphone-in
(24-bit audio CODEC)
• Expansion headers (76 signal pins)
Memory
• 8-MB SDRAM, 512-KB SRAM, 4-MB Flash
• SD memory card slot
Switches, LEDs, Displays, and Clocks
• 18 toggle switches
• 4 debounced pushbutton switches
• 18 red LEDs, 9 green LEDs
• Eight 7-segment displays
• 16 x 2 LCD display
• 27-MHz and 50-MHz oscillators, external SMA clock input5
VHDL introduction

Programmation ou description?
 Les objectifs du langage VHDL
 Conception de circuits intégrés reconfigurable ou non (ASIC, FPGA…) : SYNTHESE
 Mise au point de modèle de simulations numériques (circuits virtuels) : MODELISATION
 Le langage est capable de DECRIRE
 des comportements CONCURRENTS ( // )
Les deux portes
 Des comportements séquentiels
travaillent en //
Synthèse ou modélisation

Nous nous
focaliserons
dans ce cours à
la synthèse
uniquement

Notre cible en
TP: FPGA
Cyclone 2 sur
la carte DE2 6
VHDL introduction

L’abréviation VHDL signifie VHSIC Hardware Description Language avec


VHSIC : Very High Speed Integrated Circuit.
Ce langage a été écrit dans les années 70 pour réaliser la simulation de
circuits électroniques.
On l’a ensuite étendu en lui rajoutant des extensions pour permettre la
conception (synthèse) de circuits logiques programmables (P.L.D.
Programmable Logic Device).
Auparavant pour décrire le fonctionnement d’un circuit électronique
programmable les techniciens et les ingénieurs utilisaient des langages de bas
niveau (ABEL, PALASM, ORCAD/PLD,..) ou plus simplement un outil de
saisie de schémas.

7
VHDL: concepts de base

Structure générale
Votre fichier texte de
description: xxx.vhd

Mode transfert des


signaux de votre
entity

8
Flot de conception

Un outils de développement: Quartus II d’Altera

9
VHDL: concepts de base

Méthodologie de conception
 Guide pratique du débutant
 Décomposition du cahier des charges en fonctions élémentaires
 Classification de la fonction
• COMBINATOIRE: instructions dites concurrentes
• SEQUENTIELLE: utilisation d’un PROCESS

Logique combinatoire Logique séquentielle

La sortie ne dépend pas de l’état passé La sortie dépend de son état passé

Un vecteur d’entrée = un vecteur de sortie unique Système nécessitant une horloge (systèmes dits
synchrones)

Des exemples:
Des exemples:
•Multiplexeurs
•Compteurs
•Additionneurs
•Registres à décalage
•Décodeur 7 segements
•Machine d’état (automate)
•Encodeurs de priorité 10
VHDL: concepts de base

Les questions à se poser


 On identifie les fonctions et on les dessine sur papier
 On repère et nomme les entrées de chaque blocs ( on évite d’utiliser les mêmes
noms)
 On répertorie les signaux INTERNES (mot clé SIGNAL)
 Le bloc est-il combinatoire ou séquentiel?
 Si séquentiel alors description avec le mot clé PROCESS + instructions autorisées
 Le bloc est-il utilisé plusieurs fois
 Si oui il vaut mieux créer un composant (entity+ architecture)
 Sinon le bloc est synthétiser par les lignes de codes directement
Exemple: faire une porte ET 4entrée avec des ET 2 entrées
Il faut un ET4 est un
SIGNAL composant
Voir page 12 (entity+architecture)
pour plus de
détails
On créera 1 composant
ET2 (entity+architecture)
Utilisé 3 fois pour décrire
ET4
11
VHDL: concepts de base

Un autre exemple: Horloge BCD 2 digits


 Blocs décodeurs 7 segments - combinatoire
 Blocs compteurs – séquentiel
 Les Blocs compteurs sont cascadé pour la propagation de la retenue
 Après 9 j’ai 0 avec un de retenue! Affichage 10

Ce fil ne sort pas du composant de plus


haut niveau: on le déclarera
SIGNAL FILS: bit_vector(3 downto 0);

Sorties pilotant
les Leds de
Séquentiel donc process l’afficheur 1
COMPT: PROCESS(CLK)
Begin
….
END PROCESS;
12
VHDL: concepts de base

Les librairies
 Facilite la tâche du concepteur
 Rajout de fonctionnalités supplémentaires

La librairie IEEE
 A mettre au début de votre description
 Pour rajouter les types étendues std_logic et std_logic_vector
 use IEEE.STD_LOGIC_1164.all;
 DORENAVANT nous remplacerons SYSTEMATIQUEMENT
 BIT par STD_LOGIC
 BIT_VECTOR par STD_LOGIC_VECTOR
 Pour utiliser des fonctions arithmétiques sur ces STD_LOGIC_VECTOR
 USE IEEE.NUMERIC_STD.ALL;
 Et aussi USE IEEE.std_logic_arith.all;
• Q<=Q+1; -- Q étant par exemple un std_logic_vector et 1 est un entier!!
Exemples
• A<B -- A et B des std_logic_vector
Applicatifs • oData<=CONV_STD_LOGIC_VECTOR(TEMP,8); avec TEMP integer range 0 to 255;

13
VHDL: concepts de base

Complément sur les opérations arithmétiques


 Le rajout de use IEEE.numeric_std.all; permet
 De travailler avec des valeurs signées et non signées IEEE.std_logic_unsigned.all et
• signal A,B: signed(3 downto 0); IEEE.std_logic_arith.all sont d‟anciennes
• signal tempo: unsigned(3 downto 0); bibliothèques

 De convertir un std_logic_vector en signed ou unsigned


• A<= signed(SW(3 downto 0)); Ne pas mettre en même temps:
• B<=unsigned(RES);
IEEE.numeric_std.all;
 De convertir des signed ou unsigned en std_logic_vector
• LEDG(3 downto 0)<=std_logic_vector(tempo); IEEE.std_logic_arith.all;

 De redimensionner des vecteurs


• Permet d’étendre le bit de signe correctement! Préfèrez l‟emploi de IEEE.numeric_std.all;
• signal A,B: signed(LARG downto 0);
A<= resize(signed(SW(LARG downto 1)),LARG+1);
Alternative à resize
 De travailler avec les opérateurs arithmétiques standart A<=resize(signed(SW(LARG downto 1)),LARG+1);

• >, >=, =<,<, + ,- etc….


Recopie du bit bit de poids forts
A<= A(3)&A
 Le rajout de use IEEE.std_logic_unsigned.all; permet
 De travailler avec les opérateurs arithmétiques standart
 de mélanger des entiers avec des std_logic_vector: A<= A +1;

14
VHDL: concepts de base

Littéraux
 Caractères: ’0’, ’x’,’a’,’%’
 Chaînes: ”11110101”, 1-1”, , ”xx”,”bonjour”,”$@&” Ne pas confondre 1 bit

 Chaînes de bits: B”0010_1101”, X ”2D”, O ”055” exemple ‘0’ ou ‘1’


 Décimaux:27, -5, 4e3, 76_562, 4.25 Avec un vecteur de bits
 Basés: 2#1001#, 8#65_07, 16#C5#e2 ” 11 ” ou ” 1101110 ”

Les opérateurs Un bus (ou ensemble


 Logiques (boolean, bit, std_ulogic) de fils électrique) est
représenté sous forme
 AND, OR, NAND, NOR, XOR, NOT d’un vecteur de bits
 Relationnels ( retournent un boolean)
 = /= < <= > >=
 Arithmétiques
 + - * / ** MOD REM
 Concaténations d’éléments de tableaux &
 "bon" & "jour" => "bonjour" STD_LOGIC_VECTOR (3 DOWNTO 0);

15
Logique combinatoire: Instructions concurrentes

Assignation simples Exemple 2


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

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


S3<="101";
S4<= "111" XOR E; --manip sur les bus directement
16
end arch_example;
Logique combinatoire: Instructions concurrentes

Assignation conditionnelle signal <= signal1 when expresion_boolénne else


 Structure WHEN/ELSE ………
signal1xx when expresion_boolénne else
---- Solution 1: with WHEN/ELSE -------------
2 LIBRARY ieee; signal par défaut;
3 USE ieee.std_logic_1164.all;
4 ---------------------------------------------
5 ENTITY encoder IS
6 PORT ( x: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
7 y: OUT STD_LOGIC_VECTOR (1 DOWNTO 0));
8 END encoder;
9 ---------------------------------------------
10 ARCHITECTURE encoder1 OF encoder IS Exemple d’application:
11 BEGIN
encodeur clavier pour PIC
12 y <= "00" WHEN x="0001" ELSE
13 "01" WHEN x="0010" ELSE Intérêt: réduire le nombre d’entrée du PIC
14 "10" WHEN x="0100" ELSE
15 "11" WHEN x="1000" ELSE
20 "ZZZ";
21 END encoder1;
22 ---------------------------------------------

17
Logique combinatoire: Instructions concurrentes

Assignation sélective with expression select


signal <= signal1when valeur 1,
signal2 when valeur2,
------
signal par défaut when others ;
Le multiplexeur: on aiguille une enrée vers la
sortie en fonction d’un numéro d’aiguillage

MUX
Autre possibilté:
1 voie parmi 4 std_logic_vector(1 downto 0)

18
Logique combinatoire: Instructions concurrentes

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


 Découpage de votre projet en fonctions: création de composants adéquats
 Assemblage des composants créés pour structurer votre projet
 MOT CLE: PORTMAP Analogie avec ORCAD: on choisit
 Ma Référence :port map ( liste ordonnée de signaux) ; un composant de la bibliothèque en
• ou le référencant sur la feuille
 Ma Référence : port map ( port=> signal , port => signal ) ; Exemple: résistance R1
Un 555: U1

exemple: applicatif: Comment faire un additionneur 4 bits?


etape 1: créer un composant ADDITIONNEUR 1 bits
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY fa IS PORT (
Ci, X, Y: IN STD_LOGIC;
S, Cout: OUT STD_LOGIC);
END fa;
ARCHITECTURE Dataflow OF fa IS
BEGIN
Cout <= (X AND Y) OR (Ci AND (X XOR Y));
S <= X XOR Y XOR Ci;
END Dataflow; 19
Full Adder
Logique combinatoire: Instructions concurrentes

étape 2: Valider le composant ( compilation /simulation)


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

architecture arch_add4full of add4full is


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

ENTITY ET4 IS
PORT
(X1,X2,X3,X4 : IN
--librairie pour inclure type std_logic
STD_LOGIC;
library IEEE;
Y: OUT STD_LOGIC
use IEEE.std_logic_1164.all;
);
END ET4;
ENTITY ET2 IS
PORT
ARCHITECTURE arch_ET4 OF ET4 IS
(
-- partie déclarative COMPOSANT
A,B: IN STD_LOGIC;
On COMPONENT ET2 is
S: OUT STD_LOGIC
PORT
); déclare
(A,B: IN STD_LOGIC;
END ET2; ET2 S: OUT STD_LOGIC);
END COMPONENT ET2;
ARCHITECTURE arch_ET2 OF ET2 IS
-- partie déclarative SIGNAL
BEGIN
--pas de IN ou OUT car signal INTERNE Les fils de
S<= A and B;
SIGNAL FIL1,FIL2: STD_LOGIC ;
END arch_ET2; connexions
BEGIN INTERNES
-----------------------
-- 1ere porte ET placée
U1:ET2 port map (A=>X1,B=>X2,S=>FIL1);
-- 2ème porte ET placée
U2:ET2 port map (A=>X3,B=>X4,S=>FIL2);
-- 3ème porte ET placée PORT MAP
U3:ET2 port map (A=>FIL1,B=>FIL2,S=>Y); pour
-- on pourrait faire à la place !!!! placement et
2 fichiers .vhd avec chacun 1 entity+1 architecture -- Y<= X1 and X2 and X3 and X4
END arch_ET4;
connexion
21
Logique combinatoire: Instructions concurrentes
--les libraries
library IEEE;
Bilan use IEEE.std_logic_1164.all;
……….
 Pour décrire des systèmes combinatoires les
instructions types « concurrentes » seront ENTITY LENIVEAUTOP (
………..)
préférées End ENTITY
 L’ordre des instructions est SANS ARCHITECTURE …..
IMPORTANCE ( car en parallèle)
COMPONENT Truc
 Il est souhaite de scinder les projets en …
composants simples END COMPONENT Déclaration de
COMPONENT Machin
 APPROCHE METHODOLOGIQUE TOP-DOWN …
composants créés

 Utilisation des bibliothèques IEEE END COMPONENT

SIGNAL: ……….
SIGNAL: ……..

XX<=“1110”;
Squelette de YY<= A AND B;
U1: Truc PORT MAP( …….);
description S<= “10” when (A=B) else
Utilisation des
ressources
“00”;
VHDL U2: Machin PORT MAP( …….);
disponibles

With (Toto) select


G<= ……
22
END ARCHITECTURE
Logique combinatoire: exemples

Décodeurs 7 segments
 UTILISATION D’UNE TABLE (LUT) POUR DECRIRE LE SYSTEME
Création de
library IEEE; nouveaux types:
entity decod7seg is use IEEE.std_logic_1164.all; TYPE
port( use IEEE.std_logic_unsigned.all; Tableau: ARRAY
iDigit:IN std_logic_vector(3 downto 0);
oSeg:OUT std_logic_vector(6 downto --definition de l'architecture
architecture arch_dec_7seg_v1 of decod7seg is
0)
-- definition d'un nouveau type
); -- tableau de 16 elements de 7 bits
end decod7seg; type ROM is array(15 downto 0) of std_logic_vector(6 downto 0);
--initialisaion du tableau
-- tableau vu comme une memoire(LUT)
signal LUT:ROM:=(
"1000000","1111001","0100100","0110000","0011001","
0010010","0000010",

"1111000","0000000","0011000","0001000","0000011","
1000110","0100001",

"0000110","0001110");
begin
Carte DE2: -- pour indexer tableau il faut un entier
-- fonction de conversion conv_integer dans
Anode commune
IEEE.std_logic_unsigned.all
Segment actif à ‘0’ oSeg<=LUT(conv_integer(iDigit));
23
Brochage: voir p31 du manuel end arch_dec_7seg_v1;
Logique combinatoire: exemples

Additionneur « haut niveau »


 Emploi des librairies IEEE;
 On augmente la taille de 1 si l’on souhaite conserver la retenue d’entrée
--librairie pour inclure type std_logic architecture arch1_add4full of adddirect is
library IEEE; --creation de TEMP pour resultat: extension de 1 bit
use IEEE.std_logic_1164.all; signal TEMP:std_logic_vector(LARG downto 0);
use IEEE.std_logic_unsigned.all; begin
TEMP<=('0'&A)+('0'&B)+Cin;
--A et B etendu de 1 bit.
entity adddirect is Res<=TEMP(TEMP'HIGH-1 downto 0);
generic (LARG:integer:=4); Cout<=TEMP(TEMP'HIGH);
-- parametre generique --TEMP'HIGH renvoi indice poids fort
-- taille aditionneur changer en 1 clic! end arch1_add4full;

port( Les attributs des signaux -Exemple S[5:0]


Cin:IN std_logic;
S’HIGH renvoie 5 et S’LOW renvoie 0
A:IN std_logic_vector(LARG-1 downto
0); S’RANGE renvoie 5 downto 0
B:IN std_logic_vector(A'range);
S’event renvoie TRUE si changement d’état de S
Res:OUT std_logic_vector(A'range);
Cout:OUT std_logic
);
Utilisation de GENERIC lors du PORT MAP
end adddirect;
U1: generic(10)
24
adddirect PORT MAP(xxxxxx);
Logique combinatoire: exemples

Arithmetic Logic Unit (ALU)

Sélection Op
arithmétique/logique Code Opératoire (mot de
commande sur 3 bits)

25
Logique combinatoire: exemples

Arithmetic Logic Unit (ALU)

2 LIBRARY ieee; Sélection Op


3 USE ieee.std_logic_1164.all; arithmétique/logique
4 USE ieee.std_logic_unsigned.all; Code Opératoire (mot de
5 ---------------------------------------------- commande sur 3 bits)
6 ENTITY ALU IS
26 ----- Logic unit: -----------
7 PORT (a, b: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
27 WITH sel(2 DOWNTO 0) SELECT
8 sel: IN STD_LOGIC_VECTOR (3 DOWNTO 0);
28 logic <= NOT a WHEN "000",
9 cin: IN STD_LOGIC;
29 NOT b WHEN "001",
10 y: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
30 a AND b WHEN "010",
11 END ALU;
31 a OR b WHEN "011",
12 ----------------------------------------------
32 a NAND b WHEN "100",
13 ARCHITECTURE dataflow OF ALU IS
33 a NOR b WHEN "101",
14 SIGNAL arith, logic: STD_LOGIC_VECTOR (7 DOWNTO 0);
34 a XOR b WHEN "110",
15 BEGIN
35 NOT (a XOR b) WHEN OTHERS;
16 ----- Arithmetic unit: ------
36 -------- Mux: ---------------
17 WITH sel(2 DOWNTO 0) SELECT
37 WITH sel(3) SELECT
18 arith <= a WHEN "000",
38 y <= arith WHEN '0',
19 a+1 WHEN "001",
39 logic WHEN OTHERS;
20 a-1 WHEN "010",
40 END dataflow;
21 b WHEN "011",
41 ----------------------------------------------
22 b+1 WHEN "100",
b-1 WHEN "101",
24 a+b WHEN "110", 26
25 a+b+cin WHEN OTHERS;
Logique combinatoire: exemples

Buffers 3 états
De manière générale il faut se poser la
question:
Le composant cible dispose t’il des
ressources nécessaires pour synthétiser
ma fonction
Pas de 3 états possibles si le composants
n’en a pas!!
1 LIBRARY ieee;
2 USE ieee.std_logic_1164.all;
3 ----------------------------------------------
4 ENTITY tri_state IS
5 PORT ( ena: IN STD_LOGIC;
6 input: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
7 output: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
8 END tri_state;
9 ----------------------------------------------
10 ARCHITECTURE tri_state OF tri_state IS
11 BEGIN
12 output <= input WHEN (ena='0') ELSE
13 (OTHERS => 'Z');
14 END tri_state;
15 ----------------------------------------------

27
Logique séquentielle: le process

Le mot clé PROCESS


 Syntaxe:
MONETIQUETTE:process (signal1, signal2 etc)
-- zone déclarative
Signal sFIL1,sFIL2: xxxxxxxx
Begin
xxx
xxx
xxx
end process MONETIQUETTE;

 Le PROCESS est activé lors d’un changement d’état d’un des signaux de la liste de
sensibilité
 Une fois dans le PROCESS le déroulement est SEQUENTIELLE
 Les instructions utilisables dans un PROCESS sont SPECIFIQUE ( pas de when/else
par exemple)
 Les signaux sont mis à jour uniquement à la fin du process
process Process Process(a,b)
begin begin begin
Écritures q <= d; c <= a and b; c <= a and b;
alternatives wait until Reloj = ‘1’; wait on a, b; end process;
end process; end process; 28
Logique séquentielle: le process

Réveil du process
 Exemple: bascule D latch
 Fonctionnement sur niveau

Processus activé

29
Logique séquentielle: le process

Rendre synchrone
 Bascule D edge: fonctionnement sur front

Autre façon:
Process(CLK)
Begin
If (CLK=‘1’) then
Q<=D;
End if;
End process;

30
Logique séquentielle: le process

Ecriture correcte des process


 Les compilateurs imposent une certaine rigidité dans la description des process
 Les règles a respecter

process(horl) Ce qu‟il faut faire!


if (horl‟event and horl = „1‟) then
if (ena = „ 1 ‟) then En pratique le FPGA (ou CPLD)
contenu_registre <= valeur_in; possède une ou des broches
end if; spécifiques pour le signal
end if; d‟horloge
end process;
31
Logique séquentielle: le process

Penser à l’initialisation du systèmes


 Signaux reset et set: comportement défini par l’utilisateur
Reset et Set SYNCHRONE
On remarquera que RST a disparu de la
liste de sensibilité

LIBRARY ieee; process (CLK)


USE ieee.std_logic_1164.all; Begin
--------------------------------------- if (CLK'event and CLK ='1') then
ENTITY dff IS if (RESET =’1’) then
PORT ( d, clk, rst: IN STD_LOGIC; S <= ‘0’;
elsif (SET =’1’)then Actif à 1 ici pour
q: OUT STD_LOGIC); S <= ‘1’; l’exemple
END dff; else
--------------------------------------- S <= D;
ARCHITECTURE behavior OF dff IS end if;
BEGIN end if;
end process ;
PROCESS (rst, clk) Reset ASYNCHRONE
BEGIN
Comportement
IF (rst=‘0') THEN synchrone de la bascule
q <= '0';
ELSIF (clk'EVENT AND clk='1') THEN
q <= d;
END IF;
END PROCESS;
END behavior; 32
Logique séquentielle: le process

Mise à jour des signaux à la fin du process


 Exemple 1: bascule avec sortie complémentée

---- Solution 1: NE MARCHE PAS--------------- ---- Solution 2: OK -------------------


2 LIBRARY ieee; 2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all; 3 USE ieee.std_logic_1164.all;
4 --------------------------------------- 4 ---------------------------------------
5 ENTITY dff IS 5 ENTITY dff IS
6 PORT ( d, clk: IN STD_LOGIC; 6 PORT ( d, clk: IN STD_LOGIC;
7 q: BUFFER STD_LOGIC; 7 q: BUFFER STD_LOGIC;
8 qbar: OUT STD_LOGIC); 8 qbar: OUT STD_LOGIC);
9 END dff; 9 END dff;
10 --------------------------------------- 10 ---------------------------------------
11 ARCHITECTURE not_ok OF dff IS 11 ARCHITECTURE ok OF dff IS
12 BEGIN 12 BEGIN
13 PROCESS (clk) 13 PROCESS (clk)
14 BEGIN 14 BEGIN
15 IF (clk'EVENT AND clk='1') THEN 15 IF (clk'EVENT AND clk='1') THEN
16 q <= d; 16 q <= d; LIGNE 19
17 qbar <= NOT q; LIGNE 17 17 END IF;
18 END IF; 18 END PROCESS; Je décris un relation
Je me fais avoir car si d a COMBINATOIRE => je
19 END PROCESS; 19 qbar <= NOT q;
changé q ne changera qu’à sors du PROCESS!!!
20 END not_ok; 20 END ok;
la fin du process
21 --------------------------------------- 21 ---------------------------------------
33
Logique séquentielle: le process

Mise à jour des signaux


Library ieee;
 Cas des compteurs Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;
architecture DESCRIPTION of CMP4BITSRET is
entity CMP4BITSRET is
signal CMP: std_logic_vector (3 downto 0);
PORT (
begin
RESET, CLOCK : in std_logic;
process (RESET,CLOCK)
RET : out std_logic;
begin
Q : out std_logic_vector (3 downto 0));
if RESET ='1' then
end CMP4BITSRET;
CMP <= "0000";
elsif (CLOCK ='1' and CLOCK'event) then
CMP <= CMP + 1;
if (CMP = "1111") then
RET <= '1';
else
RET <= '0';
end if;
end if;
end process;
Q <= CMP;
end DESCRIPTION; 1110+1=1111 oui mais à la fin du process
Conclusion: etat 1111 et pas de retenue!
Prochain front: 1111+1=0 je detecte 1111 , l’ancienne
valeur et RET passe à 1
Oui mais trop tard!! 34
Logique séquentielle: le process

Des solutions
SOLUTION 1:
SOLUTION 2:
process (RESET,CLOCK) process (RESET,CLOCK)
begin begin
if RESET ='1' then if RESET='1' then
CMP <= "0000"; CMP <= "0000";
elsif (CLOCK ='1' and CLOCK'event) then elsif (CLOCK ='1' and CLOCK'event) then
CMP <= CMP + 1; CMP <= CMP + 1;
if (CMP = "1110") then Je décris le
end if;
–- La retenue passera à un quand CMP = 14 combinatoire HORS
end process;
décimal du PROCESS
RET <= '1'; -- Validation de la retenue
else RET <= '1' when (CMP = "1111") else
RET <= '0'; '0';
end if; Version complètement
end if; synchrone:
end process;
J’anticipe pour avoir un résultat
correct

35
Logique séquentielle: les instructions

Assignations directes Library ieee;


 S<= signal; Use ieee.std_logic_1164.all;
Use ieee.numeric_std.all;
Use ieee.std_logic_unsigned.all;

entity CMP4BITS is
PORT (
CLOCK : in std_logic;
Q : out std_logic_vector (3 downto 0));
Q est défini en sortie end CMP4BITS;

OR Q<=Q+1 signifie architecture DESCRIPTION of CMP4BITS is


Relire état courant et signal Q_BUS_INTERNE : std_logic_vector(3 downto 0));
incrémente begin
Solution 1: définir BUFFER process (CLOCK)
au lieu de OUT begin
if (CLOCK ='1' and CLOCK'event) then
Solution 2: couramment Q_BUS_INTERNE <= Q_BUS_INTERNE + 1;
utilisée: passer par un signal end if;
end process;
Q <= Q_BUS_INTERNE; -- affectation du bus interne au
-- signal de sortie Q
end DESCRIPTION;

36
Logique séquentielle: les instructions

Assignation conditionnelle COMPTEUR GRAY


LIBRARY ieee;
 Structure SI/SINON SI USE ieee.std_logic_1164.all;
Library ieee; USE work.std_arith.all;
Use ieee.std_logic_1164.all; entity GRAY is
Use ieee.numeric_std.all; Bascule T port (H,R :in std_logic;
Use ieee.std_logic_unsigned.all; Q :out std_logic_vector(2 downto 0));
entity BASCULET is end GRAY;
T comme TOGGLE ( basculement)
port ( architecture ARCH_GRAY of GRAY is
D,CLK : in std_logic; La sortie change d’état à chaque front (
utilisation pour la synthèse des compteurs) signal X :std_logic_vector(2 downto 0);
S : buffer std_logic); begin
end BASCULET; process(H,R)
begin
architecture DESCRIPTION of BASCULET is if R='1' then X <= "000";
begin elsif (H'event and H='1') then
PRO_BASCULET : process (CLK) if X = "000" then X <= "001";
Begin Compteur de elsif X = "001" then X <= "011";
if (CLK'event and CLK='1') then GRAY elsif X = "011" then X <= "010";
if (D=’1’) then elsif X = "010" then X <= "110";
S <= not (S); Code binaire elsif X = "110" then X <= "111";
end if; réfléchi elsif X = "111" then X <= "101";
end if; elsif X = "101" then X <= "100";
end process PRO_BASCULET; (codeur de
position par elsif X = "100" then X <= "000";
end DESCRIPTION; end if;
exemple)
end if;
end process;
Q <= X; 37
end ARCH_GRAY;
Logique séquentielle: les instructions

Assignation conditionnelle
 Structure CASE/IS
 Utile pour décrire des grafcets, machine d’états

Case selecteur is
when condition1 => instructions ;
…….
instructions ;
when condition2 => instructions ;
----
when others => instructions ;
end case ;

CAS possibles de l’expression EST


LORSQUE signal = valeur1 => instructions séquentielles;
LORSQUE signal = valeur2 =>instructions séquentielles;
LORSQUE signal = valeur3 =>instructions séquentielles;
LORSQUE signal = AUTRES =>instructions séquentielles;
FIN DE CAS;

38
Logique séquentielle: les instructions

 Exemple de CASE/IS Schéma de principe d’un registre à décalage SIMPLE


 Description d’un registre à décalage

registre à décalage à droite OU à gauche

On peut utiliser une variable à la


Reg_dec: PROCESS (h) place d’un signal
VARIABLE stmp: std_logic_vector(3 DOWNTO 0); Affecttation d’une variable
BEGIN
If (h=‘1’ and h’event) then Mavariable:= ma valeur;
CASE selection IS CONTRAIREMENT AU SIGNAUX
WHEN ”11”=> stmp := d_entree; --chargement paralelle LA VALEUR EST MISE A JOUR DE
WHEN ”10”=>stmp:= stmp(2 DOWNTO 0) & edg; --gauche SUITE
WHEN ”01”=>stmp:= edd &stmp(3 DOWNTO 1); --droite
WHEN OTHERS => ; --mémorisation Rappel: & « colle »
END CASE; les signaux ensemble
sortie <= stmp; la sortie est SYNCHRONE
END PROCESS Reg_dec; Pas de retard supplémentaire car utilisation d’une variable
Si emploi d’un signal à la place d’une variable affectation
EN DEHORS DU PROCESS ( voir chapitre Mise à jour des
signaux et page suivante pour un exemple)
39
Logique séquentielle: des exemples

1 --------------------------------------------------
Registre à décalage simple 2 LIBRARY ieee;
 Sortie série ( 1 seule sortie) 3 USE ieee.std_logic_1164.all;
4 --------------------------------------------------
ENTITY shiftreg IS
6 GENERIC (n: INTEGER := 4);
7 PORT (d, clk, rst: IN STD_LOGIC;
8 q: OUT STD_LOGIC);
9 END shiftreg;
10 --------------------------------------------------
11 ARCHITECTURE behavior OF shiftreg IS
12 SIGNAL internal: STD_LOGIC_VECTOR (n-1 DOWNTO 0);
13 BEGIN
14 PROCESS (clk, rst)
15 BEGIN
16 IF (rst='1') THEN
17 internal <= (OTHERS => '0');
18 ELSIF (clk'EVENT AND clk='1') THEN
19 internal <= d & internal(internal'LEFT DOWNTO 1);
20 END IF;
21 END PROCESS;
22 q <= internal(0);
23 END behavior;
24 --------------------------------------------------

40
Logique séquentielle: des exemples

Registre à décalage
LIBRARY ieee;
 Sortie parallèle USE ieee.std_logic_1164.all;
 Choix du sens USE work.std_arith.all;
entity DECAL_DG is
port (H,R,SENS :in std_logic;
IN_OUT,OUT_IN :inout std_logic);
end DECAL_DG;
architecture ARCH_DECAL_DG of DECAL_DG is
signal Q :std_logic_vector(3 downto 0);
begin
process(H,R)
begin
if R='1' then Q <= "0000";
Emploi de signaux et non de elsif (H'event and H='1') then
variables if SENS = '1' then
Q <= Q(2 downto 0) & IN_OUT;
Affectation en dehors du else Q <= OUT_IN & Q(3 downto 1);
process end if;
end if;
end process;
OUT_IN <= Q(3) when SENS = '1' else 'Z';
IN_OUT <= Q(0) when SENS = '0' else 'Z';
end ARCH_DECAL_DG;

41
Logique séquentielle: des exemples

Une RAM
LIBRARY ieee;
USE ieee.std_logic_1164.all;
---------------------------------------------------
ENTITY ram IS
GENERIC ( bits: INTEGER := 8; -- # of bits per word
words: INTEGER := 16); -- # of words in the memory
PORT ( wr_ena, clk: IN STD_LOGIC;
addr: IN INTEGER RANGE 0 TO words-1;
data_in: IN STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
data_out: OUT STD_LOGIC_VECTOR (bits-1 DOWNTO 0));
12 END ram;
---------------------------------------------------
ARCHITECTURE ram OF ram IS Création d’un nouveau type:
TYPE vector_array IS ARRAY (0 TO words-1) OF STD_LOGIC_VECTOR (bits-1 DOWNTO 0); TYPE
SIGNAL memory: vector_array; Déclaration d’un signal du type C’est un tableau de vecteurs
BEGIN créé précédemment
PROCESS (clk, wr_ena)
BEGIN
IF (clk'EVENT AND clk='1') THEN
IF (wr_ena='1') THEN
memory(addr) <= data_in;
END IF;
END IF;
END PROCESS;
data_out <= memory(addr); 42
END ram;
Logique séquentielle: des exemples

Diviseur de fréquence
 Diviseur par comptable
 Possibilité de faire par décomptage aussi
LIBRARY ieee; Application et utilisation d‟un
USE ieee.std_logic_1164.all;
USE ieee.std_arith.all; diviseur de fréquence
entity DIV_FREQ1 is
port (H :in std_logic; •On évitera de cascader la sortie du
N :in std_logic_vector(3 downto 0); diviseur sur l’horloge du bloc suivant
DIV : out std_logic);
end DIV_FREQ1;
architecture ARCH_DIV_FREQ1 of DIV_FREQ1 is •La bonne méthode:
signal Q :std_logic_vector(3 downto 0); Horloge du système LA même
begin pour tous les blocs
process(H) La sortie du diviseur est une
begin entrée de validation du bloc
if (H'event and H='1') then suivant
if Q = 15 then Q <= N; Si En=‘1’ alors je
else Q <= Q + 1; compte
end if;
end if;
end process;
DIV <= '1' when Q = 15 else '0';
end ARCH_DIV_FREQ1;
43
Logique séquentielle: des exemples

Application et utilisation d’un diviseur de fréquence

LIBRARY ieee;
USE ieee.std_logic_1164.all; COMPOSANT HAUT NIVEAU
USE work.std_arith.all; LIBRARY ieee;
entity COMPTCAS is USE ieee.std_logic_1164.all;
port (H,R,EN :in std_logic; USE work.std_arith.all;
CO :out std_logic; entity COMPT12 is
Q :out std_logic_vector(3 downto 0)); port (H,RAZ,EN :in std_logic;
end COMPTCAS; CO :out std_logic;
architecture ARCH_COMPTCAS of COMPTCAS is Q :out std_logic_vector(11 downto 0));
end COMPT12;
signal X :std_logic_vector(3 downto 0);
architecture ARCH_COMPT12 of COMPT12 is
begin signal X :std_logic_vector(11 downto 0);
process(H,R) signal CO1,CO2,CO3,EN1 :std_logic;
begin component COMPTCAS
if R='1' then X <= "0000"; port (H,R,EN : in std_logic;
elsif (H'event and H='1') then CO : out std_logic;
if EN = '1' then X <= X + 1; Q : out std_logic_vector(3 downto 0));
else X <= X; end component;
end if; begin
COMPTEUR1 : COMPTCAS port map(H,RAZ,EN,CO1,Q(3 downto 0));
end if;
COMPTEUR2 : COMPTCAS port map(H,RAZ,CO1,CO2,Q(7 downto 4));
end process; EN1 <= CO1 and CO2;
Q <= X; COMPTEUR3 : COMPTCAS port map(H,RAZ,EN1,CO3,Q(11 downto 8));
CO <= '1' when Q = 15 else '0'; CO <= CO1 and CO2 and CO3;
44
end ARCH_COMPTCAS; end ARCH_COMPT12;
Logique séquentielle: des exemples

Détection d’un front


 Détection d’un changement d’état d’un signal
 Contrainte: DESCRIPTION SYNCHRONE

Detection: PROCESS Équivalent à


VARIABLE detect : std_logic_vector(1 DOWNTO 0); Process(clk)
BEGIN
WAIT UNTIL rising_edge (clk); -- c'est donc synchrone de clk If (clk=‘1’ and clk’event)
front_montant <= '0'; ……
front_descendant <= '0' ;
detect(1) := detect(0);
detect(0) := signal_lent;
IF detect = "01" THEN
front_montant <= '1'; Rappel:
END IF;
la variable prend sa valeur instannément
IF detect = "10" THEN
front_descendant <= '1'; Le signal prend sa valeur à la sortie du
END IF; process
END PROCESS;

45