Université des Sciences et de Technologie Houari

Boumediene USTHB

MASTER ELECTRONIQUE DES SYSTÈMES EMBARQUÉS

INTRODUCTION AU LANGAGE DE
PROGRAMMATION VHDL
 Objectif de ce cours
Dans ce chapitre, nous aborderons:

Introduction au langage VHDL

Concepts linguistiques de base
Méthodologie de conception de base
Exemples
 Reference Book
1. VHDL Primer by J. Bhasker; Addison Wesley Longman Pub.
2. Introduction to Digital Systems by M. Ercegovec, T. Lang and L.J.
Moreno; Wiley
3. VHDL: Analysis & Modeling of Digital Systems by Z. Navabi; MGH
4. VHDL Programming by Examples by Douglas L. Perry; TMH
5. VHDL by Douglas Perry
6. The Designer Guide to VHDL by P.J. Ashendem; Morgan Kaufmann Pub.
7. Digital System Design with VHDL by Mark Zwolinski; Prentice Hall Pub.
8. Digital Design Principles and Practices by John F. Wakerly, Prentice
Hall (third Edition) 2001 includes Xilinx student edition).
Le VHDL: Qu’est-ce que c’est, et à quoi cela sert-il?

• VHDL: VHSIC Hardware Description Language

• VHSIC: Very High Speed Integrated Circuit (projet de
grande envergure du DoD (Departement of Defense)
Américain, mis en place dans les années ’80
• Principe de base: Définir un langage de description de
matériel qui puisse être utilisé pour simuler du matériel
numérique.
• Extension: Utilisation du même langage pour la
synthèse automatique des circuits.
 VHDL: Est-ce le seul HDL?

• Il existe plusieurs autres langages de description de

matériel, entre autres:
• Verilog (Très populaire aux États-Unis, utilisé aussi en
Europe, au Japon et au Canada)
• UDL/1 (Utilisé à un certain moment au Japon)
• Estérel (langage académique – Français)
• HardwareC (langage académique – Stanford)
• Verilog est plus simple que le VHDL, mais est un peu
moins utilisé
 Pourquoi utiliser des langages HDL?

• Pouraccélérer la conception de circuits (raison

économique)
• Pourpermettre la conception de circuits très
complexes (150 millions de portes logiques d’ici 5
ans)
• Pour pouvoir représenter les systèmes numériques
selon les différents axes d’abstraction
 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 ( // )
• Des comportements séquentiels
Les deux portes
• Synthèse ou modélisation travaillent en //

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

 Terminology
• HDL: Hardware Description Language
• E.g.: Verilog, VHDL
• RTL: Register Transfer Level.
Il est en HDL écrit pour la synthèse logique (alias HDL structurel): les opérations et les
événements de cycle d'horloge à cycle d'horloge sont explicitement définis → l'architecture de la
conception est implicite dans le code RTL
• Behavioral HDL
Il s'agit de HDL écrit pour la synthèse comportementale: il décrit l'intention et l'algorithme sous-
jacent à la conception sans spécifier le comportement de cycle à cycle.
• Behavioral synthesis
Il tente d'optimiser la conception au niveau architectural avec des contraintes d'horloge, de
latence et de débit. La sortie est une conception de niveau RTL avec des horloges, des registres
et des bus.
• Logic synthesis
Il convertit automatiquement le code RTL en portes sans modifier l'architecture implicite. Il tente
d'optimiser la mise en œuvre au niveau de la porte pour atteindre les objectifs de performance
(délai, zone, etc.).
Flux graphique
Implement

Simulate

Synthesize

Map

Place

Route

Download
 Grandes étapes

• Input Hardware Description Langue (HDL)

• Synthesis (La synthèse)
• Map (Carte)
• Place & Route (Lieu et itinéraire)
• Hardware configuration file generation (Génération
du fichier de configuration matérielle)
 Grandes étapes
Input VHDL description Z <= (A and B) or C;
A
Transformer le VHDL en portes Z
primitives (synthèse) B
C
Z A
Transformer les primitives en primitives B
dépendantes de la technologie (MAP) LUT
C

LUT LUT LUT A

Associer une primitive à des instances Z B
spécifiques et se connecter à l'aide de LUT LUT LUT C
ressources de routage (PAR)
LUT LUT LUT

000 000 000 A

Encode la description du placement et du routage Z B
dans un fichier de configuration pour la 000 000 101 C
programmation d'un type de FPGA spécifique 000 000 000
Méthodologie de conception de base

Exigences

RTL Model Simulate

Synthesize

Gate-level
Model Simulate Test Bench

ASIC or FPGA Place & Route

Timing
Model Simulate
 Le « Y » de Gadjsky

Comportemental Structural

Algorithmes
Processeurs
Register transfer
Registres
Expressions Booléennes
Portes
Fonctions de transfert
Transistors

•Le design est structuré autour Cellules

d'une hiérarchie de Modules

représentations
Circuits
• Les HDL peuvent décrire
différents aspects d'une Circuit imprimé
conception à plusieurs niveaux
d'abstraction Physique
Domaines et niveaux de modélisation

Structural Functional

haut niveau
d'abstraction

faible niveau
d'abstraction

Geometric “Y-chart” due to

Gajski & Kahn
Domaines et niveaux de modélisation

Structural Functional
Algorithme (comportemental)

Register-Transfer
Language

Boolean Equation

Differential Equation

Geometric “Y-chart” due to

Gajski & Kahn
 Domaines et niveaux de modélisation

Structural Functional
Processor-Memory
Switch

Register-Transfer

Gate

Transistor

Geometric “Y-chart” due to

Gajski & Kahn
Domaines et niveaux de modélisation

Structural Functional

Polygons

Sticks

Standard Cells

Plan d'étage

Geometric “Y-chart” due to

Gajski & Kahn
 Concepts VHDL de base

• Interfaces
• Modeling (Behavior, Dataflow, Structure)
• Test Benches
• Analysis, elaboration, simulation
• Synthesis
 Flux de conception conventionnel
Funct. Spec

RTL Behav. Simul.

Logic Synth. Stat. Wire Model

L'extrémité avant
Gate-level Net. Gate-Lev. Sim.

Back-end Floorplanning
Parasitic Extrac.
Place & Route

Layout
Vérification à différents niveaux d'abstraction

System Simulators
Behavioral
HDL HDL Simulators

Couverture de code
RTL

Gate-level Simulators

Verification
Analyse temporelle
Gate-level statique

Layout vs
Physical Schematic (LVS)
Domain
 Classification des simulateurs

Logic Simulators

HDL-based Emulator-based Schematic-based

Event-driven Cycle-based Gate System

 Flot de conception
• Un outils de développement:

22
 Classification des simulateurs
• HDL-based: Conception et banc de test décrits avec HDL
• Event-driven
• Cycle-based

• Schematic-based: La conception est entrée graphiquement à

l'aide d'un éditeur de schéma

• Emulators: La conception est mappée dans le matériel FPGA pour

la simulation de prototypes. Utilisé pour effectuer une co-
simulation matériel / logiciel
 Premier concept de base: les entités (entity)

•Première étape de définition de matériel:

définir l’interface
•Comment: à l’aide de la déclaration « entity »
Spécification entrée-sortie du circuit

Example: my_ckt
Inputs: A, B, C
Outputs: X, Y
VHDL description:
A entity my_ckt is
X
port (
B my_ckt
Y A: in bit;
S B: in bit;
S: in bit;
X: out bit;
Y: out bit);
end my_ckt ;
 VHDL entity

Datatypes:
• entity my_ckt is In-built
Name of the circuit
User-defined
port ( User-defined
Filename same as circuit
A: in bit; Aname
Name of the circuit
B: in bit; Example.
User-defined X
B NomCircuit name:
de fichier
my_ckt my_ckt au
identique
S: in bit; Filename:
nom my_ckt.vhd
du circuit recommandé Y
X: out bit; S Example:
Direction of port
Circuit name: my_ckt
Y: out bit 3 main types:
Nom de fichier: my_ckt.vhd
in: Input
); out: Output
Noms de ports ou
inout: Bidirectional
noms deend my_ckt; Notez l'absence de point-virgule
signaux “;” à la
fin du dernier signal et la présence à la
fin du crochet de fermeture
 VHDL: Concepts de base
• Structure générale
Votre fichier texte de description: xxx.vhd

Mode transfert des signaux de votre entity

27
 VHDL: Concepts de base
• Méthodologie de conception
• Guide pratique du débutant
• COMBINATOIRE: Instructions dites concurrentes
• SEQUENTIELLE: Utilisation d’un PROCESS
Logique combinatoire
La sortie ne dépend pas de l’état passé Logique séquentielle
La sortie dépend de son état passé
Un vecteur d’entrée = un vecteur de sortie Système nécessitant une horloge (systèmes
unique dits synchrones)
Des exemples: Des exemples:
•Multiplexeurs •Compteurs
•Additionneurs •Registres à décalage
•Décodeur 7 segements •Machine d’état (automate)
•Encodeurs de priorité
 Les Opérateurs.
L’affectation simple : <=
Dans une description VHDL, c’est certainement l’opérateur le plus utilisé. En
effet il permet de modifier l’état d’un signal en fonction d’autres signaux et/ou
d’autres opérateurs.

Exemple avec des portes logiques : S1 <= E2 and E1 ;

Les valeurs numériques que l’on peut affecter à un signal sont les suivantes :
- ‘1’ ou ‘H’ pour un niveau haut avec un signal de 1 bit.
- ‘0’ ou ‘L’ pour un niveau bas avec un signal de 0 bit.
- ‘Z’ pour un état haute impédance avec un signal de 1 bit.
- ‘-’ pour un état quelconque, c’est à dire ‘0’ ou ‘1’. Cette valeur est très utilisée avec les
instructions : when … else et with …. Select ….
 Les Opérateurs.
Opérateur de concaténation : &.

Cet opérateur permet de joindre des signaux entre eux.

Exemple :
-- Soit A et B de type 3 bits et S1 de type 8 bits
-- A = "001" et B ="110"
S1 <= A & B & "01" ;
-- S1 prendra la valeur suivante après cette affectation
-- S1 = "001 110 01"
 Les Opérateurs.
Opérateurs logiques.
Opérateur VHDL
ET and
NON ET nand
OU or
NON OU nor
OU EXCLUSIF xor
NON OU EXCLUSIF xnor
NON not
DECALAGE A GAUCHE sll
DECALAGE A DROITE srl
ROTATION A GAUCHE rol
ROTATION A DROITE ror
 Les Opérateurs.
Opérateurs arithmétiques.

Opérateur VHDL
ADDITION +
SOUSTRACTION -
MULTIPLICATION *
DIVISION /
 Les Opérateurs.
Opérateurs relationnels.

Opérateur VHDL
Egal =
Non égal /=
Inférieur <
Inférieur ou égal <=
Supérieur >
Supérieur ou égal >=
 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

ET4 est un composant
Il faut un SIGNAL
(entity+architecture)

On créera 1 composant ET2

(entity+architecture)
Utilisé 3 fois pour décrire ET4
 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);

Séquentiel donc process

COMPT: PROCESS(CLK)
Begin
….
END PROCESS; Sorties pilotant les
Leds de l’afficheur 1
 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;
Exemples • Q<=Q+1; -- Q étant par exemple un std_logic_vector et 1 est un entier!!
• A<B -- A et B des std_logic_vector
Applicatifs
• oData<=CONV_STD_LOGIC_VECTOR(TEMP,8); avec TEMP integer range 0 to 255;
 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 Préfèrez l’emploi de IEEE.numeric_std.all;
• Permet d’étendre le bit de signe correctement!
• signal A,B: signed (LARG downto 0);
A<= resize (signed (SW (LARG downto 1)),LARG+1);
• De travailler avec les opérateurs arithmétiques standart
• >, >=, =<,<, + ,- etc…. Alternative à resize
• Le rajout de use IEEE.std_logic_unsigned.all; permet A<=resize(signed(SW(LARG downto 1)),LARG+1);
• De travailler avec les opérateurs arithmétiques standart
• de mélanger des entiers avec des std_logic_vector: A<= A +1; Recopie du bit bit de poids forts
A<= A(3)&A
 VHDL: Concepts de base
• Littéraux
• Caractères: ’0’, ’x’,’a’,’%’
Ne pas confondre 1 bit exemple ‘0’ ou ‘1’
• Chaînes: ”11110101”,”xx”,”bonjour”,”$@&”
Avec un vecteur de bits
• Chaînes de bits: B”0010_1101”, X ”2D”, O ”055”
• Décimaux: 27, -5, 4e3, 76_562, 4.25 ” 11 ” ou ” 1101110 ”

• Basés: 2#1001#, 8#65_07, 16#C5#e2

• Les opérateurs
• Logiques (boolean, bit, std_ulogic) Un bus (ou ensemble de fils électrique) est
• AND, OR, NAND, NOR, XOR, NOT représenté sous forme 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);
 Logique combinatoire: Instructions concurrentes
