Poly VHDL 2022-2023 Paysage ST Jerome

VHDL SYNTHETISABLE
Version 2022-2023
St Jérôme Douala
A. Nketsa
VHDL SYNTHETISABLE A. Nketsa 1 14/11/2022

1 – Introduction au langage VHDL
Intérêts et objectifs du langage VHDL
Démarche de développement
Composants cible
Eléments de base et Règles générales du langage
Les mots réservés
Types dans le langage
Les objets manipulés dans le langage (limités aux constantes, signaux et ports)
Les opérateurs et les expressions
Les conditions
2 – Approche générale d’un système en VHDL
Notion de vue externe (Entité) – vue interne (comportement  Architecture)
Déclaration d’une entité
Déclaration et structure d’une architecture
Notions de librairies et notion de package
Librairies standard et Packages standard
Librairies usuelles de QUARTUS II
Structure des fichiers VHDL : Description et Package

3 – Les instructions
Généralités
Groupe d'instructions
4 – Description des instructions du mode concurrent (IMC)
Définition
Notion de blocs
Relation entre blocs
Notion de parallélisme
Les instructions
 Assignation inconditionnelle
 Assignation conditionnelle
 Assignation sélective
 Instanciation de composants (utilisation)
 Process
5 – Notion de composant
 Représentation graphique
 Déclaration de composant
 Syntaxe d'instanciation (utilisation d'un composant)
 Passage de paramètres
 Généricité

6- Instructions du mode séquentiel (IMS)
 Assignation inconditionnelle
 Assignation conditionnelle
 Assignation sélective
7 – Application du VHDL pour la description des systèmes logiques

 Système combinatoire
 Système séquentiel
8 – Description des Systèmes séquentiels simples classiques
- description d’un registre généralisé de n bits actif sur front montant (arazb, asetb, en)
- description d’un compteur généralisé de n bits modulo 2n
(n, arazb, asetb, sraz, en, sload, E(n-1 .. 0))
- description d’un compteur généralisé de n bits modulo m2n
(arazb, asetb, sraz, en, sload, E(n-1 .. 0), Emod(n-1 .. 0) )
- Généralisation : description d’un compteur-décompteur généralisé de n bits modulo 2n à saut
(arazb, asetb, sraz, en, sload, E(n-1 .. 0), upd, saut(n-1 .. 0) )
- Registres à décalage
9 – Systèmes séquentiels complexes
Machine à états
- Codage
- Exemple

10 – Synthèse : Approche des systèmes complexes
Codage
Exemples

Bibliographie
1- Systèmes électroniques numérique 2- VHDL : Introduction à la synthèse
complexes logique
Editions Ellipses Editions Eyrolles par P. Larcher
par A. Nketsa - D. Delauzun
3- Logique programmable –Architecture des 4- VHDL for programmable logic
FPGA et CPLD Editions Addison Wesley par K.
Méthodes de conception – Langage VHDL Skahill
Editions Eyrolles par L. Dutrieux et D.
Demigny
5- VHDL : Méthodologie de design et 6- Initiation au langage VHDL
techniques avancées Editions Masson par M. Aumiaux
Editions Dunod Par T. Schneider
7- VHDL for logic synthesis 8-VHDL : Langage, modélisation, synthèse

Editions Wiley par A. Rushton Editions Presses Polytechniques et
universitaires romandes
par R. Airiau – J.M Bergé – V. Olive – J.
Rouillard

1- Introduction au langage VHDL
1.1 Intérêts et objectifs du langage
VHDL = (VHSIC Hardware Description Language)

VHSIC = (Very High Speed Integrated Circuit)
VHDL raccourci = Langage de description matérielle de systèmes électroniques (numériques)
Langage complet
Même langage pour toutes les étapes de la conception à la mise en œuvre des systèmes numériques.
Spécification :
Etape de description du système avec ses objectifs et ses contraintes du système
Modélisation
Etape de représentation du fonctionnement présumé du système.
Simulation
Etude des cas réels du système modélisé
Synthèse
Etape de traduction du modèle en équations logiques et de transfert dans un circuit logique programmable

Langage indépendant
- du constructeur de circuits logiques programmables (CLP)
- de l’architecture des CLP (PLD – CPLD – FPGA – ASIC)
- de la technologie (TTL, CMOS, LVCMOS, etc..)
Langage puissant et flexible : Plusieurs niveaux de description

Par équations aussi appelée flot de données
Comportementale aussi appelée algorithmique car les instructions utilisées sont semblables à celles des langages évolués en
Informatique.
Structurelle connexion de composants
Hiérarchisation – modularité
Composant - librairies – packages

Langage moderne et évolutif
Lisibilité
Du fait des instructions en langage évolué, la lecture de la description est aisée.
Possibilité d’approche Top – Down
Elle consiste à partir de la fonction et à décomposer celle-ci en sous-fonctions. Cette approche nécessite souvent l’expérience du
concepteur pour ne pas décrire plusieurs fois des fonctions similaires. Elle comporte obligatoirement des aller-retours entre les
différentes phases que le concepteur s’est fixé.
Cette approche, même si elle n’est pas facile, est celle qui permet de proposer plusieurs solutions sans a priori. On peut les évaluer pour
choisir celle qui convient le mieux aux critères donnés.
Possibilité d’approche Bottom-Up
Elle consiste à partir des composants existants pour construire le système. Cette approche est plus abordable que la précédente mais
elle conduit souvent à une solution figée difficile à comparer avec d’autres. Elle a cependant le mérite de conduire à une démarche
incrémentale généralement fonctionnelle.
Possibilité d’approcher mixte
Il est rare de traiter un problème soit par le top-down seul ou le bottom-up seul. On doit généralement faire des allers-retours entre les
deux démarches. D’une part parce qu’une entreprise souhaite le plus souvent rentabiliser son savoir-faire et d’autre part parce qu’il ne
faut pas se priver de nouvelles alternatives.
Réutilisation des composants
Le VHDL permet par la description structurelle d’utiliser des composants pour en créer d’autres.
Création de nouveaux composants
- par encapsulation (regroupement)
- par raffinement successif (poupées russes)

Langage portable
Compatibilité entre constructeur ! ! !
Passage CPLD ou FPGA vers ASIC
Langage ouvert
Définition de nouvelles fonctions
Constructeur
Utilisateur

1-2 Démarche de développement
Définition du cahier des charges de l’application Spécification
Description de l’application en VHDL (choix d’une méthodologie) Modélisation
Simulation fonctionnelle Evaluation fonctionnelle
Synthèse – optimisation (fit - placement et routage) Réalisation

(Equations + cible)
Simulation post placement (simulation temporelle) Evaluation temporelle
Programmation du composant (transfert des points de connexion) Transfert sur la cible
Test sur site Evaluation sur la cible

1-3 Composants cible
CPLD
FPGA
ASIC

1.4 Eléments de base du langage VHDL (Règles générales)
Notation
a) Pas de distinction majuscule-minuscule
Sauf pour les constantes entre apostrophes (‘’) et les chaînes entre guillemets (" ")
b) Littéraux
Les littéraux sont des valeurs attribuables à différents objets (éléments du langage).
* entiers décimaux relatifs (integer):
Notation habituelle, mais on peut y inclure '_' (souligné) comme séparateur
Exemples : 1254
* caractères (constant):
Un seul caractère se met entre apostrophes : 'A' , 'f ' , '1'
Dans ce cas les majuscules et minuscules sont différenciées.
Exemples : 'a' et 'A' sont différents
* chaîne de caractères elle se met entre guillemets " "

Exemple
"GEII"
Le mot réservé & permet la concaténation des chaînes

Exemples
"ABC" & "CDEF" donne "ABCCDEF"

* Bit remplacé par
std_logic :
‘U' valeur non initialisée
'X' niveau inconnu forçage fort
'0' niveau 0 forçage fort
‘Z’ haute impédance
‘W’ niveau inconnu forçage faible
‘L’ niveau 0 forçage faible
’H’ niveau 1 forçage faible
’-‘ quelconque (non défini)
std_logic_vector :
Tableau ou chaîne de std_logic
Notation chaîne de caractères "10100"
Par défaut la base est binaire, mais on peut utiliser la notation
- Octale O"127"
- Hexadécimale X"01AC"
c) une instruction peut s'étendre sur plusieurs lignes tant que le saut de ligne ne s'effectue pas au milieu d'un identificateur
d) toute instruction se termine par ;
e) un commentaire commence par -- (moins, moins) et tient sur une ligne
f) Others primitive de compactage d’écriture

g) les identificateurs = noms
Un identificateur :
 est une suite de caractères alphabétiques, des chiffres, et '_' souligné
 le premier caractère doit être une lettre
 '_' ne doit pas terminer le nom, n'y figurer 2 fois consécutives
 ne doit pas excéder une ligne
 ne doit pas être un nom réservé

1.5 Mots - réservés
Ces mots-clés ne peuvent être utilisés comme identificateurs, même si beaucoup d’entre eux n’ont pas d’utilité en synthèse logique.
Les mots en gras sont ceux que nous allons utiliser très souvent.
abs access after alias
all and architecture array
asset attributs begin block
body buffer bus case
component configuration constant disconnect
downto else elsif end
entity exit file for
function generate generic group
guarded if impurs in
inertial inout is label
library linkage literal loop
map mod nand new
next nor not null
of on open or
others out package port
postponed procedure process purs
range record register reject
rem report return rol
ror select severity signal
shared sla sll sra
srl subtype then to
transport type unaffected units
until use variable wait
when while with xnor
xor

