Vous êtes sur la page 1sur 91

Systèmes embarqués temps réel

Pr. AMAMI Benaissa


2020/2021

Systèmes Embarqués Temps Réel 1


FST Tanger 2020/2021
Chapitre 5 :
Les circuits logiques programmables FPGA
et Programmation VHDL
1. Circuits Logiques Programmables: FPGA

❑ Un circuit logique programmable, ou réseau logique programmable, est


un circuit intégré logique qui peut être reprogrammé après sa fabrication.
❑ Il est composé de nombreuses cellules logiques élémentaires et bascules logiques
librement connectables
❑ C'est la reconfiguration, ou programmation, du composant qui définit les
connexions faites entre portes logiques.

❑ On parle pas de programmation au sens logiciel (contrairement à un


microprocesseur). on parlera de « reconfiguration » plutôt que de
reprogrammation (on modifie des connexions ou le comportement du composant,
on connecte des portes logiques entre elles, etc.).
❑ Il s'agit de réseaux logiques reconfigurables et modifiables.

P. Amami Benaissa/ FST Tanger 3


1. Circuits Logiques Programmables: FPGA

❑ Ce type de composant électronique est communément désigné par différents appellations en


anglais dont notamment :

▪ FPGA (field-programmable gate array, réseau de portes programmables , plus de 106


portes) ;
▪ PLD (programmable logic device, circuit logique programmable, 100-200 portes) ;
▪ EPLD (erasable programmable logic device, circuit logique programmable et
effaçable) ;
▪ CPLD (complex programmable logic device, circuit logique programmable
complexe, 5-10 K portes );
▪ PAL (programmable array logic, réseau logique programmable) ;
▪ PLA (programmable logic array, réseau logique programmable).

❑ Bien que fondamentalement synonymes, ces termes ne sont généralement pas


interchangeables dans le vocabulaire commercial des fabricants :

▪ FPGA désigne plutôt des composants à technologie RAM,


▪ EPLD des composants à technologie FLASH,
▪ PAL des composants à technologie FUSIBLE.

P. Amami Benaissa/ FST Tanger 4


1. Circuits Logiques Programmables: FPGA

P. Amami Benaissa/ FST Tanger 5


1. Circuits Logiques Programmables: FPGA

P. Amami Benaissa/ FST Tanger 6


1. Circuits Logiques Programmables: FPGA

❑ Un circuit FPGA est un composant électronique qui contient des milliers, voire des
millions de transistors connectés ensemble pour réaliser des fonctions logiques
simples telles que des additions ou des soustractions ou des fonctions complexes
telles que la mise en œuvre d’un contrôleur DSP (digital signal processor) ou bien
microprocesseur.
❑ Ces circuits FPGA sont largement utilisés dans les systèmes embarqués
notamment dans les domaines de l’automatisme, de l’automobile, de
l’aéronautique et des télécommunications
❑ les circuits FPGA présentent une technologie qui permet de reprogrammer le
circuit à la carte (in situ).
❑ En effet l’avantage majeur que présentent les circuits FPGA, est leur grande
flexibilité, car la structure interne peut être changée sans avoir à modifier la
structure globale du circuit.
❑ Cet avantage nous permet de faire des prototypages rapides et de moindre coût
en comparaison avec d’autres circuits ASIC (Application-Specific Integrated
Circuit) par exemple.

P. Amami Benaissa/ FST Tanger 7


1. Circuits Logiques Programmables: FPGA

❑ Xilinx, Altera et Quicklogic sont les pionniers dans les domaines des circuits FPGA. Toutes ces
compagnies se partagent le même concept architectural. Il se divise en trois parties :

▪ les blocs d’entrées et sorties (IOB) ;


▪ les blocs logiques de configuration (CLB) ;
▪ les interconnexions.

❑ Les blocs logiques, présents en grand nombre sur la puce (de quelques milliers à quelques
millions) sont connectés entre eux par une matrice de routage configurable. Ceci permet la
reconfiguration à volonté du composant.

P. Amami Benaissa/ FST Tanger 8


1. Circuits Logiques Programmables: FPGA

P. Amami Benaissa/ FST Tanger 9


1. Circuits Logiques Programmables: FPGA

P. Amami Benaissa/ FST Tanger 10


2. Langage VHDL
❑ Afin de pouvoir finaliser un FPGA, il est nécessaire d'utiliser un langage de
description matériel. Après compilation de cette description, on obtient un fichier
de configuration pour le FPGA choisi. VHDL et Verilog sont les deux langages de
description les plus répandus.

V : (Vhsic: Very High Speed Integrated Circuit)


H : (Hardware)
D : (Description)
L :(Language),

❑ VHDL est un langage de description de matériel destiné à représenter le


comportement ainsi que l'architecture d’un système électronique numérique

❑ Ce n’est pas un langage de programmation, mais plutôt un langage formel pour la


spécification des systèmes digitaux, aussi bien au niveau comportemental que
structurel. Il permet de faire la description, la simulation et la synthèse des
systèmes digitaux.

P. Amami Benaissa/ FST Tanger 11


2. Langage VHDL
Pour développer une application en VHDL, il faudra suivre la démarche ci-dessous :

La création du code source VHDL peut


être faite au moyen d'un éditeur de texte
ou d'outils graphiques permettant de
décrire la structure du système à
modéliser sous la forme de schémas ou
de diagrammes de blocs et son
comportement sous la forme de
machines d’états, de chronogrammes
ou de tables de vérité.