Assignation simples library IEEE;
Exemple 2
use IEEE.std_logic_1164.all;
library IEEE; Exemple 1
entity example is
use IEEE.std_logic_1164.all; port(
--librairie pour inclure type std_logic E:IN std_logic_vector(2 downto 0);
--portes ET S1:OUT std_logic; --1 fil
--3 entrées E2 E1 E0 S2,S3:OUT std_logic_vector(3 downto 1);--3 fils S1[3:1]
-- 1 sortie S0 S4:OUT std_logic_vector(2 downto 0)
entity ET3 is Bit Poid Fort Bit Poid faible );
port( end example;
E:IN std_logic_vector(2 downto 0);
--definition de l'architecture
S:OUT std_logic architecture arch_example of example is
); begin
end ET3; S1<='0';
S2<='1‘ & E(1 downto 0);
--definition de l'architecture -- operateur COLLER (ou CONCATENE) &
architecture arch_ET3 of ET3 is -- S2(3) S2(2) S2(1)
begin -- '1' E(1) E(0)
S3<="101";
S<=E(2) and E(1) and E(0); -- E(2) accès au fil 2
S4<= "111" XOR E; --manip sur les bus directement
end arch_ET3; end arch_example;
 Logique combinatoire: Instructions concurrentes
• Assignation conditionnelle : Structure WHEN / ELSE
signal <= signal1 when expresion_boolénne else
---- Solution 1: with WHEN/ELSE ------------- ………
2 LIBRARY ieee; signal1xx when expresion_boolénne else
3 USE ieee.std_logic_1164.all; signal par défaut;
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 ---------------------------------------------
 Logique combinatoire: Instructions concurrentes