1.6- Types du langage VHDL
Le VHDL est un langage typé.
Tous les éléments utilisables doivent préalablement être indiqués (on dit aussi déclarés)
Volontairement, nous ne traiterons que des types à utiliser en Travaux pratiques
Types utilisés en TP
Std_logic : rappel des valeurs possibles :
‘U' valeur non initialisée
'X' niveau inconnu forçage fort
‘Z’ haute impédance
‘W’ niveau inconnu forçage faible
‘L’ niveau 0 forçage faible
’H’ niveau 1 forçage faible
’-‘ quelconque (non défini)
Std_logic_vector tableau de std_logic
(fin downto debut)
Std_logic_vector (fin downto debut)
Natural sous type de integer

Natural est le type des entiers positifs ou nul
Type utilisateur (Type énuméré)

Type nom_type is (liste des éléments du type séparés par des virgules);
Nous reviendrons sur le type utilisateur pour donner des noms aux états d’une machine à états.

1.7 Objets du langage VHDL et Déclaration
- les constantes : une constante est une valeur fixe à laquelle on donne un nom.
Déclaration Constant nom_constante : type_prédéclaré : = valeur ;
Exemple :
Constant zéro : std_logic_vector (0 to 1) : = "00" ;
huit : std_logic_vector (3 downto 0) : = "1--0" ;
XZZ : std_logic_vector (7 downto 0) : = "00000000";
: = (others  '0') ;
others permet de compacter l'écriture
- les signaux :
C'est l'objet le plus important. Il sert à établir les liens entre les blocs. Il peut représenter aussi bien un fil qu'un ensemble de fils ou tout
autre élément complexe.
Déclaration Signal nom_signal : type ;
Exemple
Signal bus_local : std_logic_vector (7 downto 0) ;

Déclaration d’un tableau de std_logic
Déclaration signal Nom_tableau : std_logic_vector(fin downto debut) ;
Indice : fin Indice : debut
Désignation des éléments du tableau à une dimension
Désignation de tout le tableau : Nom_tableau
Désignation d’un élément du tableau nom_tableau(indice)
Désignation de plusieurs éléments contigus d’un tableau nom_tableau(indice_fin downto indice_debut)
Exemple :
signal Nom_tableau : std_logic_vector(7 downto 0)
bit7 bit5 bit4 bit3 bit2 bit1 bit0
nom_tableau(5 downto 3) nom_tableau(0)

- les ports :
Les ports sont des signaux avec une direction.
Déclaration d'un port

Port (nom_port : direction type);
Direction peut être : in pour désigner la (ou les) entrée(s)

out pour désigner la (ou les) sortie(s)
inout pour designer la (ou les) entrée(s)-sortie(s)
Exemple
entree in
out sortie
inout entree_sortie
port ( entree : in std_logic;

sortie : out std_logic;
entree_sortie : inout std_logic
);

- les variables :
Elles ne seront pas utilisées en TP donc elles sont indiquées à titre d’information

1.8 Opérateurs et expressions
a) Les Opérateurs
Nous avons restreint la table aux types utilisés en TP
CATEGORIE SIGNIFICATION TYPE OPERANDES

entrées Résultat
Opérateurs logiques
and et booléen Booléen
nand non-et
or ou std_logic Std_logic
nor non-ou
xor ou exclusif std_logic_vector Std_logic_vector
xnor égal (non ou-exclusif)
not non
Opérateurs relationnels =
Opérateurs de comparaison
=
/=
Std_logic
< tout type
Natural ou std_logic_vector par booléen
<= scalaire
extension
>
>=

Opérateurs arithmétiques
+ + unaire, ou addition Std_logic Std_logic
- - unaire, ou soustraction
* multiplication Natural Natural
/ division entière
abs valeur absolue std_logic_vector std_logic_vector
** Exponentiation par surchage de l’opérateur
mod modulo
Natural Natural
rem reste
Décalages
sll logique gauche Natural Natural
srl logique droit
rol circulaire gauche std_logic_vector std_logic_vector
ror circulaire droit par surchage de l’opérateur par surchage de l’opérateur
Autres
concaténation
&
Remarques

b) Les expressions
b-1) Définition
Une expression est une combinaison cohérente d’opérateurs et d’opérandes
b-2) Types d’expression

3 types d’expression
- expression booléenne
- expression logique
- expression arithmétique
b-2-1) Expression booléenne
Définition
C'est une expression dont l'évaluation donne un résultat vrai ou faux.
Formes générales
2 formes :
a) expression simple = résultat d'une comparaison
b) composée = résultat d'une fonction logique de booléens

a) expression simple = résultat d'une comparaison
booléen : std_logic operateur_comparaison std_logic;
booléen : std_logic_vector operateur_comparaison std_logic_vector

std_logic_vector operateur_comparaison natural
booléen : natural operateur_comparaison natural

natural operateur_comparaison std_logic_vector
Exemples :
signal busd : std_logic_vector(7 downto 0);
busd >= 200 Comparaison de busd(7..0) à 200
busd(4 downto 1) = 5 comparaison du mot de 4bits à 5
busd(5) = '0' comparaison du bit 5 de busd à 0

b) composée = résultat d'une fonction logique de booléens
Pour cela, on utilise les opérateurs logiques appliqués à des booléens
booléen : booléen opérateur_logique booléen;
opérateur logique unaire = not
opérateur logique = and, or, nand, nor, xor, et xnor
Exemples
signal busd : std_logic_vector(7 downto 0);
( (busd >= 200) and (busd(4 downto 1) = 5) ) xor (busd(5) = '0' ) )

b-2-2) Expression logique
Définition
C'est une expression qui se calcule bit à bit sans report en utilisant les opérateurs logiques et qui produit un résultat du type de sortie.
Exemple ci-contre de calcul bit à bit sans report
a3 a2 a1 a0
Soit A et B deux std_logic_vector(3 downto 0) A
On veut calculer A and B
B b3 b2 b1 b0
A and B a3 a2 a1 a0
and and and and
b3 b2 b1 b0
Formes générales
a) Std_logic : std_logic opérateur_logique std_logic
b) Std_logic_vector : std_logic_vector opérateur_logique std_logic_vector commutatif

std_logic_vector opérateur_logique natural commutatif
c) Natural : natural opérateur_logique natural commutatif

natural opérateur_logique std_logic_vector commutatif

b-2-3 Expression arithmétique
Définition
C'est une expression qui se calcule en utilisant les opérateurs arithmétiques et qui produit un résultat du type de sortie.
Les opérateurs arithmétiques couramment utilisés sont l'addition et la soustraction.
Formes générales
a) Std_logic : std_logic opérateur_arithmétique std_logic
b) Std_logic_vector : std_logic_vector opérateur_arithmétique std_logic_vector

std_logic_vector opérateur_arithmétique natural
c) Natural : natural opérateur_arithmétique natural

natural opérateur_arithmétique std_logic_vector
Exemple
Habituel
1.9 Les conditions

Définition
Une condition est une expression booléenne.

2 - Approche générale d’un système en VHDL
2-1 Points de vue d'un système en VHDL
Tout système peut se décomposer en deux parties :
- la partie externe appelée aussi vue externe
- la partie interne appelée aussi vue interne
Vue externe
Définition
C'est la description des entrées-sorties du système en indiquant la direction de chaque élélent
Représentations du système par la vue externe
a) Système à construire
Les noms des ports sont des signaux externe que le

système utilise
entree sortie
Nom_systeme

b) Système existant
Dans ce cas :
- le système est considéré comme un composant avec
des broches externes.
- les noms de ces broches sont associés à ce composant
entree
On dit aussi que le système est encapsulé. sortie
Donc
- on a accès à ces broches Nom_systeme
- la fonction est implicite

Vue externe sans paramètre = Déclaration entité sans paramètres
Entity nom_entité is
Port ( nom_signal1 : direction type;
In pour entrée
Out pour sortie
Inout pour entrée-sortie
Nom_signalx : direction type

pas de ; pour la dernière déclaration
);
end nom_entité;
Nom_entité
signal_sortie
in out
Signal_entree_sortie
inout

Vue externe avec paramètre = Déclaration entité avec paramètres
Generic(nom_paramètre : type_paramètre := valeur_défaut ;
Nom_paramètre1 : type := valeur1_defaut);
Port ( nom_signal1 : direction type;
In pour entrée std_logic
Out pour sortie std_logic_vector(fin downto deb)
Inout pour entrée-sortie natural ou integer ou positive
Nom_signalx : direction type

pas de ; pour la dernière déclaration
);
end nom_entité;
Nom_entité
signal_entree signal_sortie
in out
Signal_entree_sortie
gen(n:=x) inout

Exemple de déclaration d’entité
Exemple simple sans paramètres
Déclaration Schéma vue externe
Entity cptg is arazb

cptg
Port (arazb, ck : in std_logic: ck
Sraz, sload, en, ud : in std_logic; sraz
E : in std_logic_vector(3 downto 0): sload Q[3..0]
Q : out std_logic_vector(3 downto 0): en
Find, finc : out std_logic ud finc
); E[3..0]
find
end entity; ou end cptg;
Généricité : avec paramètres

Exemple simple avec paramètres
Déclaration Schéma vue externe
Entity cptgn is arazb

Generic(n: natural := 3);
Port (arazb, ck : in std_logic: ck cptgn
Sraz, sload, en, ud : in std_logic; sraz
E : in std_logic_vector(n-1 downto 0): sload Q[]
Q : out std_logic_vector(n-1 downto 0):
Find, finc : out std_logic en
); ud finc
end entity; ou end cptgn; E[]
gen(n:=3) find

Vue interne
Définition
La vue interne correspond à la description du comportement du système en fonction de la vie externe associée.
Ecriture en VHDL
Architecture
Déclaration de l’architecture et structure générale
Architecture nom_architecture of nom_entité is