P. Amami Benaissa/ FST Tanger 12


2. Langage VHDL

L’analyseur (ou compilateur) vérifie la


syntaxe d’une description VHDL. Il
permet la détection d’erreurs locales, qui
ne concernent que de l’unité compilée.
L’approche compilée produit directement
du code machine, ou, dans certains cas,
du code C qui sera lui-même compilé.

P. Amami Benaissa/ FST Tanger 13


2. Langage VHDL

Chaque concepteur possède une


bibliothèque de travail (working library)
de nom logique WORK (le nom est
standard) dans laquelle sont placés tous
les modèles compilés. Plusieurs
bibliothèques peuvent être actives
simultanément. Chaque bibliothèque
contient une collection de modèles
mémorisés dans un format
intermédiaire. Elle contient également
un certain nombre de relations et
d’attributs liant, si nécessaire, les
différents modèles entre eux.

P. Amami Benaissa/ FST Tanger 14


2. Langage VHDL

L'élaborateur a pour tâche de créer un


modèle exécutable à partir de modules
compilés séparément et de détecter des
erreurs globales.

P. Amami Benaissa/ FST Tanger 15


2. Langage VHDL

Le simulateur calcule comment le


système modélisé se comporte
lorsqu’on lui applique un ensemble de
stimuli.

P. Amami Benaissa/ FST Tanger 16


2. Langage VHDL
Les cibles VHDL

P. Amami Benaissa/ FST Tanger 17


5. Structure d’une description VHDL
5.1Bibliothèque, Entité et Architecture

• VHDL nous intéresse en tant que langage pour la description, simulation et


synthèse des systèmes digitaux.
• Au plus haut niveau d'abstraction, un système digital est vu comme une "boîte
noire" ou (structure logique) , dont on connaît l'interface avec l'extérieur mais dont
on ignore le contenu

P. Amami Benaissa/ FST Tanger 18


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture

• En VHDL, une boite noire (structure logique) ou la vue externe du composant est
décrite à l'aide d'une entité (entity) et d’une architecture. Une entité doit toujours
être associée avec au moins une description de son contenu, de son
implémentation: c'est l'architecture

P. Amami Benaissa/ FST Tanger 19


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Library
• Library ;Toute description VHDL utilisée pour la synthèse a besoin de bibliothèques.
L’IEEE (Institut of Electrical and Electronics Engineers) les a normalisées et plus
particulièrement la bibliothèque IEEE1164. Elles contiennent les définitions des types
de signaux électroniques, des fonctions et sous programmes permettant de réaliser
des opérations arithmétiques et logiques,...
• Syntaxe de la déclaration de la bibliothèque

• Dans la bibliothèque IEEE STD_LOGIC_1164 TYPE les types usuels sont déjà
déclarés. Le type std_logic contient 9 éléments de base.

P. Amami Benaissa/ FST Tanger 20


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Entity
• entity : permet de déclarer une entité (le modèle du composant)

• port : définit les entrées/sorties : in et out indiquent le sens suivi du type du port, bit prend la
valeur 0 ou 1.
• Syntaxe de la déclaration de l’entité

• A et B sont des entrées de type std_logic, C est une sortie de type std_logic
• VHDL définit quatre modes qui déterminent le sens de transfert d’une donnée au travers du port :

P. Amami Benaissa/ FST Tanger 21


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Entity

• in : L’entité lit un signal d’entrée fourni par l’extérieur (ex : load, reset, clock, donnée
unidirectionnelles)

P. Amami Benaissa/ FST Tanger 22


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Entity

• out : L’entité fournit un signal de sortie, mais ne peut pas relire ce signal

P. Amami Benaissa/ FST Tanger 23


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Entity

• buffer : L’architecture de l’entité fabrique un signal utilisable en sortie, qui peut aussi être relu par
l’entité comme un signal interne (ex : sorties d’un compteur dont l’état doit être testé)

P. Amami Benaissa/ FST Tanger 24


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Entity

• inout : Le signal est bidirectionnel :


• en sortie, il est fourni par l’entité; en entrée, il est fourni par l’extérieur. Ce mode autorise aussi le
bouclage interne (ex : bus de données)
• Par défaut, le mode d’un port est in.

P. Amami Benaissa/ FST Tanger 25


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Entity
• Architecture ; Le Corps de l'architecture est la vue interne du système. Plusieurs
vues sont possibles pour la même conception, dont les principaux styles sont :

• Flots de données (Data flow) : l’architecture est déclarée sous forme d’équations
logiques

• Comportemental : l’architecture est déclarée sous forme d’algorithmes

• Structurel: l’architecture est déclarée sous forme structure, c'est-à-dire sous forme de
composants (component) interconnectés avec des signaux interne. un assemblage
de sous-blocs, similaire à la liste d'interconnexions d'un schéma logique (netlist)

P. Amami Benaissa/ FST Tanger 26


3. Structure d’une description VHDL
Bibliothèque, Entité et Architecture
Entity : signal

• Syntaxe de déclaration de l’architecture sous forme flot de données

• Signal, déclare un signal permettant la communication entre les états concurrents à


l'intérieur d'une architecture. Dans la définition, on doit spécifier un type au signal et
l'on peut attribuer une valeur par défaut.

• Syntaxe de la déclaration d’un signal à l’intérieur d’une architecture

P. Amami Benaissa/ FST Tanger 27


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 1 : Simulation sur ISE de Xilinx de la porte And

•Equation logique : C = A and B