Assignation sélective with expression select
signal1 <= signal1 when valeur 1,
Le multiplexeur: on aiguille une entrée vers la sortie signal2 when valeur2,
------
en fonction d’un numéro d’aiguillage signal par défaut when others ;

Autre possibilté:
MUX std_logic_vector(
1 voie parmi 4 1 downto 0)
 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: PORT MAP
• Ma Référence :port map ( liste ordonnée de signaux) ;
Analogie avec ORCAD: on choisit un composant
de la bibliothèque en le référençant sur la feuille
• ou
Exemple: résistance R1
• Ma Référence : port map ( port=> signal , port => signal ) ; Un 555: U1
Exemple: applicatif: Comment faire un additionneur 4 bits?
LIBRARY IEEE;
Etape 1: je crée un composant ADDITIONNEUR 1 bits 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;
Full Adder END Dataflow;
 Logique combinatoire: Instructions concurrentes
Etape 2: je valide le composant ( compilation /simulation)
Etape3: je structure mon niveau supérieur ( comment faire 4 bits avec 1 bit?)

architecture arch_add4full of add4full is

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

--librairie pour inclure type std_logic ENTITY ET4 IS

library IEEE; PORT
(X1,X2,X3,X4 : IN STD_LOGIC;
use IEEE.std_logic_1164.all;
Y: OUT STD_LOGIC
);
ENTITY ET2 IS Je commence par END ET4; Je respecte les noms choisis sur papier
PORT faire ma ET2
( ARCHITECTURE arch_ET4 OF ET4 IS
A,B: IN STD_LOGIC; -- partie déclarative COMPOSANT
COMPONENT ET2 is
S: OUT STD_LOGIC
PORT
); On déclare ET2 (A,B: IN STD_LOGIC;
END 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 connexions
SIGNAL FIL1,FIL2: STD_LOGIC ; INTERNES
S<= A and B;
END arch_ET2; BEGIN
-----------------------
-- 1ere porte ET placée
U1:ET2 port map (A=>X1,B=>X2,S=>FIL1);
-- 2ème porte ET placée PORT MAP pour
U2:ET2 port map (A=>X3,B=>X4,S=>FIL2);
-- 3ème porte ET placée placement et connexion
U3:ET2 port map (A=>FIL1,B=>FIL2,S=>Y);
-- on pourrait faire à la place !!!!
-- Y<= X1 and X2 and X3 and X4
END arch_ET4;
2 fichiers .vhd avec chacun 1 entity + 1 architecture
 Logique combinatoire: Instructions concurrentes
--les libraries

• Bilan library IEEE;

use IEEE.std_logic_1164.all;
……….
• Pour décrire des systèmes combinatoires
ENTITY LENIVEAUTOP (
les instructions types « concurrentes » ………..)
End ENTITY
seront préférées
ARCHITECTURE …..
• L’ordre des instructions est SANS COMPONENT Truc
…
IMPORTANCE ( car en parallèle) END COMPONENT Déclaration de composants
COMPONENT Machin créés
• Il est souhaite de scinder les projets en …
END COMPONENT
composants simples
SIGNAL: ……….
• APPROCHE METHODOLOGIQUE TOP-DOWN SIGNAL: ……..

• Utilisation des bibliothèques IEEE XX<=“1110”;

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

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

"1111000","0000000","0011000","0001000","0000011","1000110","0100001",
"0000110","0001110");
begin
-- pour indexer tableau il faut un entier
-- fonction de conversion conv_integer dans IEEE.std_logic_unsigned.all
oSeg<=LUT(conv_integer(iDigit));
Anode commune
end arch_dec_7seg_v1;
Segment actif à ‘0’
 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