-- déclaration nouveaux types
-- déclaration composant
-- déclaration des constantes
-- déclaration signaux
Begin
-- Description du comportement
-- instructions du mode concurrent
End nom_architecture; ou end architecture:

Notion de librairies - Notion de packages
Définition librairies
Une librairie est une répertoire (dossier) où on regroupe les packages
Définition Package
Un package est un fichier où on regroupe :
- les déclarations des nouveaux types
- les déclarations de composants pour les rendre utilisables en tant que tel.
- les définitions des fonctions et des procédures que nous ne traiterons pas
Schéma de principe
Librairie
Package p1
Package pn

Librairies usuelles
ieee librairie standard
Work librairie utilisateur par défaut
Les packages de la librairie ieee
std_logic_1164 package standard de base
Std_logic_unsigned pour les calculs arithmétiques sur les std_logic_vector considérés comme des nombres entiers non-signés
Std_logic_arith pour les calculs sur les entiers
Std_logic_signed pour les calculs arithmétiques sur les std_logic_vector considérés comme signés
Invocation de la librairie
Library nom_librairie ;
Utilisation des packages et composants
Use nom_librarie.nom_package.nom_composant;
Ou
Use nom_librarie.nom_package.all; --- pour tous les éléments du package

Déclaration entité avec librairies
Library nom_librairie ; Library nom_librairie ;
Use nom_librairie.nom_package.all ; Use nom_librairie.nom_package.all ;
-- Library work;
-- Use work.nom_package_utilisateur.all;
Entity nom_entité is Entity nom_entité is

Generic (
Port (
);
Port (
); );
end nom_entité; end nom_entité;

Les Fichiers en VHDL
- 2 types de fichiers
Le fichier de description des systèmes
Le fichier de package

Structure d’un fichier VHDL de description d'un système
-- Invocation des librairies
Library ieee;
-- utilisation de packages stockés dans la librairie ieee
Use ieee.std_logic_1164.all;
-- Invocation d’autres librairies par exemple work
-- utilisation de packages stockés dans la librairie work
Port (
);
End nom_entité;
Architecture nom_architecture of nom_entité is
-- déclaration des composants

-- déclaration de nouveaux types
-- déclaration de constantes
-- déclaration de signaux
Begin
-- Description du comportement
-- instructions, appels de procédures et fonctions
End nom_architecture;

Structure d’un fichier VHDL de description d'un package
-- Invocation des librairies
Library ieee;
-- utilisation de packages stockés dans la librairie ieee
Use ieee.std_logic_1164.all;
Package nom_package is
Component nom_composant1 is
End component;
-- autres composants
Component nom_composantn is
End component;
End nom_package;
Nous n'utiliserons pas cette année le corps du package donc nous ne le présentons pas.

3 - LES INSTRUCTIONS
3-1 Généralités
- Toutes les instructions se terminent par ;
- une instruction peut s'étaler sur plusieurs lignes
3-2 Groupe d’instructions :

- Instructions du mode concurrent (IMC)
- Instructions du mode séquentiel (IMS)

3-3 Description des instructions en mode concurrent (IMC)
a) Définition du mode concurrent

Le mode concurrent est un mode pour lequel :
- les instructions sont des blocs indépendants s'exécutant de façon indépendante
- il n'y a pas d'ordre dans leur écriture
b) Notion de bloc et Relation entre blocs

Chaque instruction constitue un bloc indépendant qui s’exécute indépendamment des autres.
Les blocs sont éventuellement reliés entre eux par des signaux.
c) Notion de parallélisme
Nous allons voir sur un exemple que les blocs étant autonomes, l'écriture en séquence n'empêche pas le fonctionnement en
parallèle de ces blocs.
Exemple
On veut traduire le schéma suivant en VHDL selon 3 versions :
A
X
Y
B
Y = (A ET B) OU C
Version1 Version 2 Version 3
Y <= (A and B ) or C; X <= A and B; Y <= X or C;
Y <= X or C; X <= A and B;
Les 3 versions produisent le même résultat.

Conclusion importante :
- Pas d'ordre dans le déroulement des instructions du mode concurrent écrites en séquence.
d) Liste des instructions du mode concurrent traitées
(Nous avons volontairement limité cette liste)
- Assignation inconditionnelle
- Assignation conditionnelle (when else)
- Assignation sélective (with select)
- Instanciation de composant
- Process (basculement dans le mode séquentiel)

e) Syntaxe et description des instructions du mode concurrent
e-1) Assignation inconditionnelle
Syntaxe
nom_signal <= expression;
Le signal et l'expression doivent être du même type ou compatible

Exemple
Y <= (A and B ) or C;

e-2) Assignation conditionnelle (when else)
Syntaxe
nom_signal <= expression1 when condition1 else
expression2 when condition2 else
expression_defaut;
1- Remarques et conditions d'utilisation

a) Compréhension
Cette instruction décrit un genre de multiplexeur avec priorité
Si condition1 est vraie alors nom_signal prend la valeur de expression1
Si aucune condition n'est vraie alors nom_signal prend la valeur de expression_défaut
b) Conditioni
Les conditioni sont des expressions booléennes
c) Notion de priorité
Il y a une priorité entre les conditions.
L'ordre de priorité est celui d'écriture des conditions.
La première (ici condition1) est plus prioritaire que les autres zt ainsi de suite.
Les conditioni doivent être exclusives deux par deux
C'est-à-dire conditioni ET conditionj est faux avec i  j
ou plus simplement conditioni ET conditionj = 0

d) interprétation pour la synthèse
La mise en œuvre de cette instruction coûte chère en nombre de portes logiques pour prendre en compte la gestion des priorité
Exemple
Instruction Equation générée
S <= A when B='1' else Priorité de B=1
C when D='0' else Priorité de B=1 et D=0
E; S= A B
+ C . /B . /D
+ E . /B . D

e) Omission du dernier else (Mémoire implicite de structure non fatale)
Si on omet le dernier else alors on crée une mémoire implicite non fatale
Cela signifie que au lieu de produire une fonction combinatoire, cette instruction produit une fonction séquentielle asynchrone.
Les fonctions séquentielles asynchrones ne sont pas conseillées en VHDL
Exemple
sans omission avec omission
Instruction S <= A when B='1' else S <= A when B='1' ;
C;
Logigramme produit A A
B S B S
C
Mémoire implicite
Non fatale
Fonction combinatoire Fonction séquentielle asynchrone
Remarque :
La mémoire implicite de strycture est valable uniquement lorsque B = 0.
C'est pour cela que la mémoire est non fatale.
f) Exemples
f=A.B devient
f <= A when B = '1' else
'0';
e-3) Assignation sélective (with select)
Syntaxe
with choix select
nom_signal <= expression1 when choix1,
expression2 when choix2,
expression_defaut when others;
1- Remarques et conditions d'utilisation

a) Compréhension
Cette instruction décrit un vrai multiplexeur, c'est-à-dire une fonction d'aiguillage
Si cboix vaut choix1 alors nom_signal prend la valeur de expression1
Si aucun choixi ne vaut choix e alors nom_signal prend la valeur de expression_défaut
b) Choixi
Les choixi sont les valeurs possibles de choix
Puisque les choixi sont les valeurs possibles de choix alors il n'y a pas de priorité entre les choixi

Cette instruction décrit un multiplexeur. Elle coûte moins de portes logiques when else.
Tant que cela est possible, il faut la préférer à when else.