P. Amami Benaissa/ FST Tanger 28


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 1 : Simulation sur ISE de Xilinx de la porte And

P. Amami Benaissa/ FST Tanger 29


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 2 : Simulation sur ISE de Xilinx du circuit demi-additionneur


Le demi additionneur est un circuit combinatoire qui permet de réaliser la somme arithmétique de
deux nombres A et B chacun sur un bit. A la sotie on va avoir la somme S et la retenu Cout (Carry).

• Equation logique : Cout = A and B, S = A Xor B


• Table de vérité de demi-additionneur

P. Amami Benaissa/ FST Tanger 30


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 2 : Simulation sur ISE de Xilinx du circuit demi-additionneur

• Equation logique : Cout = A and B, S = A Xor B

P. Amami Benaissa/ FST Tanger 31


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 3 : Simulation sur ISE de Xilinx du circuit additionneur complet 1 bit


Dans l’Additionneur complet, il faut tenir compte de retenu externe Cout

• Equation logique : S = Cin xor(A xor B);


•Cout = (A and B) or (A and Cin) or (B and Cin);
• Table de vérité de l’additionneur

Cin =R=retinue

P. Amami Benaissa/ FST Tanger 32


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 3 : Simulation sur ISE de Xilinx du circuit additionneur complet 1 bit

P. Amami Benaissa/ FST Tanger 33


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 4 : Simulation sur ISE de Xilinx du circuit additionneur complet 2 bits


Pour l’architecture, on peut exprimer les équations du premier et du second additionneur. Le lien entre les deux
additionneurs est fait à l’aide de C0. C0 est un lien interne il est défini dans l’architecture par le mot signal. L’instruction
SIGNAL déclare un signal permettant la communication entre les états concurrents à l'intérieur d'une architecture.
Dans la définition, on doit spécifier un type au signal et l'on peut attribuer une valeur par défaut

• Equation logique : S = Cin xor(A xor B);


•Cout = (A and B) or (A and Cin) or (B And Cin);

•Avec :

P. Amami Benaissa/ FST Tanger 34


4. Description des circuits numériques avec la conception « Flot de données »

Exemple 4 : Simulation sur ISE de Xilinx du circuit additionneur complet 2 bits

P. Amami Benaissa/ FST Tanger 35


5. Fonction PROCESS

• Une architecture en VHDL est un ensemble de processus exécutés en parallèle (en


concurrence).
• L'ordre relatif des processus à l'intérieur d'une architecture n'a pas d'importance.
• Il existe deux types de processus : Le processus implicite et le processus explicite

• Chaque composant interne du système sera un processus (process) de


l'architecture
• Une architecture est un ensemble de processus
• Les processus s'exécutent en parallèle
• Les processus de l'architecture sont interconnectés par le biais des signaux (signal),
équivalent des fils ou câbles d'interconnexion dans le monde réel

• Un processus explicite est un ensemble de phrases exécutées séquentiellement: à


l'intérieur d'un processus l'ordre des phrases a donc une importance Un processus
ne peut pas être déclaré à l'intérieur d'un autre Processus.
• Tout signal dont le changement de valeur a une influence sur le processus doit
apparaître dans la liste de sensibilité.
• Dans le cas contraire, la simulation pourrait donner des résultats faux puisqu'elle ne
serait pas enclenchée.
• Pour éviter des erreurs, on peut mettre dans la liste de sensibilité tous les signaux
testés ou apparaissant à droite d'une affectation, à l'intérieur du processus.
P. Amami Benaissa/ FST Tanger 36
5. Fonction PROCESS

Syntaxe de déclaration d’un Process

P. Amami Benaissa/ FST Tanger 37


5. Fonction PROCESS

Syntaxe d’instruction Wait

WAIT est utilisé dans une déclaration séquentielle de type PROCESS ou PROCEDURE (voir ci-dessous).
WAIT remplace une liste de sensibilité pour contrôler l'exécution et la suspension d'un PROCESS.
WAIT peut être placé n'importe où dans le PROCESS.
Sans WAIT ou sans liste de sensibilité, un PROCESS se boucle indéfiniment.
WAIT ON est équivalent à une liste de sensibilité. La liste des signaux suit.
Ainsi : les deux codes sont équivalents

Un processus est synchronisé par une (ou plusieurs) instructions WAIT


WAIT ON <événement>
WAIT UNTIL <condition booléenne>
WAIT FOR <durée>
WAIT
Les processus sont cycliques
Un Processus est explicite (PROCESS) ou implicite (instruction concurrente)
P. Amami Benaissa/ FST Tanger 38
6. Description des circuits numériques avec la conception «Comportementale»

Exemple 5 : Simulation sur ISE de Xilinx de la porte and

P. Amami Benaissa/ FST Tanger 39


6. Description des circuits numériques avec la conception «Comportementale»

Exemple 6 : Simulation sur ISE de Xilinx du circuit demi-additionneur

P. Amami Benaissa/ FST Tanger 40


6. Description des circuits numériques avec la conception «Comportementale»

Exemple 7 : Simulation sur ISE de Xilinx du circuit additionneur complet 1 bit

P. Amami Benaissa/ FST Tanger 41


6. Description des circuits numériques avec la conception «Comportementale»

Exemple 8 : Simulation sur ISE de Xilinx d’un compteur

P. Amami Benaissa/ FST Tanger 42


7. Les boucles for, while, if, exit,, case with …select
.

Syntaxe de l’instruction IF

La combinaison IF THEN permet d'effectuer un test d'une expression logique. La suite