architecture arch1_add4full of adddirect is
--librairie pour inclure type std_logic --creation de TEMP pour resultat: extension de 1 bit
library IEEE; signal TEMP:std_logic_vector(LARG downto 0);
use IEEE.std_logic_1164.all; begin
TEMP<=('0'&A)+('0'&B)+Cin;
use IEEE.std_logic_unsigned.all; --A et B etendu de 1 bit.
Res<=TEMP(TEMP'HIGH-1 downto 0);
entity adddirect is Cout<=TEMP(TEMP'HIGH);
--TEMP'HIGH renvoi indice poids fort
generic (LARG:integer:=4); end arch1_add4full;
-- parametre generique
-- taille aditionneur changer en 1 clic! Les attributs des signaux -Exemple S[5:0]
port(
S’HIGH renvoie 5 et S’LOW renvoie 0
Cin:IN std_logic;
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);
Utilisation de GENERIC lors du PORT MAP
Cout:OUT std_logic
); U1: generic(10)
end adddirect; adddirect PORT MAP(xxxxxx);
 Logique combinatoire: exemples
Arithmetic Logic Unit (ALU)

Sélection Op arithmétique/logique
2 LIBRARY ieee;
3 USE ieee.std_logic_1164.all;
4 USE ieee.std_logic_unsigned.all;
5 ----------------------------------------------
Code Opératoire (mot de commande sur 3 bits)
6 ENTITY ALU IS
7 PORT (a, b: IN STD_LOGIC_VECTOR (7 DOWNTO 0);
8 sel: IN STD_LOGIC_VECTOR (3 DOWNTO 0); 26 ----- Logic unit: -----------
9 cin: IN STD_LOGIC;
10 y: OUT STD_LOGIC_VECTOR (7 DOWNTO 0));
27 WITH sel(2 DOWNTO 0) SELECT
11 END ALU; 28 logic <= NOT a WHEN "000",
12 ---------------------------------------------- 29 NOT b WHEN "001",
13 ARCHITECTURE dataflow OF ALU IS 30 a AND b WHEN "010",
14 SIGNAL arith, logic: STD_LOGIC_VECTOR (7 DOWNTO 0); 31 a OR b WHEN "011",
15 BEGIN 32 a NAND b WHEN "100",
16 ----- Arithmetic unit: ------ 33 a NOR b WHEN "101",
17 WITH sel(2 DOWNTO 0) SELECT
18 arith <= a WHEN "000",
34 a XOR b WHEN "110",
19 a+1 WHEN "001", 35 NOT (a XOR b) WHEN OTHERS;
20 a-1 WHEN "010", 36 -------- Mux: ---------------
21 b WHEN "011", 37 WITH sel(3) SELECT
22 b+1 WHEN "100", 38 y <= arith WHEN '0',
b-1 WHEN "101", 39 logic WHEN OTHERS;
24 a+b WHEN "110", 40 END dataflow;
25 a+b+cin WHEN OTHERS;
41 ----------------------------------------------
 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
1 LIBRARY ieee; Pas de 3 états possibles si le composants n’en a
2 USE ieee.std_logic_1164.all; pas!!
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 ----------------------------------------------
 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
q <= d; c <= a and b; c <= a and b;
Écritures alternatives wait until Reloj = ‘1’; wait on a, b; end process;
end process; end process;
 Logique séquentielle: le process
• Réveil du process
• Exemple: bascule D latch
• Fonctionnement sur niveau

Processus activé
 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;
 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)