e) Omission de when others (mémoire implicite de structure fatale)
Si on omet la ligne when others alors on crée une mémoire implicite fatale
Dès que cette mémoire est obtenue, la sortie ne change plus quel que soit les entrées
Exemple
Instruction With B select With B select
S <= A when '1', -- virgule S <= A when B='1' ;
C when others;
B S B S
C
Solution avec on mux2v1
Mémoire implicite
Mux2V1
fatale
A I1
S
Y
C I0
S
B
Remarque :
La mémoire implicite de structure est valable dès que S =1. Er S reste à 1
C'est pour cela que la mémoire est fatale.
e-4 Notion de composant (Instanciation = utilisation particulière)
Généralités
Un composant est constitué de deux parties:
- la vue externe (décrite par l'entité)
- le comportement (décrit dans l'architecture) (encapsulé)
Un composant :
- doit être construit. Pour cela, il est décrit comme tout système en VHDL.avec le couple entité-architecture
- peut être utilisé. Pour cela, on a besoin uniquement de la vue externe, le comportement étant sous_entendu (on dit aussi encapsulé)
Pour être utilisé, un composant doit être déclaré,

- soit dans la zone entre ARCHITECTURE et BEGIN de l'architecture qui veut l'utiliser,
- soit dans un PACKAGE.
Représentation graphique
Règles
Composant existant : Composant à créer :
Nom_composant
broche_in broche_out
signal_out
signal_in
broche_inout
Nom_composant Signal_inout
broche_in broche_out
gen(n:=x) broche_inout
Nom_composant

Utilisation d’un composant (on dit aussi instantiation)
Version sans paramètre générique

Etiquette_obligatoire_et_unique : nom_composant
port map (passage de paramètres);
Version avec paramètres génériques (version 1)

Etiquette_obligatoire_et_unique : nom_composant
generic map (nom_paramètre => paramètre)
port map (passage de paramètres);

Passage de paramètres
- Passage de paramètres par nom. Pas d'ordre des paramètres
Passage de paramètres par nom :

L’ordre de déclaration des paramètres formels n’est pas respecté (Méthode conseillée) : Conservation du nom du paramètre
formel
etiquette : nom_du_composant
generic map ( nom_paramètre => valeur_effective)
PORT MAP ( nom_broche_in => signal_utilisé_i,
nom_broche_out => signal_utilisé_o,
…
nom_broche_inout => signal_utilisé_io
);
Le paramètre formel est le nom de la broche du composant
Le paramètre effectif est le nom du signal à connecter à la broche
Relations avec la connexion de composant sur un schéma électronique
Nom_utilisation Nom_utilisation
signal_out signal_out
signal_in signal_in
broche_in broche_out broche_in broche_out
Signal_inout Signal_inout
y
broche_inout gen(n:=x) broche_inout
Nom_composant Nom_composant

Remarques : Broches non connectées
- Lorsque le paramètre effectif est une constante en entrée,
On peut :
- soit passer la constante comme paramètre
- soit déclarer un signal du même type auquel on assigne la constante puis on passe le signal comme paramètre effectif.
- Lorsqu’un paramètre en sortie ne doit pas être utilisé,

On peut :
- soit le connecter à open,
- soit déclarer un signal du même type auquel on assigne la constante puis on passe le signal comme paramètre effectif

Déclaration de composant dans une architecture ou dans un package
COMPONENT nom_du_composant IS
PORT ( signal : direction type ;
signal : direction type ;
…
signal : direction type
);
END COMPONENT ;
Description du composant
-- librairie et utilisation
ENTITY nom_du_composant IS
PORT ( signal, [signal], … : direction type ;
signal, [signal], … : direction type ;
…
signal, [signal], … : direction type
);
END nom_du_composant ;
ARCHITECTURE nom_architecture_du_composant OF nom_du_composant IS

[déclaration des composants]
[déclaration des types]
[déclaration des signaux]
…
BEGIN
"zone de description du composant"
END nom_architecture_du_composant ;
PACKAGES ET LIBRAIRIE
PACKAGE nom_du_package IS
"Déclarations de composants"
"Déclarations de fonctions"
"Descriptions de types"
END nom_du_package ;
Un "package" est toujours associé à une librairie. La visibilité de cette librairie se fait par l'instruction LIBRARY. La visibilité d'un
"package" par l'instruction USE.
LIBRARY nom_de_la_librairie ;
USE nom_de_la_librairie.nom_du_package.ALL ;

Exemple d’utilisation de composant
Connecter l’afficheur 7 segment à une platine de test
Composant deco_7seg Platine avec connexion
platine
en
u0_deco
ptd
segment(7..0) Inter(5) en
Inter(4) ptd seg(7 ..0)
E(3..0)
segment(7..0)
deco_7seg
Inter(3 ..0) E(3..0)
deco_7seg
u0_deco : deco7seg
port map ( en => inter(5), ptd => unter(4),
e => inter(3 downto 0), segment => seg
);

Généricité (exemple d’instanciation)
Composant Système
platine
arazb
ck cptgn U0_cptgn
sraz arazn arazb
sload Q[] ck ck cptgn
Q(3 downto 0)
en Inter(7) sraz
ud finc Inter(6) sload Q[]
E[] Inter(5) en
opên
gen(n:=3) find Inter(4) ud finc
Inter(3 downto 0) E[]
open
4 gen(n:=3) find
u0_cptgn : cptgn
generic map ( n => 4)
port map ( ck => ck, arazb =>> aeazb,
sraz => inter(7), sload => inter(6),
en => inter(5), ud => inter(4),
E => inter(3 downto 0),
Q => Q, find => open, finc => open
);

6- INSTRUCTIONS DU MODE SEQUENTIEL
1- Définition du mode séquentiel
Dans le mode séquentiel, les instructions tiennent compte des valeurs précédemment assignées aux signaux.
Conséquence, c'est la dernière assignation qui est prise en compte pour le signal considéré.
2- Passage dans le mode séquentiel

Le passage dans le mode séquentiel se fait en exécutant l'instruction du mode concurrent process.
* Un process est un groupe délimité d'instructions, doté de 5 caractéristiques essentielles :

a) Le process s’exécute de bout en bout car c'est une instruction du mode concurrent (donc indivisible)
b) Le process s'exécute à chaque changement d'un des signaux auxquels il est déclaré sensible (déclenchable).
 définition d'une liste de déclenchement (ou de sensibilité) du process
c) Dans un process, les instructions successives s'exécutent séquentiellement.
d) Un signal peut être modifié plusieurs fois dans le process, mais c'est la dernière modification qui est prise en compte.
e) Les modifications apportées aux signaux par les instructions prennent effet à la fin du process.
Par conséquent,
- la mise à jour des signaux se fait uniquement à la fin du process
- seule la dernière modification est vue à l’extérieur du process.
- les modifications intermédiaires sont ignorées.

3- Structure d'un process
nom_process (optionnel) : process (liste des événements de déclenchement)
-- déclaration éventuelle des variables
begin
-- instructions du mode séquentiel
end process nom_process ;
Définition de la liste de déclenchement

La liste de déclenchement est la liste des entrées dont tout changement permet de lancer le déroulement du process.
Cas pratique de la liste de déclenchement

Dans la pratique :
- si la fonction est combinatoire : on met toutes les entrées dans la liste
- si la fonction est séquentielle synchrone, on met dans la liste :
o les entrées asynchrones
o l'entrée d'horloge (on ne peut avoir qu'une seule horloge par process)

4- Liste des instructions traitées
- Assignation inconditionnelle
- Assignation conditionnelle (if then else end if)
(if elsif then else end if)
- Assignation sélective (case end case)

5- Description des Instructions
1- Assignation inconditionnelle
* un signal nom_signal <= expression ;
* une variable nom_variable : = expression ; -- pour information

2- Assignation conditionnelle
Formulation simple Formulation complète
If condition1 then If condition1 then

suite_d'instructions1 (IMS) ; suite_d instructions1 (IMS) ;
else elsif condition2 then
suite_d'instructions2(IMS) ; suite_d ‘instructions2 (IMS) ;
end if ; else
suite_d’instructions3 (IMS) ;
end if ;
1- Remarques et conditions d'utilisation (idem que pour when else)
a) Pendant de when else dans le mode concurrent
b) Compréhension
Cette instruction décrit un genre de multiplexeur avec priorité
Si condition1 est vraie alors exécution de suite_instructions1
Si aucune condition n'est vraie alors exécution de suite_instructions de la clause else
c) Conditioni
Les conditioni sont des expressions booléennes

Il y a une priorité entre les conditions.
L'ordre de priorité est celui d'écriture des conditions.
La première (ici condition1) est plus prioritaire que les autres zt ainsi de suite.
Les conditioni doivent être exclusives deux par deux
C'est-à-dire conditioni ET conditionj est faux avec i  j
ou plus simplement conditioni ET conditionj = 0

La mise en œuvre de cette instruction coûte chère en nombre de portes logiques pour prendre en compte la gestion des priorité
Exemple
Instruction Equation générée
If B='1' then S <= A; Priorité de B=1
elsif D='0' then S <= C; Priorité de B=1 et D=0
else S <= E; S= A B
end if; + C . /B . /D
+ E . /B . D

e) Omission de else (Mémoire implicite de structure non fatale)
Si on omet le dernier else alors on crée une mémoire implicite non fatale
Les fonctions séquentielles asynchrones ne sont pas conseillées en VHDL
Exemple
Instruction If B='1' then S <= A; If B='1' then S <= A;
else S <= C; end if;
end if;
B S B S
C
Mémoire implicite
Non fatale
Remarque :
La mémoire implicite de structure est valable uniquement lorsque B = 0.
C'est pour cela que la mémoire est non fatale.
f) Comparaison avec when else

If then permet de faire plus d'opérations que when else

3- Assignation sélective
case choix IS
when choix1  suite_d’instructions1;
.
when choixi  suite_d’instructionsi;
.
when others  suite_d’instructionsn;
end case;
Remarques et conditions d'utilisation (idem que pour with select)
a) Pendant de with select dans le mode concurrent
b) Compréhension
Cette instruction décrit un vrai multiplexeur, c'est-à-dire une fonction d'aiguillage
Si cboix vaut choix1 alors exécution de suite_instructions1
Si aucun choixi ne vaut choix e alors exécution de suite_instrucn
c) Choixi
Les choixi sont les valeurs possibles de choix
d) Notion de priorité
Puisque les choixi sont les valeurs possibles de choix alors il n'y a pas de priorité entre les choixi
e) interprétation pour la synthèse

Cette instruction décrit un multiplexeur. Elle coûte moins de portes logiques when else.
Tant que cela est possible, il faut la préférer à if then.

f) Omission de when others (mémoire implicite de structure fatale)
Si on omet la ligne when others alors on crée une mémoire implicite fatale
Dès que cette mémoire est obtenue, la sortie ne change plus quel que soit les entrées
Exemple
Instruction case B is case B is
when '1' => S <= A; when '1' => S <= A;
when others => S <= C;
end case; end case;
B S B S
C
Solution avec on mux2v1
Mux2V1 Mémoire implicite
A I1 fatale
S
Y
C I0
S

Remarque : La mémoire implicite de structure est valable dès que S =1. Er S reste à 1
C'est pour cela que la mémoire est fatale.
g) Comparaison avec with select
Case is permet de faire plus d'opérations que with select
4- Imbrications des instructions du mode séquentiel
On peut imbriquer les instructions du mode séquentiel
Exemple
If cond1 then
Case choix is
When choix1 => if cond2 then
End if;
When choix2 =>
suite de case
When oyhers =>
End case;
Else
autres instructions
End if;

5- Mémoire implicite de construction dans les instructions if then et case is
Définition
La mémoire implicite de construction apparaît sur un signal qui n'a pas été décrit dans toutes les branches des instructions if
then et cas is
signal incomplètement décrit