du déroulement dépend du résultat. Deux imbrications sont possibles : ELSIF suivi
d'un autre test et ELSE qui contrôle les résultats FALSE.

Remarques :
Il est possible d’imbriquer plusieurs boucles IF les unes dans les autres.

P. Amami Benaissa/ FST Tanger 43


7. Les boucles for, while, if, exit,, case with …select
.

Syntaxe de l’instruction While

WHILE est une instruction de bouclage. Elle s'utilise avec LOOP. On place la condition de
fin de sortie dans l'instruction même contrairement au LOOP seul où on est obligé d'avoir
recourt à la commande EXIT. On peut toutefois utiliser EXIT ou NEXT.
Le bouclage se fait tant que la condition reste TRUE.

P. Amami Benaissa/ FST Tanger 44


7. Les boucles for, while, if, exit,, case with …select
.

Syntaxe de l’instruction FOR

FOR est une instruction de bouclage. Elle s'utilise avec LOOP. On place la condition
de fin de sortie dans l'instruction même contrairement au LOOP seul où on est obligé
d'avoir recourt à la commande EXIT. On peut toutefois utiliser EXIT ou NEXT.

Exemple :

P. Amami Benaissa/ FST Tanger 45


7. Les boucles for, while, if, exit,, case with …select
.

Syntaxe de l’instruction Exit

L’instruction EXIT se combine avec FOR, WHILE et LOOP pour sortir d'une boucle.

P. Amami Benaissa/ FST Tanger 46


7. Les boucles for, while, if, exit,, case with …select
.

Syntaxe de l’instruction Case

L’instruction CASE, souvent appelée “switch case”, convient parfaitement pour décrire
un diagramme d'état, un grafcet ou tout autre formalisme de structures séquentielles
(voir plus loin state machine ou machine à etat). L'instruction “When others” n'est pas
obligatoire, mais son ajout en fin de liste, permet de donner une action à tous les choix
qui n'ont pu être trouvés dans la liste.

P. Amami Benaissa/ FST Tanger 47


7. Les boucles for, while, if, exit,, case with …select
.

Syntaxe de l’instruction Select

Dans la fonctionnalité, SELECT est équivalent à l'instruction CASE. SELECT ne peut


toutefois affecter qu'une seule variable.

Exemple :

P. Amami Benaissa/ FST Tanger 48


8. Fonction component (composant)

La fonction COMPONENT permet d'écrire un programme sous la forme structurelle. En


effet, il faut déclarer et définir les composants de la fonction puis dans le corps de
l'architecture, il suffit de les connecter en suivant un schéma structurel. Cette méthode
d'écriture permet aussi la description hiérarchique.

Quatre blocs sont à distinguer dans une telle définition :

1. Recensement de tous les composants du schéma. Ceci se fait par la syntaxe


Syntaxe de déclaration d’un COMPONENT

2. Affectation des liaisons du schéma aux broches des composants. Cette phase
correspond à réaliser la NETLIST du schéma ceci se fait grâce à la fonction
FOR MAP avec la syntaxe suivante :
Syntaxe de déclaration de FOR MAP

P. Amami Benaissa/ FST Tanger 49


8. Fonction component (composant)

3. Attribution des circuits à leur ENTITY. Cette phase permet de contrôler le


modèle comportemental qui va déterminer le fonctionnement du composant.
La fonction CONFIGURATION permet de réaliser ceci avec la syntaxe
suivante :

Syntaxe de déclaration d’une CONFIGURATION

P. Amami Benaissa/ FST Tanger 50


8. Fonction component (composant)

• Avant d'utiliser (instancier) un composant, il doit être déclaré