if (horl’event and horl = ‘1’) then Ce qu’il faut faire!
if (ena = ‘ 1 ’) then
En pratique le FPGA (ou
contenu_registre <= valeur_in;
CPLD) possède une ou
end if;
des broches spécifiques
end if;
pour le signal d’horloge
end process;
 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
LIBRARY ieee;
On remarquera que RST a
USE ieee.std_logic_1164.all;
disparu de la liste de sensibilité
---------------------------------------
ENTITY dff IS
PORT ( d, clk, rst: IN STD_LOGIC;
q: OUT STD_LOGIC); process (CLK)
END dff; Begin
if (CLK'event and CLK ='1') then
--------------------------------------- if (RESET =’1’) then
S <= ‘0’;
ARCHITECTURE behavior OF dff IS elsif (SET =’1’)then Actif à 1 ici pour l’exemple
BEGIN S <= ‘1’;
else
PROCESS (rst, clk) S <= D;
end if;
BEGIN end if;
IF (rst=‘0') THEN end process ;

q <= '0';
ELSIF (clk'EVENT AND clk='1') THEN Reset ASYNCHRONE
q <= d;
Comportement
END IF;
synchrone de la bascule
END PROCESS;
END behavior;
 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 LIGNE 17 15 IF (clk'EVENT AND clk='1') THEN
16 q <= d; 16 q <= d; LIGNE 19
17 qbar <= NOT q; Je me fais avoir car si d 17 END IF;
18 END IF; a changé q ne changera 18 END PROCESS; Je décris une relation
19 END PROCESS; qu’à la fin du process 19 qbar <= NOT q;
20 END ok;
COMBINATOIRE => je
20 END not_ok;
21 --------------------------------------- 21 --------------------------------------- sors du PROCESS!!!
 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;
architecture DESCRIPTION of CMP4BITSRET is Use ieee.std_logic_unsigned.all;
signal CMP: std_logic_vector (3 downto 0); entity CMP4BITSRET is
begin PORT (
process (RESET,CLOCK) RESET, CLOCK : in std_logic;
begin RET : out std_logic;
if RESET ='1' then Q : out std_logic_vector (3 downto 0));
CMP <= "0000"; end CMP4BITSRET;
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; 1110+1=1111 oui mais à la fin du process
Q <= CMP; Conclusion: etat 1111 et pas de retenue!
end DESCRIPTION; Prochain front: 1111+1=0 je detecte 1111 , l’ancienne valeur et RET passe à 1
Oui mais trop tard!!
 Logique séquentielle: le process
• Des solutions SOLUTION 2:
process (RESET,CLOCK)
SOLUTION 1:
begin
if RESET='1' then
process (RESET,CLOCK)
CMP <= "0000";
begin
elsif (CLOCK ='1' and CLOCK'event) then
if RESET ='1' then
CMP <= CMP + 1;
CMP <= "0000";
end if;
elsif (CLOCK ='1' and CLOCK'event) then
end process;
CMP <= CMP + 1; Je décris le
if (CMP = "1110") then combinatoire -- Validation de la retenue
–- La retenue passera à un quand CMP = 14 HORS du RET <= '1' when (CMP = "1111") else '0';
décimal PROCESS
RET <= '1';
else
RET <= '0'; Version complètement
end if; synchrone:
end if; J’anticipe pour avoir un
end process; résultat correct
 Logique séquentielle: le process
Compteur avec Remise à Zéro (RAZ)
L'entrée RAZ( Remise à Zéro) (Reset en anglais) sur un compteur est une entrée qui permet de mettre la
valeur du compteur à 0. Elle peut être synchrone (prise en compte seulement sur front d'horloge) ou
asynchrone.
library ieee; use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all; On peut remarquer que la
use ieee.std_logic_unsigned.all; liste de sensibilité n'est
ENTITY Compteur IS pas la même dans les
PORT ( deux cas : "clk" pour le
clk,raz :IN std_logic; synchrone et "clk,raz"
q : BUFFER std_logic_vector(3 downto 0)); pour l'asynchrone.
END Compteur;

-- ******* methode synchrone **********

-- ******** methode asynchrone *********
PROCESS(clk)
PROCESS(clk,raz)
BEGIN
BEGIN
IF clk'event and clk='1' THEN
IF raz='1' THEN
IF raz='1' THEN
q<=(OTHERS=>'0'); -- ou q <= "0000";
q <= (OTHERS=>'0'); -- ou q <= "0000";
ELSIF clk'event and clk='1' THEN
ELSE q <= q + 1;
q <= q + 1;
END IF;
END IF;
END IF;
END PROCESS;
END PROCESS;
 Logique séquentielle: le process
Remarque sur le type BUFFER : Xilinx déconseille d'utiliser le type BUFFER dans une entité, particulièrement
quand il s'agit d'un signal interne au FPGA (pas une sortie physique). Il conseille plutôt d'utiliser un signal pour
compter et une sortie spécifique pour sortir le ou les bits utiles. Pour l'initialisation synchrone, par exemple, le
programme complet sera la suivant :

ARCHITECTURE aCmpt OF Compteur IS

SIGNAL q : std_logic_vector(3 downto 0); -- signal intermédiaire
library ieee;
BEGIN
use ieee.std_logic_1164.all;
-- RAZ synchrone
use ieee.std_logic_arith.all;
PROCESS(clk) BEGIN
use ieee.std_logic_unsigned.all;
IF clk'event and clk='1' THEN
ENTITY Compteur IS
IF raz='1' THEN
PORT (
q<=(OTHERS=>'0');
clk,raz :IN std_logic;
ELSE q <= q + 1;
qs : OUT std_logic_vector(3 downto 0)); -- sortie véritable
END IF;
END Compteur;
END IF;
END PROCESS; -- toujours faire :
qs <= q;
END aCmpt;
 Logique séquentielle: le process
Compteur avec chargement parallèle
Le chargement parallèle est en général asynchrone dans les circuits existants. Nous allons le conserver comme tel :

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
ENTITY Compteur IS
PORT (
clk,load :IN std_logic;
qs : OUT std_logic_vector(3 downto 0);
qe : IN std_logic_vector(3 downto 0));
END Compteur;
ARCHITECTURE acmpt OF Compteur IS
SIGNAL q :std_logic_vector(3 downto 0);
BEGIN
qs <= q;
PROCESS(clk,load) BEGIN
IF load='1' THEN
q<=qe; -- ou q<=31; valeur predefinie
ELSIF clk'event and clk='1' THEN
q<=q+1;
END IF;
END PROCESS;
END acmpt;
 Logique séquentielle: le process
Compteur 4 bits BCD avec validation d'horloge
architecture Behavioral of Counter2_VHDL is
un compteur BCD, c'est à dire qui compte de 0 à 9 signal temp: std_logic_vector(3 downto 0);
begin
process(Clock,Reset) begin
library IEEE; if Reset='1' then
use IEEE.STD_LOGIC_1164.ALL; temp <= "0000";
use IEEE.STD_LOGIC_ARITH.ALL; elsif(Clock'event and Clock='1') then
use IEEE.STD_LOGIC_UNSIGNED.ALL; if Clock_enable='0' then
entity Counter2_VHDL is if temp="1001" then
port(
temp<="0000";
Clock_enable: in std_logic;
Clock: in std_logic; else temp <= temp + 1;
Reset: in std_logic; end if;
Output: out std_logic_vector(3 downto 0)); else temp <= temp;
end Counter2_VHDL; end if;
end if;
end process;
Output <= temp;
end Behavioral;
Logique séquentielle: le process
Résultats de simulation
 Logique séquentielle: le process
Compteur 4 bits
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity counter is
Port ( CLOCK : in STD_LOGIC;
DIRECTION : in STD_LOGIC;
COUNT_OUT : out STD_LOGIC_VECTOR (3 downto 0));
end counter;
architecture Behavioral of counter is
signal count_int : std_logic_vector(3 downto 0) := "0000";
begin
process (CLOCK)
Begin
if CLOCK='1' and CLOCK'event then
if DIRECTION='1' then
count_int <= count_int + 1;
else
count_int <= count_int - 1;
end if;
end if;
end process;
COUNT_OUT <= count_int;
end Behavioral;
 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));
end CMP4BITS;
Q est défini en sortie
architecture DESCRIPTION of CMP4BITS is
OR Q<=Q+1 signifie signal Q_BUS_INTERNE : std_logic_vector(3 downto 0));
Relire état courant et incrémente begin
Solution 1: définir BUFFER au lieu process (CLOCK)
de OUT begin
if (CLOCK ='1' and CLOCK'event) then
Solution 2: couramment utilisée: Q_BUS_INTERNE <= Q_BUS_INTERNE + 1;
end if;
passer par un signal
end process;
Q <= Q_BUS_INTERNE; -- affectation du bus interne au
-- signal de sortie Q
end DESCRIPTION;
 Logique séquentielle: les instructions
• Assignation conditionnelle COMPTEUR GRAY
LIBRARY ieee;
• Structure SI/SINON SI USE ieee.std_logic_1164.all;
USE work.std_arith.all;
entity GRAY is
Library ieee; port (H,R :in std_logic;
Use ieee.std_logic_1164.all; Q :out std_logic_vector(2 downto 0));
Use ieee.numeric_std.all; end GRAY;
Use ieee.std_logic_unsigned.all; architecture ARCH_GRAY of GRAY is
entity BASCULET is signal X :std_logic_vector(2 downto 0);
port ( begin
D,CLK : in std_logic; Bascule T
process(H,R)
S : buffer std_logic); begin
end BASCULET; T comme TOGGLE ( basculement) if R='1' then X <= "000";
La sortie change d’état à chaque front ( elsif (H'event and H='1') then
architecture DESCRIPTION of if X = "000" then X <= "001";
BASCULET is utilisation pour la synthèse des compteurs)
elsif X = "001" then X <= "011";
begin elsif X = "011" then X <= "010";
PRO_BASCULET : process (CLK) elsif X = "010" then X <= "110";
Begin elsif X = "110" then X <= "111";
if (CLK'event and CLK='1') then elsif X = "111" then X <= "101";
if (D=’1’) then Compteur elsif X = "101" then X <= "100";
S <= not (S); de GRAY elsif X = "100" then X <= "000";
end if; end if;
end if; end if;
end process PRO_BASCULET; Code binaire réfléchi
end process;
end DESCRIPTION; Q <= X;
(codeur de position par exemple)
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;
 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

Reg_dec: PROCESS (h)

VARIABLE stmp: std_logic_vector(3 DOWNTO 0);
BEGIN On peut utiliser une variable à la place d’un signal
If (h=‘1’ and h’event) then
CASE selection IS Affecttation d’une variable
WHEN ”11”=> stmp := d_entree; --chargement paralelle
WHEN ”10”=>stmp:= stmp(2 DOWNTO 0) & edg; --gauche Mavariable:= ma valeur;
WHEN ”01”=>stmp:= edd &stmp(3 DOWNTO 1); --droite
WHEN OTHERS => ; --mémorisation CONTRAIREMENT AU SIGNAUX LA VALEUR EST MISE A
END CASE;
sortie <= stmp; JOUR DE SUITE
END PROCESS Reg_dec;
Rappel: & « colle » les signaux ensemble

la sortie est SYNCHRONE

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
 Logique séquentielle: les instructions
Registre à décalage
L'opérateur de concaténation "&" est utile pour ce genre de registre. Voici un exemple de registre à
décalage vers la droite (vers les poids faible) : le bit de poids faible (indice 0) est perdu, le bit d'entrée est
ajouté aux bits restants (indices 7 à 1).

architecture aShiftReg of ShiftReg is

signal dataq : std_logic_vector(7 downto 0);
begin
library IEEE;
use IEEE.STD_LOGIC_1164.ALL; process(clk) begin
entity ShiftReg is if clk'event and clk='0' then -- c'est ici que l'on concatène le bit d'entrée
port( au registre décalé
clk,entree : in std_logic; dataq <= entree & dataq(7 downto 1);
q : out std_logic_vector(7 downto 0));
end ShiftReg; end if;
end process;
process(dataq)begin
q<=dataq;
end process;
end aShiftReg;
Logique séquentielle: les instructions
Registre à décalage
 Logique séquentielle: des exemples
• Registre à décalage simple 1 --------------------------------------------------
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 --------------------------------------------------
 Logique séquentielle: des exemples
• Registre à décalage LIBRARY ieee;
• Sortie parallèle USE ieee.std_logic_1164.all;
USE work.std_arith.all;
• Choix du sens 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";
elsif (H'event and H='1') then
if SENS = '1' then
Q <= Q(2 downto 0) & IN_OUT;
Emploi de signaux et non de variables else Q <= OUT_IN & Q(3 downto 1);
end if;
Affectation en dehors du process 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;
 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
TYPE vector_array IS ARRAY (0 TO words-1) OF STD_LOGIC_VECTOR (bits-1 DOWNTO 0);
SIGNAL memory: vector_array;
BEGIN
Déclaration d’un signal du Création d’un nouveau type: TYPE
PROCESS (clk, wr_ena) type créé précédemment
BEGIN C’est un tableau de vecteurs
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);
END ram;
 Logique séquentielle: des exemples
• Diviseur de fréquence
• Diviseur par comptable
• Possibilité de faire par décomptage aussi
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE ieee.std_arith.all;
entity DIV_FREQ1 is
port (H :in std_logic;
N :in std_logic_vector(3 downto 0); Application et utilisation d’un diviseur de fréquence
DIV : out std_logic);
end DIV_FREQ1; •On évitera de cascader la sortie du diviseur sur l’horloge du
architecture ARCH_DIV_FREQ1 of DIV_FREQ1 is bloc suivant
signal Q :std_logic_vector(3 downto 0);
begin
•La bonne méthode:
process(H)
begin Horloge du système LA même pour tous les
if (H'event and H='1') then blocs
if Q = 15 then Q <= N; La sortie du diviseur est une entrée de validation
else Q <= Q + 1;
end if;
du bloc suivant
end if; Si En=‘1’ alors je compte
end process;
DIV <= '1' when Q = 15 else '0';
end ARCH_DIV_FREQ1;
 Logique séquentielle: des exemples
• Application et utilisation d’un diviseur de fréquence
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.std_arith.all;
entity COMPTCAS is
port (H,R,EN :in std_logic;
CO :out std_logic;
Q :out std_logic_vector(3 downto 0));
end COMPTCAS;
architecture ARCH_COMPTCAS of COMPTCAS is COMPOSANT HAUT NIVEAU
LIBRARY ieee;
signal X :std_logic_vector(3 downto 0); USE ieee.std_logic_1164.all;
USE work.std_arith.all;
begin entity COMPT12 is
process(H,R) port (H,RAZ,EN :in std_logic;
begin CO :out std_logic;
Q :out std_logic_vector(11 downto 0));
if R='1' then X <= "0000"; end COMPT12;
elsif (H'event and H='1') then architecture ARCH_COMPT12 of COMPT12 is
if EN = '1' then X <= X + 1; signal X :std_logic_vector(11 downto 0);
signal CO1,CO2,CO3,EN1 :std_logic;
else X <= X; component COMPTCAS
end if; port (H,R,EN : in std_logic;
end if; CO : out std_logic;
Q : out std_logic_vector(3 downto 0));
end process; end component;
Q <= X; begin
CO <= '1' when Q = 15 else '0'; COMPTEUR1 : COMPTCAS port map(H,RAZ,EN,CO1,Q(3 downto 0));
COMPTEUR2 : COMPTCAS port map(H,RAZ,CO1,CO2,Q(7 downto 4));
end ARCH_COMPTCAS; EN1 <= CO1 and CO2;
COMPTEUR3 : COMPTCAS port map(H,RAZ,EN1,CO3,Q(11 downto 8));
CO <= CO1 and CO2 and CO3;
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
Équivalent à
Detection: PROCESS
VARIABLE detect : std_logic_vector(1 DOWNTO 0); Process(clk)
BEGIN If (clk=‘1’ and clk’event)
WAIT UNTIL rising_edge (clk); -- c'est donc synchrone de clk
front_montant <= '0'; ……
front_descendant <= '0' ;
detect(1) := detect(0);
detect(0) := signal_lent;
IF detect = "01" THEN
front_montant <= '1';
END IF; Rappel:
IF detect = "10" THEN la variable prend sa valeur instannément
front_descendant <= '1';
END IF; Le signal prend sa valeur à la sortie du
END PROCESS; process
End of Presentation Thank You!

Any Questions ?
“The future depends on what you do today.”