if B='1' then if B='1' then
S1 <= A; S1 <= A;
S2 <= C; S2 <= C;
else else
S1 <= '0'; S1 <= '0';
S2 <= '0';
end if; end if;
S1 et S2 sont décrites dans toutes les branches de S1 est décrite dans toutes les branches de l'instruction if
l'instruction if then then
Donc S1 est combinatoires
Donc S1 et S2 sont combinatoires, c'est-à-dire sans
mémoire S2 n'est pas décrite dans toutes les branches de
l'instruction if then
Donc S2 présente une mémoire omplicite de
construction

Evitement de la mémoire implicite de construction
Deux solutions
a) Décrire tout signal dans chaque branche de if then et/ou Case is
b) Exploiter le fait que dans le mode séquentiel, c'est la dernière assignation du signal qui est prise en compte à la sortie du
process. Pour cela, il suffit de définir une valeur initiale avant l'utilisation des instructions concernées
Solution a) Soluyion b)
S2 <= '0'; -- valeur initiale de S3
if B='1' then if B='1' then

S1 <= A; S1 <= A;
S2 <= C; S2 <= C;
else else
S1 <= '0'; S1 <= '0';
S2 <= '0';
end if; end if;

Résumé des instructions traitées
ARCHITECTURE nom_architecture of nom entité IS
Déclaration éventuelle de composants
Déclaration éventuelle de nouveaux types
Déclaration des signaux (les signaux assurent le lien entre les blocs)
Begin -- début de la partie description
-- Bloc instructions concurrentes

 assignation inconditionnelle
nom_signal <= expression;
 assignation conditionnelle
nom_signal <= expression1 when condition1 else
expression2 when condition2 else
expression_par_defaut;
 assignation sélective
with choix select
nom_signal <= expression1 when choix1,
expression2 when choix2,
expression_par defaut when others ;
 generate
 Process (Introduction aux instructions du mode séquentiel)
 instanciation de composant

-- Bloc instanciation (utilisation) des composants
nom_instance : nom_composant port map ( passage de paramètres);
Process (liste d'événements de déclenchement du process)
Begin
Bloc Instructions séquentielles (style algorithme)
Assignation inconditionnelle
if then else end if;
case end case;
End process ;
End nom_architecture;

7- Application du VHDL à la synthèse des systèmes logiques
A- Système combinatoire
Un système combinatoire est un système sans mémoire. C'est-à-dire que la même combinaison des entrées produit la même sortie au
temps de propagation près. Dans la présentation que nous allons utiliser, nous allons ignorer dans un premier temps le temps de
propagation.
 Description d’un système combinatoire

 Modèle
 Table de vérité à variables introduites
Deux types de table
- Table sans notion de priorité (toutes les combinaisons des entrées explicitées)
- Table avec notion de priorité entre les entrées principales
 Règles générales de codage

 Pour les instructions du mode concurrent
 présence obligatoire de l’expression_par_défaut pour when else
 présence obligatoire de when others pour with select
 Pour les instructions du mode séquentiel
Dans un process,
- toutes les entrées figurent dans la liste de déclenchement
- toute sortie mise à jour doit avoir une valeur dans toutes les branches possibles. Pour cela, il faut éviter la génération d'une
mémoire implicite (de structure ou de construction) :
 présence obligatoire else pour IF
 présence obligatoire de when others pour case
 définition d’une valeur initiale du signal par défaut au début du process ou assignation d'une valeur au signal dans
toutes les branches
 Choix de codage
Type d'instruction
Mode concurrent Mode séquentiel
Type de table
Table sans priorité With select Case is

Table avec priorité When else If then else
Remarque :
Il existe des cas de tables où chacune de ces instructions peut être utilisée pour la programmer en VHDL,

Approche d'un système combinatoire
- Par table de vérité à variables introduites
- Par une expression logique
I- Par table de vérité à variables introduites (à partir du cahier de charges)
Exemples de description d'une table de vérité à variables introduites en VHDL
- Table sans priorité entre les variables principales de la table

Forme de la table Instructions adaptées
(Utilisation des instructions with select ou case is)
Library ieee;
use ieee.std_logic_1164.all;
Entrées Sortie entity sans_priorite is
A B f port ( A, B, C, D : in std_logic;
0 0 0 F : out qtd_logic
0 1 C.D );
1 0 1 end sans_priorite:
1 1 C+D
architecture ar if sans_priorite is
signal choix : std_logic_vector(1 downto 0);
begin
choix <= A & B;
with choix select
F <= C and D when "01",
C or D when "11",
'1' when "11",
'0' when others;
end ar;

- Table avec priorité entre les variables principales de la table
Forme de la table Instructions adaptées
(Utilisation des instructions when else ou if then)
Library ieee;
Entrées Sortie use ieee.std_logic_1164.all;
sraz sload en id use ieee.std_logic_unsigned.all;
1 * * 0000
0 1 * E entity avec_priorite is
0 0 1 iQ +1 port ( sraz, sload, en : in std_logic;
0 0 0 iQ F, iq : in std_logic_vector(3 downto 0);
id : out std_logic_vector(3 downto 0);
);
end avec_priorite:
architecture ar if avec_priorite is
begin
id <= (others => '0' when sraz='1' else
E when sload='1' else
iq+1 when en='1' else
iq;
end ar;

II- Par une expression logique
- Construction d'une table de vérité à variables introduites
- Description directe en VHDL
Construction d'une table de vérité à variables introduites

a) Construction d'une table de vérité à variables introduites par application du Théorème d'expansion de Shannon
b) Application des méthodes de codage d'une table de vérité
Exemple
Voir exemple précédant

Description directe en VHDL
a) Organiser les termes produits des plus prioritaires au moins prioritaires
(Règle de priorité : le terme produit le plus prioritaire est celui qui contient le plus grand nombre de variables)
b) Décrire la fonction avec when else ou if then

( les conditions décrivent chaque terme produit)
Exemple
f(A, B, C, D) = A.B.C.D  A.B.D  B.C  C.D
- Classer kes termes produits par ordre de priorité. le plus prioriyaire = celui ayant plus de variavles
Donc A.B.C.D est le plus prioritaire suivi de A.B.D puis de B.C  C.D
- Décrire dans l'ordre de priorité chaque terme produit

F <= '1' when A='1' and B='1' and C='0' and D='1' else
'1' when A='1' and B='0' and D='0' else
'1' when B='0' and C='1' else
'1' when C='0' and D='1' else
'0';

B- Système séquentiel
Généralités
Définition
Un système séquentiel est un système présentant u,e mémoire rel que la même combinaison des entrées ne produit pas le même
résultat.
Système asynchrone
Rappel définition d’un système asynchrone
C(est un système séquentiel sans horloge.
Exemple : Description d’une bascule RS rn VHDL
Remarques préliminaires :
Bascule RS
Entity Bascule_rs is Architecture ar of bascule_rs is
Port ( R, S : in std_logic;
Q : out std_logic Begin
);
end bascule_rs;
End ar;

Système synchrone
Définition d’un système synchrone
C'est un système séquentiel avec une entrée privilégiée, appelée horloge, qui valide toute mise à jour de la sortie.
Système synchrone de base en VHDL:
Un process ne peut contenir qu'une seule horloge.
Description de l’horloge
If CK'event and CK = '1' Then
Modification Valeur finale

sur CK de CK
Détection de front montant sur CK

Gestion des signaux dans un process
 Un signal dont la valeur n'est pas assignée pour une configuration donnée des entrées se verra affecter un verrou ou une bascule D
pour conserver sa valeur précédente (mémoire implicite).
 Il est conseillé et de bonnes pratiques que tout système synchrone soit initialisé explicitement de manière asynchrone (par exemple
avec une entrée arazb).
Description des bascules synchrones

* une horloge active sur un niveau (latch) combinatoire + mémoire implicite
* une horloge active sur un front (flipflop)
 une seule horloge par process

 une raz asynchrone

Bascules simples
Bascule D
Entity latch is
Port (CK, D : in std_logic;
Q : out std_logic
);
end latch ;
Bascule D latch (niveau) Bascule flipflop (front)
Bascule D Bascule D
Architecture a_latch of latch is Architecture a_flipflop of latch is

begin begin
Process (CK, D) Process (CK)
Begin Begin
If CK = '1' then If ck’event=’1’ and CK = '1' then
QD; QD;
End if; End if;
End process; End process ;
End a_latch ; end a_flipflop;

8- Systèmes séquentiels synchrones simples
Schéma général de description des systèmes séquentiels synchrones simples
Schéma Description
arazb
Seq_simples Library ieee;
use ieee.std_logic_1164.all
CK
combinatoire
CK arazb entity seq_simples is
Entrees generic (n : natural := 3);
Bloc
synchrones ID[] Q[]

D[] Q[] port ( ck, arazb : in std_logic
IQ[]
bascules
entrees_synchrones : à déclarer selon les types;
Q : out std_logic_vector(n-1 downto 0)

);
end seq_simples

;
Table de vérité de la partie combinatoire Architecture arch of seq_simples is
Entrées synchrones sorties Signal id , iq : std_logic_vector(n-1 downto 0);
Id[]
-- Cas 1 Description du bloc combinatoire -- à part dans le même fichier.
Begin
-- description des bascules
process(ck, arazb)
La description comporte : begin
- une partie asynchrone induite par les entrées if arazb='0' then iq <= (others => '0';
asynchrones et les branches associées elsif ck'event and ck='1' then
- une partie synchrone induite par l'entrée iq <= id
d'horloge et la branche associée. end if,
end process;
2 solutions d'architecture :
Pour toutes ces solutions seul le contenu de la
branche synchrone sera décrit de façon différente -- description de la partie combinatoire
(directe ou indirecte). -- table de vérité (when else ou with select ou un autre
- description du bloc combinatoire à part dans le
même fichier. -- process dans ce cas ou utilise if ou case
)
id <=
-- mise à jour de la sortie

Q <= iq;
-- Calcul des autres sorties
End arch;
Applications aux systèmes séquentiels simples
2) Registre Tampon (reg_tampon_en)
autorisation(en), mise à zéro asynchrone (arazb), et mise à un asynchrone (asetb)
Schéma Description
Reg_tampon_en
Library ieee;
asetb use ieee.std_logic_1164.all
arazb entity reg_tampon_en is
CK generic (n : natural := 3);
E[] port ( ck, arazb, asetb : in std_logic;
asetb
arazb
CK
combinatoire
en en : in std_logic
E : in std_logic_vector(n-1 downto 0);
Bloc
gen(n:=2) Q[]
ID[]
D[] Q[]
IQ[] Q : out std_logic_vector(n-1 downto 0)
bascules );
end reg_tampon_en;

Architecture ar of reg_tampon_en is
Table de vérité de la partie asynchrone Signal iq , id : std_logic_vector(n-1 downto 0);
arazb asetb Q[]
0 0 A éviter Begin
0 1 toutes les bascules à 0 Process(ck, arazb)
1 0 toutes les bascules à 1 Begin
1 1 Mémorisation et passage au mode If arazb=’0’ then iq <= (others => ‘0’)
synchrone elsif asetb=’0’ then iq <= (others => ‘1’)
elsif ck’event and ck=’1’ then
Iq <= id;
Table de vérité de la partie combinatoire
End if;
Entrées sorties Remarque
end process;
synchrones
en Id[] -- description du bloc combinatoire par when else
0 Iq[] mémoire Id <= E when en = '1' else
1 E[] Recopie entrée Iq;
-- mise à jour de la sortie
Q <= iq ;
End ar;
Conclusion :
Pour toutes les fonctions séquentielles simples,
si on adopte la description de la partie combinatoire en dehors de if ck’event
alors il suffit de décrire uniquement la table de vérité du bloc combinatoire,
le reste du fichier est inchangé.

3) Registre Tampon générique et généralisé (reggn)
autorisation(en), mise à zéro asynchrone (arazb), et mise à0 synchrone (sraz)
Schéma Description
reggn Library ieee;
arazb
CK use ieee.std_logic_1164.all
sraz entity reggn is
arazb
combinatoire
en
E[]
CK generic (n : natural := 2);
Bloc
gen(n:=x) ID[] Q[] port ( ck, arazb : in std_logic;

D Q[]
IQ[]
sraz, en : in std_logic
bascules E : in std_logic_vector(n-1 downto 0);
Q : out std_logic_vector(n-1 downto 0)
);
end reggn;