• La déclaration d'un composant est similaire à la déclaration d'une entité.
• Pour pouvoir simuler ou synthétiser un composant, il doit exister ailleurs une paire
entité-architecture qui le décrive.
• Le nom du composant doit être le même que celui de l'entité correspondante. Les
noms des signaux du composant doivent être identiques aux noms des signaux de
l'entité correspondante
• Chaque instance d'un composant doit posséder une étiquette. Chaque signal dans la
liste des ports du composant (les noms formels) doit être connecté à un signal dans
l'architecture (les noms réels). Ces associations peuvent être explicites ou implicites
(données par l'ordre dans la liste)

P. Amami Benaissa/ FST Tanger 51


8. Fonction component (composant)

Exemple 9 : Simulation du circuit additionneur complet 1bit avec la conception


structurelle
Le circuit principal est constitué de 5 composants (U1, U2, U3, U4, et U5) mais seulement 3 entités (and, or et xor). Les 5
composants sont reliés entre eux par 3 signaux internes (in1, in2 et in3).

P. Amami Benaissa/ FST Tanger 52


8. Fonction component (composant)

Exemple 9 : Simulation du circuit additionneur complet 1bit avec la conception


structurelle

Procédure à suivre :
1. Déclarer l’entité et l’architecture du circuit principale (ici l’additionneur 1bit)
2. Déclarer tous les composants qui seront utilisés (ici 3 composant : and2, or2,
xor2)
3. Déclarer les signaux qui assureront la liaison entre tous les composants (ici In1,
In2, In3)
4. Faire l’affectation des liaisons du schéma aux broches des composants avec la
fonction PORT MAP pour tous le composant ( ici 5 composants)

l’instruction PORT MAP (a => in1, b => cin, q => sum); affecte l’entrée a du
composant U3 (Xor) au signal intermédiaire(interne) In1 et affecte l’entrée b du
composant U3 (Xor) à l’entrée principale Cin du circuit additionneur et enfin il
affecte la sortie q du composant U3 (Xor) à la sortie principale du circuit
additionneur complet sum

5. Il ne faut pas oublier de déclarer les entités et les architectures des composants
(ici 3 composants and2, or2 et xor2)

P. Amami Benaissa/ FST Tanger 53


8. Fonction component (composant)

Exemple 9 : Simulation du circuit additionneur complet 1bit avec la conception


structurelle

L’entité and2 L’entité or2 L’entité xor2


library IEEE;
use IEEE.STD_LOGIC_1164.ALL; library IEEE; library IEEE;
use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_1164.ALL;
ENTITY and2 IS
PORT (a,b : IN std_logic;q : OUT std_logic); ENTITY or2 IS ENTITY xor2 IS
END and2; PORT (a,b : IN std_logic;q : OUT std_logic); PORT (a,b : IN std_logic;q : OUT std_logic);
END or2; END xor2;
ARCHITECTURE behv OF and2 IS
BEGIN ARCHITECTURE behv OF or2 IS ARCHITECTURE behv OF xor2 IS
q<=a and b; BEGIN BEGIN
END behv; q<=a or b; q<=((not a) and b) or (a and (not b));
END behv; END behv;

6. Il faut attribuer les composants à leur entité (voir étape 5) avec la fonction
CONFIGURATION

L’instruction FOR u1,u3: xor2 USE ENTITY WORK.xor2; veut dire que u1 et u3
héritent du comportement de xor2 défini dans un fichier à part

P. Amami Benaissa/ FST Tanger 54


8. Fonction component (composant)

Exemple 9 : Simulation du circuit additionneur complet 1bit avec la conception


structurelle
Programme complet du circuit additionneur complet 1bit avec la conception structurelle

P. Amami Benaissa/ FST Tanger 55


9. Description des circuits numériques avec la conception
« Structurelle »
Exemple 10 : Simulation du circuit additionneur 2 1bit

Il existe un autre type de description pour l’additionneur 2bits où on définit une structure
contenant deux additionneurs du type Additionneur interconnectés avec un signal interne
Co. Cette description s’appelle une description de type structurel.

P. Amami Benaissa/ FST Tanger 56


9. Description des circuits numériques avec la conception
« Structurelle »
Exemple 10 : Simulation du circuit additionneur 2 1bit

Le ou les composants utilisés dans l’architecture doivent être définis par le mot
component suivi du nom l’entité à utiliser et la description de la nature des ports du
composant.
dditionneur1 et additionneur2 sont les deux additionneurs utilisés, la liste des connexions
est indiqué dans l’ordre :
(additionneur1: A → A(0), B → B(0), Cin→ Cin , Som → Som(0), Cout → Co)
(additionneur2: A → A(1), B → B(1), Cin→ Co , Som → Som(1), Cout → Cout)
Il existe deux manières pour l’affectation des entrées et les sorties aux composants de
l’architecture :

1. Affectation des entrées/sorties par noms (il faut respecter l’ordre )

- port map(Cin=>Cin, A=>A(0), B=>B(0), Cout=>Co, Som=>Som(0));


- port map(Cin=>Co, A=>A(1), B=>B(1), Cout=>Cout, Som=>Som(1));

2. Affectation des entrées/sorties par position :

- port map(A(0), B(0), Cin, Som(0), Co);


- port map(A(1), B(1), Co, Som(1), Cout);
P. Amami Benaissa/ FST Tanger 57
9. Description des circuits numériques avec la conception
« Structurelle »
Exemple 10 : Simulation du circuit additionneur 2 1bit

P. Amami Benaissa/ FST Tanger 58


9. Description des circuits numériques avec la conception
« Structurelle »
Exemple 10 : Simulation du circuit additionneur 2 1bit

Il faut déclarer à part, l’entité à laquelle component fait référence (de laquelle il
hérite)

P. Amami Benaissa/ FST Tanger 59


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

• La fonction ('event) 'événement est un concept important en VHDL. Elle se


rapporte à des signaux et il se produit sur un signal.
• En d'autres termes, un événement sur un signal provoque un changement de la
valeur de ce signal.
• Il est possible de vérifier si un événement s'est produit sur un signal. Une telle
information peut être obtenue grâce à l'attribut 'événement (event) prédéfini.
L’événement(‘event) est très utilisée dans l’architecture des compteurs.

• Les instructions “clk'event and clk = '1'” et “rising_edge(clk) ” renvoient la valeur


booléenne vraie si le signal clk, de type bit, vaut 1 après un changement de
valeur, ce qui revient à tester la présence d’une transition montante de ce signal.

P. Amami Benaissa/ FST Tanger 60


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

• La différence entre les deux fonctions "clk'event and clk='1' " et "rising_edge (clk)" ou
"falling_edge (clk)" concernant la détection des fronts de l’horloge est la suivante :

Dans ce cas il n y a pas de différence entre les deux


fonctions

P. Amami Benaissa/ FST Tanger 61


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'
Considérons le programme suivant :

On peut voir que le signal 'xr' ne change pas du


tout, mais les changements de x0 comme dans le
premier code. C'est la différence fondamentale
entre les deux méthodes.

P. Amami Benaissa/ FST Tanger 62


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'
Exemple 11 : Simulation d’un compteur 3bits : le compteur arrête de
compter si Raz est égale à 1

P. Amami Benaissa/ FST Tanger 63


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'
Exemple 12 : Compteur 3 bits simple, sans remise à 0 et sans utiliser
l’instruction événement (‘event)

P. Amami Benaissa/ FST Tanger 64


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'
Exemple 13 : Compteur 3 bits simple, avec remise à 0 (RAZ) asynchrone, le
compteur compte tant que Raz = 1

P. Amami Benaissa/ FST Tanger 65


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'
Exemple 14: : Compteur 4 bits avec reset et pause est son affichage sur les 4
leds de la carte Spartan 3 E. Le comptage recommence chaque fois qu’il atteint
la valeur 15

Voici le fichier test UCF pour simuler le compteur 4 bits sur la carte spartan 3E

P. Amami Benaissa/ FST Tanger 66


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 15: : Réalisation d’un Compteur 8 bits est avec reset son affichage
sur les 8 leds de la carte Spartan 3E

Voici le fichier test UCF pour simuler le compteur 4 bits


sur la carte spartan 3E

P. Amami Benaissa/ FST Tanger 67


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 16 : Elaboration d’une horloge 24 fois plus lente que l’horloge


principale

• Dans cet exemple, nous allons créer un compteur allant de 0 à 23 et en même


temps, nous allons utiliser ce signal pour générer une horloge qui est 24 fois plus
lente que celle a l’entrée.
• Pour ce faire, il faut commencer par réaliser un compter jusqu'à 23.
• Par la suite, on devrait aussi savoir qu’un compteur est composé de flip flops et de
logique. Il faut donc avoir un process séquentiel (avec clock).
• Un compteur devrait augmenter son compte à chaque front montant d’horloge sauf
quand il arrive à 23. Quand il arrive à 23, il doit recommencer à 0. Ceci est réalisé
par le processus principale suivant :
PROCESS (clk)
BEGIN
IF clk'EVENT AND clk = '1' THEN – si l’horloge est sur front montant
alors
IF s_compt_sortie < 23 THEN –-si s_compt_sortie inférieur à 23
s_compt_sortie <= s_compt_sortie + 1; --incrémenter s_compt_sortie
ELSE -- sinon
s_compt_sortie <= "00000"; -- remise à zero du s_compt_sortie
END IF;
END IF;
END PROCESS; -- fin de processus

P. Amami Benaissa/ FST Tanger 68


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 16 : Elaboration d’une horloge 24 fois plus lente que l’horloge


principale

Il est a remarquer que s_compt_sortie n’est pas le nom du signal de sortie. Nous
allons créer un fil interne qui sera connecté a cette sortie. Nous avons le droit de lire
et d’écrire dans les fils internes. Par la suite, nous connecterons ce fil interne a la
sortie.
Pour générer l’horloge de sortie, il faut regarder la valeur du compteur et générer ‘1’ la
moitie du temps et générer ‘0’ durant l’autre moitie. Pour cette raison, nous avons :

P. Amami Benaissa/ FST Tanger 69


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 16 : Elaboration d’une horloge 24 fois plus lente que l’horloge


principale
horloge_sortie <= '0' WHEN s_compt_sortie < 12
ELSE
'1';

Le code final sera :

-- Compteur 5bits jusqu'à 23 et recommence le comptage à zéro


--On obtient un signal horloge (horloge_sortie)24 fois plus lent que clk

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY compteur IS
PORT (
clk : IN STD_LOGIC;
compt_sortie : OUT STD_LOGIC_VECTOR(4 DOWNTO 0);
horloge_sortie : OUT STD_LOGIC
);
END compteur;
ARCHITECTURE behaviorale OF compteur IS
SIGNAL s_compt_sortie : STD_LOGIC_VECTOR(4 DOWNTO 0);
BEGIN
PROCESS (clk)
BEGIN
IF clk'EVENT AND clk = '1' THEN
IF s_compt_sortie < 23 THEN
s_compt_sortie <= s_compt_sortie + 1;
ELSE
s_compt_sortie <= "00000";
END IF;
END IF;
END PROCESS;
compt_sortie <= s_compt_sortie;
horloge_sortie <= '0' WHEN s_compt_sortie < 12
ELSE
'1';
END behaviorale;
P. Amami Benaissa/ FST Tanger 70
10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 16 : Elaboration d’une horloge 24 fois plus lente que l’horloge


principale

P. Amami Benaissa/ FST Tanger 71


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 17 : Compteur avec autorisation

Prenons maintenant un deuxième exemple d’un compteur. Imaginons cette fois-ci qu’on
veuille contrôler le compteur avec un signal externe. Nous voulons que le compteur
incrémente seulement quand un bouton est presé.
Quand on relâche le bouton, on aimerait que le compteur arrête.
Pour ce faire, il faut procéder de la même manière que l’exemple précédent. La différence,
cependant, est qu’il y a une condition de plus pour que le compteur fonctionne : « A
chaque front montant d’horloge, SI LE BOUTON EST PRESE, tu peux agir comme un
compteur. » Le process deviendrait donc ceci :

P. Amami Benaissa/ FST Tanger 72


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 17 : Compteur avec autorisation


-- Compteur 5bits jusqu'à 23 et recommence le comptage à zéro
-- avec bouton d’autorisation (entrée)
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
USE ieee.std_logic_arith.all;
ENTITY compteur IS
PORT (
clk : IN STD_LOGIC;
entree : IN STD_LOGIC;
compt_sortie : OUT STD_LOGIC_VECTOR(4 DOWNTO 0)
);
END compteur;
ARCHITECTURE rtl OF compteur IS
SIGNAL s_compt_sortie : STD_LOGIC_VECTOR(4 DOWNTO 0);
BEGIN
PROCESS (clk,entree)
BEGIN
IF clk'EVENT AND clk = '1' THEN
IF entree = '1' THEN
IF s_compt_sortie < 23 THEN
s_compt_sortie <= s_compt_sortie + 1;
ELSE
s_compt_sortie <= "00000";

END IF;
END IF;
END IF;
END PROCESS;
compt_sortie <= s_compt_sortie;
END;
P. Amami Benaissa/ FST Tanger 73
10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 17 : Compteur avec autorisation

P. Amami Benaissa/ FST Tanger 74


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'
Exemple 17 : Compteur avec autorisation
Simulation avec le fichier test bench suivant :
-- Fichier test bebch pour le Compteur 5bits jusqu'à 23 et recommence le
--
-- comptage à zéro
-- avec bouton d'autorisation (entrée)

------------------------------------------------------------------------
------
LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY tbcompteur5bits_avecactivation IS
END tbcompteur5bits_avecactivation;

ARCHITECTURE behavior OF tbcompteur5bits_avecactivation IS


-- Component Declaration for the Unit Under Test (UUT)
COMPONENT compteur
PORT(
clk : IN std_logic;
entree : IN std_logic;
compt_sortie : OUT std_logic_vector(4 downto 0)
);
END COMPONENT;
--Inputs
signal clk : std_logic := '0';
signal entree : std_logic := '0';

--Outputs
signal compt_sortie : std_logic_vector(4 downto 0);

P. Amami Benaissa/ FST Tanger 75


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'
Exemple 17 : Compteur avec autorisation
Simulation avec le fichier test bench suivant :

-- Clock period definitions


constant clk_period : time := 20 ns;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: compteur PORT MAP (
clk => clk,
entree => entree,
compt_sortie => compt_sortie
);
-- Clock process definitions
clk_process :process
begin
clk <= '0';
wait for clk_period/2;
clk <= '1';
wait for clk_period/2;
end process;

entree_test : PROCESS
BEGIN

entree <= '0';


wait for clk_period*10;
entree <= '1';
wait for clk_period*10;

END PROCESS;
END;

P. Amami Benaissa/ FST Tanger 76


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 17 : Compteur avec autorisation

P. Amami Benaissa/ FST Tanger 77


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 18 : Jeu de lumière

-- clignotement de deux diodes de la carte Spartan 3E à des fréquences ----


-- différentes
------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
entity Blink_LED is
port (
CLK : in STD_LOGIC;
LED_0 : out STD_LOGIC;
LED_1 : out STD_LOGIC
);
end Blink_LED;

architecture Behavioral of Blink_LED is


signal Counter2: STD_LOGIC_VECTOR(23 downto 0); -- Blink with 0.5 Hz
signal Counter1: STD_LOGIC_VECTOR(24 downto 0); -- Blink with 1 Hz
signal CLK_1Hz: STD_LOGIC;
signal CLK_demiHz: STD_LOGIC;
begin
Prescaler1 : process( CLK)
begin
if rising_edge(CLK) then
if Counter1 < "1011111010111100001000000" then -- Blink with 0.5 Hz

P. Amami Benaissa/ FST Tanger 78


10. Fonction Attribut : “rising_edge(clk) ” et la fonction “
clk'event and clk='1'

Exemple 18 : Jeu de lumière

Counter1 <= Counter1 +1;


else
CLK_1Hz <= not CLK_1Hz;
Counter1 <=(others => '0');
end if ;
end if;
end process Prescaler1;
Prescaler2 : process( CLK)
begin
if rising_edge(CLK) then
if Counter2 < "101111101011110000100000" then -
- Blink with 0.5 Hz
Counter2 <= Counter2 +1;
else
CLK_demiHz <= not CLK_demiHz;
Counter2 <=(others => '0');
end if ;
end if;
end process Prescaler2;
LED_0 <= CLK_1Hz; NET LED_1 LOC = "E12" | IOSTANDARD=LVTTL;
LED_1 <= CLK_demiHz; NET LED_0 LOC = "F12" | IOSTANDARD=LVTTL;
end Behavioral; NET CLK LOC = "C9" | IOSTANDARD=LVTTL;

P. Amami Benaissa/ FST Tanger 79


11. Machine à état

• Un système électronique est caractérisé par :


▪ Ses entrées : e0; …; ei; … ; en
▪ Son état électrique E
▪ Ses sorties : s0; … ; si; … ; sn
Il existe deux type de systèmes électroniques
▪ Les systèmes combinatoires construits à l’aide de logique combinatoire
▪ Les systèmes séquentiels construits à l’aide de logique séquentielle
• Machines à états
▪ Les combinaisons des entrées conduisent à un nombre fini de
combinaisons de sortie, d’où l’appellation machine à nombre d’états finis
ou Machine à Etats
▪ Vecteur d’entrée : Combinaison des variables d’entrée
▪ Vecteur de sortie : Combinaison des variables de sortie
• Notations :
▪ Entrée : E
▪ Etat Présent : EP
▪ Etat Futur : EF
▪ Sortie : S

P. Amami Benaissa/ FST Tanger 80


11. Machine à état

• Etat : Indicateur de position dans le temps


• Définitions
▪ Registre d’Etat : Composé de bascules permettant de mémoriser les
valeurs des états
▪ Etat Présent : sortie stable du registre d’état à l’instant présent
▪ Etat Futur : état dans lequel se trouvera la machine après une impulsion
d'horloge
• Table de transition : deux parties indiquant le présent et le futur.
▪ E : Entrée à l’instant n
▪ EP : Etat Présent à l’instant n
▪ EF : Etat Suivant à l’instant n + 1
▪ S : Fonction de Sortie à l’instant n + 1
▪ Table de transition

P. Amami Benaissa/ FST Tanger 81


11. Machine à état

La machine à état représente la partie contrôle, c’est à dire le cerveau du système


électronique qui commande la partie opérative.

P. Amami Benaissa/ FST Tanger 82


11. Machine à état

Une machine à états finis est un circuit séquentiel dont les sorties dépendent d’un
état et éventuellement des entrées. La structure logique générale d’un tel circuit est
représentée sur la figure suivante :

Le bloc SM (State Memory) a pour fonction de mémoriser l’état courant de la machine. Il a par
essence un comportement séquentiel synchronisé sur un signal d’horloge.
Le bloc NSL (Next State Logic) a pour fonction de calculer le prochain état en fonction de
l’état courant et des entrées.
Le bloc OL (output Logic) a pour fonction la génération des signaux de sortie en fonction de
l’état courant et éventuellement des entrées.

P. Amami Benaissa/ FST Tanger 83


11. Machine à état

Exemple 19 : Description en VHDL d’un système avec machine à états (4 états)

La description du système se fait par un nombre fini d’états. Ci-dessous la représentation


schématique d’un système à 4 états (M0 à M3), 2 sorties (S1 et S2), 2 entrées X et Y, sans oublier
l’entrée d’horloge qui fait avancer le processus, et celle de remise à zéro qui permet de l’initialiser :

L’état initial est M0. Les 2 sorties sont à 0. Au coup d’horloge on passe inconditionnellement à l’état M1
sauf si la condition Y=1 a été vérifiée, ce qui mène à l’état M3 ou si X=0 a été validé ce qui mène à M2.
De M3 on revient au coup d’horloge à M0. De M1 on passe à M2, et de M2 on passe à M 3...
Dans chaque état on définit les niveaux des sorties.
P. Amami Benaissa/ FST Tanger 84
11. Machine à état

Exemple 19 : Description en VHDL d’un système avec machine à états (4 états)

Traduisons cette machine à état en langage VHD avec :


Une entité
une ARCHITECTURE de description d’état avec 2 PROCESS : Un process asynchrone et un
process synchrone.

Le 1er process (process SYNCHRONE) met à jour la variable d’état en cours ( signal : etat), en la
remplaçant par le contenu d’un autre signal appelé : etat_suiv . Ceci se fait à chaque front d’horloge.
Ce 1er Process gère aussi la remise à zéro (entrée : reset).

Le 2ème process (process ASYNCHRONE) met à jour le signal etat-suiv en lui attribuant la valeur
d’un état de la liste (M0, M1…), en fonction de conditions sur les entrées ou de l’ordre prévu des
états. Il attribue aussi les niveaux des sorties.

P. Amami Benaissa/ FST Tanger 85


11. Machine à état

Exemple 19 : Description en VHDL d’un système avec machine à états (4 états)

PROCESS SYNCHRONE :

Il est appelé aussi « current state process ». Il met à jour la variable d’état et doit
posséder une condition IF sur un front d’horloge. Il peut posséder une RAZ (optionnel).
Il assigne (sans condition) la valeur de l’état suivant (next state variable) à la variable
d’état courante sur un front. Le RAZ si elle existe, assigne une valeur statique à la
variable d’état courante. Ce process ne peut mettre à jour aucun autre signal (sortie par
exemple) ou variable !

P. Amami Benaissa/ FST Tanger 86


11. Machine à état

Exemple 19 : Description en VHDL d’un système avec machine à états (4 états)

PROCESS ASYNCHRONE :

Il est appelé aussi « next state process ». Ne pas oublier de mettre dans sa liste de sensibilité les différents signaux (entrées)
qui seront pris en compte dans les états :
exemple : PROCESS ( etat, x, y).

Ce process est la partie combinatoire de la machine d’état et ne doit pas contenir de front d’horloge. Son architecture doit être
une simple structure de CAS. L’expression testée dans les cas doit être la variable d’état courante.
Les variables d’état courant et next state doivent être du même type (entier, std_logic vector, std_logic...).
Ce process peut seulement assigner des valeurs à la next state variable (etat_suiv), mais ne peut pas lire ses valeurs.
Les variables d’état courant et next state ne peuvent pas être un port de l’entité à laquelle l’architecture appartient et aucune
partie du corps de l’architecture ne peuvent lire ou écrire leurs valeurs sauf les 2 process.

P. Amami Benaissa/ FST Tanger 87


11. Machine à état

Exemple 19 : Description en VHDL d’un système avec machine à états (4 états)

Programme complet

P. Amami Benaissa/ FST Tanger 88


11. Machine à état

Exemple 19 : Description en VHDL d’un système avec machine à états (4 états)

Programme complet

P. Amami Benaissa/ FST Tanger 89


11. Machine à état

Exemple 19 : Description en VHDL d’un système avec machine à états (4 états)

Simulation

P. Amami Benaissa/ FST Tanger 90


Bibliographies

• Extrait de document de Bertrand Le Gal, note du cours ENSEIRB-MATMECA - Bordeaux INP


• Alain Vachoux, Laboratoire de Systèmes Microélectroniques Ecole Polytechnique de Lausane
2003

P. Amami Benaissa/ FST Tanger 91