Architecture ar of reggn is
Table de vérité de la partie combinatoire Signal iq , id : std_logic_vector(n-1 downto 0);
Entrées synchrones sorties
sraz en Id[] Begin
1 * 0
0 1 E[] --Description du bloc mémoire
0 0 Iq[] Process(ck, arazb)
Begin
If arazb=’0’ then iq <= (others => ‘0’)
Iq <= id;
End if;
end process;
--Description du bloc combinatoire

-- description du bloc combinatoire par when else
id <= (others => '0') when sraz = '1' else
E when zn = '1' else
iQ;
- mise à jour de la sortie
Q <= iq ;
End ar;

Application aux Compteurs-décompteurs
Compteur généralisé de n bits modulo 2n

cptgn (n, ck, arazb, sraz, en, sload, ud, E(n-1 .. 0), Q(n-1..0), finc, find)
Description Vue externe

Compteur_decompteur binaire générique
arazb
Fonctionnement asynchrone
Arazb = 0 Q=0
ck cptgn
sraz
Fonctionnement synchrone sload Q[]
Sraz = 1 Q=0 mise à 0
Sload = 1 Q=E chargement
en
En = 1 ud finc
Ud = 0 Q = Q +1 comptage E[]
Ud = 1 Q = Q -1 décomptage gen(n:=3) find
En = 0 Q=Q Mémoire
.
Table de vérité Table de vérité finc et find
Entrées synchrones Ud finc find
sraz sload en ud id Remarque 0 Iq = tous_un 0
1 * * * 0 Mise à 0 1 1 Iq = 0
0 1 * * E chargement
0 0 1 0 IQ + 1 Comptage
0 0 1 1 IQ - 1 Décomptage
0 0 0 * IQ mémoire

Description en VHDL (Librairies - Entité ;
Library ieee;
--Description du bloc combinatoire
use ieee.std_logic_1164.all -- description du bloc combinatoire par when else
use ieee.std_logic_unsigned.all id <= (others => '0') when sraz = '1' else
E when sload = '1' else
entity cptgn is Iq + 1 when en = '1' and ud ='0' else
generic (n : natural := 3); Iq -1 when en = '1' and ud = '1' else
port ( ck, arazb :: in std_logic; iQ;
sraz, sload, en, ud : in std_logic
E :: in std_logic_vector(n-1 downto 0); - mise à jour de la sortie
fnc, find : out std_logic; finc <= '1' when ud='0' and iq=tous_un else
Q :: out std_logic_vector(n-1 downto 0) '0';
); find <= '1' when ud='1' and iq=0 else
end cptgn; '0';
Q <= iq;
– Architecture)
Architecture ar of cptgn is End ar;
Constant tous_un : std_logic_vector((n-1 downto
0)!=(others='1');
Signal iq , id : std_logic_vector(n-1 downto 0);
Begin
--Description du bloc mémoire
Process(ck, arazb)
Begin
Iq <= id;
End if;
end process

Compteur – décompteur BCD
Description
Autorisation(en), mise à zéro asynchrone (arazb), et mise à 0 synchrone (sraz)
Chargement synchrone (sload) si E[] ≤ 9
finc indique la détection de 9 quand ud =0
si cpt = 9 et ud=0 alors finc = 1
sinon finc = 0
find indique la détection de 0 quand ud =1
si cpt = 0 et ud = 1 alors find = 1
sinon find = 0
Vue externe Tables de vérité
Table de vérité
arazb Entrées synchrones Sortie
ck Cpt_dec sraz sload en ud id Remaque
sraz 1 * * * 0 Mise à 0
sload Q[3..0] 0 1 E≤9 * * E chargement
en E>9 IQ
ud finc 0 0 1 0 IQ < 9 IQ + 1 Comptahe
E[3..0] IQ ≥ 9 0
find 0 0 1 1 IQ  0 IQ - 1 Décomptage
IQ = 0 9
0 0 0 * IQ mémoire
Table de vérité finc et find

Ud finc find
0 Iq=9 0
1 1 Iq=0

Codage --
Description en VHDL (Librairies - Entité Description du bloc combinatoire
Library ieee; -- description du bloc combinatoire par when else
use ieee.std_logic_1164.all id <= (others => '0') when sraz = '1' else
use ieee.std_logic_unsigned.all E when sload = '1' and E <= 9 else
IQ when sload = '1' and E < 9 else
entity cpt_dec is Iq + 1 when en = '1' and ud='0' and iq < 9 else
port ( ck, arazb :: in std_logic; (others => '0') when en = '1' and ud='0' and iq ≥9 else
sraz, sload, en, ud : in std_logic Iq -1 when en = '1' and ud='1' and iq /=0 else
E :: in std_logic_vector(3 downto 0); "1001" when en = '1' and ud='1' and iq =0 else
fnc, find : out std_logic; iQ;
Q :: out std_logic_vector(3 downto 0)
); - mise à jour de la sortie
end cpt_dec; finc <= '1' when ud='0' and iq = 9 else
'0';
– Architecture)
Architecture ar of cpt_dec is find <= '1' when ud='1' and iq = 0 else
Signal iq , id : std_logic_vector(n-1 downto 0); '0';
Q <= iq ;
Begin
End ar;
Process(ck, arazb)
Begin
Iq <= id;
End if;
end process;

Compteur généralisé de n bits modulo programmable Emax+1
cptg,_mod_prog (n, ck, arazb, sraz, en, sload, ud, E(n-1 .. 0), Emax, Q(n-1..0), finc, find)
Description
finc indique la détection de Emax quand ud =0
si cpt = Emax et ud=0 alors finc = 1
sinon finc = 0
find indique la détection de 0 quand ud =1
si cpt = 0 et ud = 1 alors find = 1
sinon find = 0
Vue externe Table de vérité Table de vérité finc et find

arazb Table de vérité de la partie combinatoire
ck Entrées synchrones Table de vérité finc et find
sraz sraz sload en ud id Ud finc find
sload Q[] 1 0 Iq=Emax 0
en 1 1 0 Iq=0
ud finc
E[] 1
find
Emax[]
gen(n:=3)
cptg_mod_prog 1

Description en VHDL (Librairies – Entité) Description du bloc combinatoire
Library ieee; -- description du bloc combinatoire par when else
use ieee.std_logic_1164.all id <= (others => '0') when sraz = '1' else
use ieee.std_logic_unsigned.all E when sload = '1' and E <= Emax else
IQ when sload = '1' and E > Emax else
entity cpt_mod_prog is Iq + 1 when en = '1' and ud='0' and iq < Emax else
port ( ck, arazb :: in std_logic; (others => '0') when en = '1' and ud='0' and iq ≥ Emax else
sraz, sload, en, ud : in std_logic Iq -1 when en = '1' and ud='1' and iq /=0 else
E, Emax :: in std_logic_vector(3 downto 0); Emax when en = '1' and ud='1' and iq =0 else
fnc, find : out std_logic; iQ;
Q :: out std_logic_vector(3 downto 0)
); - mise à jour de la sortie
end cpt_mod_prog; finc <= '1' when ud='0' and iq = Emax else
'0';
– Architecture
Architecture ar of cpt_mod_prog is find <= '1' when ud='1' and iq = 0 else
Signal iq , id : std_logic_vector(n-1 downto 0); '0';
Q <= iq ;
Begin
End ar;
Process(ck, arazb)
Begin
Iq <= id;
End if;
end process;

9- Systèmes séquentiels complexes
Rappel : Machine à états
Définition
Une machine à états (Mae ou mae) est une représentation des systèmes séquentiels qui ne présentent qu'un seul état actif au maximum à
la fois.
Représentation
un état est représenté par un rond avec un numéro ou un nom
nom
Cas particulier : l'état initial est représenté par un double rond avec un numéro
ou un nom initial
Une transition traduit le passage entre états

Elle est représentée par une flèche étiquettée par une condition condition
Vocabulaire
Etat_amont condition
amont aval
Etat_aval
Cas particulier Transition source

Une transition sans état amont. Elle permet de activer l'état aval Condition_source
nom
Cas particulier Transition puits

Une transition sans état aval. Elle permet de desactiver l'état amonr
Condition_puits
nom

Règles de représentation
Une condition - est une expression booléenne
- peut être toujours vraie alors elle est représentée par '1'
Si plusieurs transitions partent d'un même état amont alors les conditions associées à chaque transition doivent être exclusives deux par
deux.
Exemple
Rendre les conditions exclusives par gestion de la priorité
C1
C1
nom
C2 nom
C2.C1
Valable si C1 . C2 = 0
Donc C1 et c1 sont exclusives
Règles d'évolution
1- Chaque actif est actif ou pas et on ne peut avoir qu'un seul actif à la fois.
2- La Mae démarre toujours par l'état initial actif.
3- On part de l'état actif
a) évaluer la condition associée à chaque transition sortant de l'état actif
b) Si aucune condition n'est vraie alors il n'y a pas d'évolution
c) Si une condition est vraie alors il y a une évolution :
désactiver l'état actif et activer l'état aval de la transition dont la condition est vraie.
4- recommencer en 3

Les actions
Une machine à états est conçue pour commander d'autres systèmes dans un contexte de contrôle commande.
Pour cela, la mae est considérée comme système de commande et les éléments commandés constituent la partie opérative.
En électronique numérique, ces commandes peuvent être réparties en deux groupes :
- action à mise à zéro implicite (AMZI ou MAZI)
- action à mise à zéro explicite (AMZE ou MAZE)
- Action AMZI
Définition
C'est une action dont on indique sur le graphe uniquement les activations.
L'action est désactivée partout ailleurs.
C'est une action combinatoire (pas de mémoire)
Représentation
nom_amzi = expression

- Action AMZE
Définition
C'est une action dont on indique sur le graphe les activations et desacrivations.
Cette action nécessite une mémoire.
Sa représentation comporte 2 parties qui sont des amzi :
- activation
- desactivation
Représentation
Activation
S = set S nom_amze_mu= expr_mu

Desactivation
R = reset R nom_amze_mz= expr_mz

Sources des actions
Chaque type d'action (amzi, amzi_mu et amzi_mz) peut être superposé au graphe :
- soit sur un état
- soit sur une transition
Action sur état

Une action sur un état dure tant que l'état est actif.
Représentation
Nom_amzi = expression
condition
x y
R Nom_amze_mz = expression1
L'action est décrite à côté de l'état concerné
- l'action nom_amzi sera active dans l'état x, si expression est active (souvent 1)
- l'action nom_amze_mz sera active dans l'état x, si expression1 est active (souvent 1)

Action sur transition
Une action sur une transition dure le temps de passage de l'état amont à l'état aval de la transition concernée si la condition
associée est vraie
Représentation
S Nom_amze_mu = expression1
condition
x y
L'action est décrite sur la transition concernée
- l'action nom_amze_mu sera active quand l'état amont x sera actif et que la condition est vraie.
C'est-à-dire au moment du passage de l'état amont x à l'état aval r.
Remarque importante :
Une même action peut être décrite plusieurs fois sur un même graphe..
La commande correspondante sera un ou de chaque description.

Mise en œuvre (Codage)
La mise en VHDL est synchrone, C'est-à-dire que on utilisera les bascules D flipflop pour mémoriser l'état de la mae.
Obligation d'avoir une seule horloge et une mise à zéro asynchrone.
- La mise à zéro asynchrone pour le démarrage de la mae dans l'état initial
- L'horloge pour cadencer le fonctionnement normal de la mae.

Structure générale
La structure de mise en œuvre est une généralisation du schéma des systèmes séquentiels simples. Elle
correspond au schéma ci-dessous.
mae
arazb
ck
evolution
ck arazb
entrées etat_initial
Etat
Bloc suivant Etat
combinatoire memoire present
Etat
present
actions
entrées
MAZI
entrées sorties
MAZE
ck
ck
arazb
arazb
La mise en oeuvre en VHDL peut se faire de façon modulaire en partant du schéma de base des systèmes séquentiels.
Ce schéma comporte 3 blocs :
- le bloc évolution :
Ce bloc purement combinatoire calcule l'état suivant du système en fonction de l'état présent et des entrées.
- le bloc mémoire :
Ce bloc mémorise état suivant dans état présent.
- le bloc de sortie :
Ce bloc calcule chaque sortie à générer.

Mise en œuvre synchrone en VHDL
La mise en œuvre de la machine à états comporte 3 étapes :

- donner les noms aux états de la machine.
- déclarer les signaux pour la gestion des états de la machine
- décrire la mae
a) Donner les noms aux états de la machine

- On utilise le Type utilisateur du VHDL défini par l'utilisateur :
- Définition des états de la machine:
type nom_liste_état IS (état0, …, étatn) ;
 codage état = binaire par défaut
b) Déclarer les signaux pour la gestion des états de la machine

Signal etat_present, etat_suivant : nom_liste_état;
c) Décrire la mae
Cette description comporte 3 parties :
- Evolution pour le calcul de l'état suivant (on utilise un process)
- Mémorisation (process) pour produire l'état présent
- Sorties = actions généralisées
Action à mise à zéro implicite (AMZI) =
 comportement combinatoire (When else, with select, if then ou case is)
Action à mise à zéro explicite (AMZE) =
 comportement séquentiel (Process avec horloge et raz)

Description détaillée de la machine à états (mae)
Evolution :
On utilise
- case is pour détecter l'état actif
- if then pour évaluer les conditions associées aux transitions et la mise à jour de l'état suivant
process (état_présent, entrée)

Begin
Case état_présent IS
When état0  If ei='1' then
État_suivant <= etat2;
else
état_suivant <= etat0;
end if ;
When others  etat_suivant <= etat0 ;
End case;
End process;

Memorisation :
On met à jour l'état présent :
- l'initialisation on assigne l'état initial à l'état présent
- au rythme de l'horloge on met à jour l(état présent
c'est souvent une recopie de l'état suivant dans l'état présent
Il est possible de faire un forçage synchrone de l'état présent
process (CK, arazb)

Begin
If arazb = '0' then
etat_present  etat0 ;
Elsif CK' event and CK = '1' then
etat_present  etat_suivant ;
End if;
End process;

-- Actions :
- Action AMZI
Sur le graphe, on indique uniquement les activations. L'action est déeactivée partout ailleurs.
Représentation
nom_amzi = expression
- Mise en œuvre et codage
Une action amzi est combinatoire
Elle peut être générée Codage

sur :
Un état Nom_amzi_e <=
condition
amont aval expr_e when pres=amont else
'0';
nom_amzi_e= expr_e
Une transition Nom_amzi_t <=

nom_amzi_t= expr_t expr_t when pres=amont
and condition ='1' else
condition '0';
amont aval

- Action AMZE
Sur le graphe, on indique les activations et descarivatios.
Cette action nécessite une mémoire.
Sa représentation comporte 2 parties qui sont des amzi :
- activation nom_amze_mu
- desactivation nom_amze_mz
Représentation
activation
S nom_amze_mu= expr_mu
desactivation
R nom_amze_mz= expr_mz
La mémoire est une bascule D mise à 1 par l'activation et la mise à 0 par la désactivation au rythme de l'horloge.
Les actions d'activation et de désactivation

- sont des amzi
- sont produites sur état ou sur transition
Leur traduction en VHDL sont identiques

Exemple
Calcul des elements d'ube maze
S nom_amze_mu= expr_mu Nom_amze_mz <= expr_mz when pres=amont else

'0';
Nom_amze_mu <= expr_mu when pres=amont
condition and condition ='1' else
amont aval
'0';
Mémorisation (Bascule)
R nom_amze_mz= expr_mz Process(ck, arazb)
begin
if arazb = '0' then nom_amze <= '0';
elsif ck"event and ck = '1' then
if nom_amze_mu ='1' then nom_amze <= '1';
elsif nom_amze_mz = '1' then nom_amze <= '0';
end if;
end if;
end process;

Exemple
Exemple de machine à états
e2 S S1_mu=1
R S1_mz=e5
e0
e1
0 1 2 S0=e4
e2.e3
library ieee;
Entity mac_etat is
port ( ck, arazb : in std_logic;
e : in std_logic-vector(5 downto 0); ;
S0, S1 : out std_logic;
visu_etat : out std_logic_vector(1 downto 0)
);
end mac_etat;
Structure de l'architecture
Architecture a_mac_etat of mac_etat is
-- definition d'un type utilisateur pour les états de la machine
type etat_mae is (etat0, etat1, etat2);
-- declaration de éléments gestion de la machine
signal pres, suiv : etat_mae;

begin
-- ici la mémorisation de l'état_present
process(ck,arazb)
begin
if arazb = '0' then pres <= etat0; -- etat initial
elsif ck'event and ck='1' then pres <= suiv;
end if;
end process;
-- evolution
process(pres, ) process(pres, )
begin begin
case pres is
when etat0 => case pres is
when etat0 =>
when etat1 => when etat1 =>
when etat2 =>

when etat2 =>
when others => suiv <= etat0;

end case;
when others => suiv <= etat0; end process;
end case;
end process;

mettre ici la génération des actions
S0 <=
S1_mu <=
S1_mz <=
-- Bascule S0
Process( )
end a_mac_etat;

Application à l'exemple
e2 S S1_mu=1 library ieee;

R S1_mz=e5
Entity mac_etat is
e0
e1 port ( ck, arazb : in std_logic;
0 1 2 S0=e4 e : in std_logic-vector(5 downto 0); ;
S0, S1 : out std_logic;
e2.e3 visu_etat : out std_logic_vector(1 downto 0)
);
end mac_etat;
Structure de l'architecture
Architecture a_mac_etat of mac_etat is
-- definition d'un type utilisateur pour les états de la machine
type etat_mae is (etat0, etat1, etat2);
-- declaration de éléments gestion de la machine
signal pres, suiv : etat_mae;
-- déclaration des signaux de gestion de AMZE
signal s1_mu, s1_mz : std_logic;
begin
-- ici la mémorisation de l'état_present
process(ck,arazb)
begin
if arazb = '0' then pres <= etat0; -- etat initial
elsif ck'event and ck='1' then pres <= suiv;
end if;
end process;

Evolution
Version 1 Version 2
process(pres, e) process(pres, e)
begin begin
suiv <= pres;
case pres is case pres is
when etat0 => if e(0)='1' then suiv <= etat1; when etat0 => if e(0)='1' then suiv <= etat1;
else suiv <= etat0; else suiv <= etat0;
end if; end if;
end if; end if;
elsif e(2)='0' and e(3)='1 elsif e(2)='0' and e(3)='1
then suiv <= etat0; then suiv <= etat0;
end if; end if;
when others => suiv <= etat0; when others => suiv <= etat0;
end case; end case;
end process; end process;
-- Génération des sorties

S0 <= e(4) when pres = etat2 else -- action AMZI donc combinatoire
'0';
S1_mu <= '1' when pres=etat2 and e(2) = '0' else -- action AMZI pour preparation AMZE
'0';
S1_mz <= e(5) when pres=etat0 else -- action AMZE pour preparation AMZE
'0';
-- Bascule pour AMZE

process(ck, arazb)
begin
if arazb='0' then S1 <= '0';
elsif ck'event and ck='1' then
if s1_mu ='1' then S1 <= '1';
elsif S1_mz='1' then S1 <= '0';
end if;
end if;
end process;
End architecture;

10- Synthèse : Approche des systèmes complexes
Rappel de l'électronique numérique

a) Notions de bloc de commande et de blocs à commander
b) Description des relations entre le bloc de commande et les blocs à commander
a. par tables de fonctionnement
b. par chronogrammes (exploitation des états d’un compteur)
c. par machines à états
c) Mise en œuvre
Exemples
Comptage complexe
On veut réaliser un dispositif de comptage sur 4bits ayant 4 modes de fonctionnement
mode 0 : comptage modulo 14
mode 1 : Décomptage de 12 à 6
mode 2 : comptage et arrêt du comptage si q=9
mode 3 : figer le compteur à 5
4-2 Analyse et bilan de la partie opérative

L'analyse du cahier des charges montre que la partie opérative est constituée d'un arazb
compteur_décompteur binaire modulo 16. ck
sraz
Q[3..0]
sload
en
ud
E[3..0]
Cptg_4bits

4-3 Structure
Le système est composé : Cpt_cplexe
- d'une partie opérative (cptg_4bits) arazb
- d'un bloc de commande (Bcmd) ck
arazb
ck
Bcmd
csraz
csraz sraz
Q[3..0]
csload
csload sload
M[1..0] cen
cen en
cud
cud ud
Iq[3..0]
cE[3..0]
Iq[3..0] cE[3..0] E[3..0]
Cptg_4bits
Nous avons construit la table de vérité du bloc de commande qui accepte les phases transitoires lors des changements de mode
b) Table de vérité à variables introduites avec des phases parasites réduites

mode Commandes compteur
M1 M0 csraz csload cen cud Ce[3..0] remarque
0 0 Iq  13 0 1 0 0 Compteur modulo 14
0 1 0 Iq  6 Ou Iq >12 1 1 12 Décomptage de 12 à 6
1 0 0 0 Iq  9 0 0 Comptage et arrêt à 9
1 1 0 1 x x 5 Figeage à 5

Décrire ce système en VHDL

Application à la mise en cascade des compteurs
Nous reprenons l'exemple traité pendant le rappel de ENN
Exemple1
On veut réaliser un système de comptage en BCD modulo 60.
Ce système dispose par ailleurs d'une entrée de mis à 0 asynchrone, arazb (active à 0), d'une entrée de mise à zéro synchrone,
sraz_bcd_60 (active à 1) et d'une entrée d'autorisation de comptage, en_bcd_60 (active à 1)
Donner la vue externe et interne de ce système en faisant apparaître le bloc de commande et la partie opérative.
Dans cet exemple, nous utiliserons le compteur_décompteur modulo 16

arazb
disponible
ck
Nous n'avons pas besoin de sraz

Q[3..0]
sload, ud et E[..] 0 sload
en
Donc les commandes ses limiterons à 0 ud
Sraz et en 0000 E[3..0]
Cptg_4bits

D'où la vue externe et interne cpt_bcd_60
arazb arazb
Bcmd_bcd_60 arazb
ck
ck ck
Cptg_4bits
csrazd
sraz
iqd[3..0] qd[3..0]
cend
en Q[3..0]
0 sload
Sraz_bcd_60 0 ud
0000 E[3..0]
En_bcd_60
arazb
arazb
ck
ck Cptg_4bits
csrazu
sraz
cenu iqu[3..0] qu[3..0]
en Q[3..0]
iqd[3..0]
0 sload
iqu[3..0] 0 ud
0000 E[3..0]
D’où la table de vérité
Sraz_bcd_60 En_bcd_60 csrazd cend csrazu cenu

1 x 1 x 1 x
0 1 iqd=5 iqu=9 iqu=9 1
Et
iqu=9
0 0 0 0 0 0
Décrire ce système en VHDL

Poly VHDL 2022-2023 Paysage ST Jerome

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Poly VHDL 2022-2023 Paysage ST Jerome

Transféré par

Droits d'auteur :

Formats disponibles

VHDL SYNTHETISABLE

VHDL SYNTHETISABLE A. Nketsa 1 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 2 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 3 14/11/2022

7 – Application du VHDL pour la description des systèmes logiques

VHDL SYNTHETISABLE A. Nketsa 4 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 5 14/11/2022

7- VHDL for logic synthesis 8-VHDL : Langage, modélisation, synthèse

VHDL SYNTHETISABLE A. Nketsa 6 14/11/2022

1.1 Intérêts et objectifs du langage

VHDL = (VHSIC Hardware Description Language)

VHDL raccourci = Langage de description matérielle de systèmes électroniques (numériques)

VHDL SYNTHETISABLE A. Nketsa 7 14/11/2022

Langage puissant et flexible : Plusieurs niveaux de description

Composant - librairies – packages

VHDL SYNTHETISABLE A. Nketsa 8 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 9 14/11/2022

Passage CPLD ou FPGA vers ASIC

VHDL SYNTHETISABLE A. Nketsa 10 14/11/2022

Description de l’application en VHDL (choix d’une méthodologie) Modélisation

Simulation fonctionnelle Evaluation fonctionnelle

Synthèse – optimisation (fit - placement et routage) Réalisation

Programmation du composant (transfert des points de connexion) Transfert sur la cible

Test sur site Evaluation sur la cible

VHDL SYNTHETISABLE A. Nketsa 11 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 12 14/11/2022

Exemples : 'a' et 'A' sont différents

* chaîne de caractères elle se met entre guillemets " "

Le mot réservé & permet la concaténation des chaînes

VHDL SYNTHETISABLE A. Nketsa 13 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 14 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 15 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 16 14/11/2022

Natural sous type de integer

Type utilisateur (Type énuméré)

VHDL SYNTHETISABLE A. Nketsa 17 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 18 14/11/2022

Déclaration signal Nom_tableau : std_logic_vector(fin downto debut) ;

Indice : fin Indice : debut

Désignation des éléments du tableau à une dimension

Désignation de tout le tableau : Nom_tableau

Désignation d’un élément du tableau nom_tableau(indice)

Désignation de plusieurs éléments contigus d’un tableau nom_tableau(indice_fin downto indice_debut)

bit7 bit5 bit4 bit3 bit2 bit1 bit0

nom_tableau(5 downto 3) nom_tableau(0)

VHDL SYNTHETISABLE A. Nketsa 19 14/11/2022

Déclaration d'un port

Direction peut être : in pour désigner la (ou les) entrée(s)

port ( entree : in std_logic;

VHDL SYNTHETISABLE A. Nketsa 20 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 21 14/11/2022

Nous avons restreint la table aux types utilisés en TP

CATEGORIE SIGNIFICATION TYPE OPERANDES

VHDL SYNTHETISABLE A. Nketsa 22 14/11/2022

VHDL SYNTHETISABLE A. Nketsa 23 14/11/2022

b-2) Types d’expression

b-2-1) Expression booléenne

VHDL SYNTHETISABLE A. Nketsa 24 14/11/2022

booléen : std_logic_vector operateur_comparaison std_logic_vector

booléen : natural operateur_comparaison natural

busd >= 200 Comparaison de busd(7..0) à 200

busd(4 downto 1) = 5 comparaison du mot de 4bits à 5

busd(5) = '0' comparaison du bit 5 de busd à 0