Projet de Fin d’Année

4ème années cycle c’ingénieur

Automatisme et Informatique Industriel

Rapport :
VHDL

Réalisé par : Encadré par:

ELBIKRI Kenza ELKARI ABDELJALIL
ABARDOUA Ossama

Année universitaire 2020-2021

 Dédicaces
A mes très chers parents,
Aucune dédicace ne saurait exprimer l’amour, l’estime, le respect et la reconnaissance pour vos
efforts et le soutien que vous m’avez toujours prodigué, Rien au monde ne vaut les efforts et
l’encouragement sans limites que vous ne cessez de manifester, Ce travail est le fruit de vos
sacrifices que vous avez consentis pour mon bien être et mon éducation.

A mes sœurs Khaoula et Fatima-Ezzahra, à tous les membres de ma famille, grands et petits, à
tous mes amis, à tous mes professeures, à mes collègues de classe, à toute personne qui a marqué
ma vie,

A vous tous, je dédie ce modeste travail en signe de reconnaissance et dévouement.

ABARDOUA Ossama

Je dédie ce travail accompagner d’un profond amour :

A celle qui m’a transmis la vie, l’amour, le courage, et qui m’a soutenu et encouragé tout au
long de mon parcours, qui m’a arrosé de tendresse et d’espoirs, à la source d’amour incessible, à
la mère des sentiments fragiles qui ma bénie par ces prières, ma Maman d’amour que Dieu bénie
son âme.

A celui qui m’a indiqué la bonne voie en me rappelant que la volonté fait toujours le bon gens, à
mon support dans ma vie, qui m’a appris m’a supporté et ma dirigé vers la gloire, mon Papa
chéri.
A mes chers frères.
A toutes les personnes de ma grande famille.
A mes amis.
ELBIKRI Kenza

II
 Remerciments
En préambule de ce rapport, on souhaite adresser nos remerciements les plus sincères
aux personnes qui nous ont apporté leur aide et qui ont contribué à son élaboration
d’une manière directe ou indirecte.

Nos sincères remerciements sont destinés à M. EL KARI Abdeljalil, pour nous

avoir accueilli comme encadrant, pour ses directives, ses encouragements et surtout
pour sa disponibilité tout au long de la période de ce cours.
Les discussions que nous avons partagées, ont permis d’orienter notre travail d’une
manière pertinente. Nous le remercions aussi pour sa disponibilité à encadrer ce
travail à travers ses critiques et ses propositions d’amélioration, pour son temps
consacré au suivi des différentes étapes de notre cours.
Nous le remercions pour ses directives, ses conseils et ses encouragements.
Nous profitons de ces quelques lignes pour présenter également nos remerciements et
profonde gratitude au corps professoral de l’Ecole Marocaine des Sciences de
l’Ingénieur (EMSI) de Marrakech, et plus particulièrement les enseignants de la
filière Automatismes et Informatique Industrielle, qui ont ménagé tout leur temps
et efforts pour nous doter d’une si riche formation.
Que tous ceux et celles qui ont contribué de près ou de loin à l’accomplissement de
ce travail trouvent l’expression de mes remerciements les plus chaleureux.

III
 Résumé
L'objectif de ce cours est de maîtriser les bases de la conception des circuits numériques
en langage VHDL. Les éléments de syntaxe sont introduits sur des exemples concrets de circuits
combinatoires et séquentiels, permettant dans un premier temps de simuler le fonctionnement
de ces composants, puis de les implémenter sur une cible FPGA.
Le VHDL est un langage informatique particulier, car il ne permet pas de programmer une
machine comme on le fait en C ou en C++. Son rôle est de décrire du "matériel", des composants
numériques. On trouve une application directe du VHDL dans le domaine de la
microélectronique, pour la conception des circuits intégrés. C'est même un langage
incontournable dans ce contexte car tous les blocs numériques sont décrits en HDL. Mais le VHDL
ne se limite pas au seul domaine de la microélectronique.
On trouve aujourd'hui de nombreuses applications dans le domaine des systèmes
embarqués, notamment par l'utilisation de composants logiques programmables tels que les
FPGA, qui permettent une flexibilité et des performances plus élevées que les microcontrôleurs.

IV
 Abstract
The objective of this course is to master the basics of digital circuit design in VHDL
language. The syntax elements are introduced on concrete examples of combinatorial and
sequential circuits, making it possible first to simulate the operation of these components, then
to implement them on an FPGA target.
VHDL is a particular computer language, because it does not allow you to program a
machine as you do in C or C ++. Its role is to describe "material", digital components. There is a
direct application of VHDL in the field of microelectronics, for the design of integrated circuits. It
is even an essential language in this context because all the digital blocks are described in HDL.
But VHDL is not limited to the field of microelectronics alone.
Today we find many applications in the field of embedded systems, in particular through
the use of programmable logic components such as FPGAs, which allow flexibility and higher
performance than microcontrollers.

V
 Liste des figures
Figure 1 Classification des circuits numérique.............................................................................................. 4
Figure 2 codage d'une fonction logique........................................................................................................ 4
Figure 3 PLD (Programmable Logic Device) .................................................................................................. 5
Figure 4 CPLD (Complex Programmable Logic Device) ................................................................................. 6
Figure 5 Les différentes classe de FPGA........................................................................................................ 6
Figure 6 Structure interne ............................................................................................................................. 7
Figure 7 Schéma bloc .................................................................................................................................... 7
Figure 8 Les interconnexions entre les cellules d'un FPGA ........................................................................... 7
Figure 9 carte électronique ALTERA cyclone II ............................................................................................. 8
Figure 10 Interface Quartus .......................................................................................................................... 9
Figure 11 Désignation d'une porte logique ET ............................................................................................ 15
Figure 12 Code porte ET.............................................................................................................................. 16
Figure 13 Simulation de la porte ET ............................................................................................................ 16
Figure 14 symbole de la porte logique XOR ................................................................................................ 17
Figure 15 Code porte XOR........................................................................................................................... 17
Figure 16 Simulation de la porte XOR ......................................................................................................... 18
Figure 17 Bascule D ..................................................................................................................................... 18
Figure 18 Code bascule D ............................................................................................................................ 19
Figure 19 Code porte ET.............................................................................................................................. 20
Figure 20 Code « Porte ET + Bascule D » .................................................................................................... 21
Figure 21 Simulation « Porte ET + Bascule D » ........................................................................................... 22
Figure 22 Code calculatrice digitale ............................................................................................................ 23
Figure 23 Simulation calculatrice digitale ................................................................................................... 23
Figure 24 Code compteur ........................................................................................................................... 25
Figure 25 Simulation du code ..................................................................................................................... 25
Figure 26 simulation compteur 7 segments ............................................................................................... 29

VI
 Liste des tableaux
Tableau 1 la famille cyclone .......................................................................................................................... 8

VII
 Sommaire
Dédicaces ...................................................................................................................................................... II
Remerciments .............................................................................................................................................. III
Résumé ........................................................................................................................................................ IV
Abstract ......................................................................................................................................................... V
Liste des figures ........................................................................................................................................... VI
Liste des tableaux........................................................................................................................................ VII
Sommaire ................................................................................................................................................... VIII
Introduction générale ................................................................................................................................... 1
Introduction : ................................................................................................................................................ 3
4- Architectures utilisées :......................................................................................................................... 5
4-1- PLD (Programmable Logic Device) : ................................................................................................... 5
4-2- CPLD (Complex Programmable Logic Device) :.................................................................................. 5
4-2- FPGA : ................................................................................................................................................ 6
5- Carte électronique ALTERA : ................................................................................................................. 8
6- SOFTWAR « QUARTUS » : ..................................................................................................................... 9
6-1- Création d'un nouveau projet : ....................................................................................................... 10
6-2- Saisie d’un projet : ........................................................................................................................... 11
6.2.1- Création d'un fichier VHDL : .................................................................................................... 11
6-3- Compilation : ................................................................................................................................... 11
6-4- Simulation d'un circuit : ................................................................................................................... 12
6-5- Simulation Fonctionnelle : ............................................................................................................... 13
Conclusion : ................................................................................................................................................. 13
Chapitre 2 : Travaux pratiques ............................................................................................................ 14
1- TP1 : Porte ET : .................................................................................................................................... 15
1-1- Introduction : .............................................................................................................................. 15
1-2- Code : .......................................................................................................................................... 15
1-3- Simulation : ................................................................................................................................. 16
1-4- Conclusion : ................................................................................................................................. 16
2- TP2 : Porte XOR : ................................................................................................................................. 17
2-1- Introduction : .............................................................................................................................. 17
2-2- Code : .......................................................................................................................................... 17
2-3- Simulation : ................................................................................................................................. 18
VIII
 2-4- Conclusion : ................................................................................................................................. 18
3- TP3 : Bascule D : .................................................................................................................................. 18
3-1- Introduction : ................................................................................................................................... 18
3-2- Code : ............................................................................................................................................... 18
3-4- Code porte ET : ................................................................................................................................ 19
3-5- Code BASCULE D + porte ET : .......................................................................................................... 20
3-6- Simulation : ...................................................................................................................................... 22
3-7- Conclusion : ..................................................................................................................................... 22
4- TP4 : Calculatrice digitale : .................................................................................................................. 22
4-1- Introduction : ................................................................................................................................... 22
4-2- Code : ............................................................................................................................................... 22
4-3- Simulation : ...................................................................................................................................... 23
4-4- Conclusion : ..................................................................................................................................... 24
5- TP5 : compteur 7 segment : ................................................................................................................ 24
5-1- Introduction : ................................................................................................................................... 24
5-2- Code : ............................................................................................................................................... 24
5-3- Simulation : ...................................................................................................................................... 25
5-4- Code compteur + 7 segments : ....................................................................................................... 25
5-4-2- Code compteur : ....................................................................................................................... 25
5-4-2- Code compteur : ....................................................................................................................... 26
5-4-3- Code diviseur de fréquence :.................................................................................................... 27
5-4-4- Code général :........................................................................................................................... 27
5-5- Simulation : ...................................................................................................................................... 29
5-5- Conclusion : ..................................................................................................................................... 29
6- Conclusion du chapitre : ..................................................................................................................... 29
Conclusion générale .................................................................................................................................... 30
ANNEXES ..................................................................................................................................................... 32

IX
 Introduction générale
VHDL est le sigle de VHSIC hardware description langage ; VHSIC vient quant à lui de very-
high-speed integrated circuits, une initiative de la Défense américaine dans les années 1980
visant la construction de circuits intégrés très rapides. Le VHDL est un langage de description du
matériel utilisé en électronique. En tant que standard, il est indépendant du logiciel utilisé pour
la compilation, la programmation des composants, la simulation, etc.

Il autorise plusieurs méthodologies de conception (comportemental, flot de données,

structurel) tout en étant d'un très haut niveau d'abstraction en électronique (il est indépendant
de la technologie utilisée : FPGA, CPLD, ASIC, etc.). Cette abstraction permet d'ailleurs de le
simuler sur ordinateur avant de programmer la moindre puce.

Lors de sa conception, l'objectif n'était pas de produire un nouveau langage ex nihilo : la

Défense avait récemment mis au point le langage Ada, il était préférable de partir sur ces bases
et en exploiter autant que possible la syntaxe, en l'adaptant au contexte de l'électronique
numérique.

1
Chapitre 1 :
Les circuits logiques programmables

2
Introduction :
Il y a quelques années la réalisation d’un montage en électronique numérique impliquait
l’utilisation d’un nombre important de circuits intégrés logiques. Ceci avait pour conséquences
un prix de revient élevé, une mise en oeuvre complexe et un circuit imprimé de taille
importante.
Le développement des mémoires utilisées en informatique fut à l’origine des premiers
circuits logiques programmables (PLD : programmable logic device). Ce type de produit peut
intégrer dans un seul circuit plusieurs fonctions logiques programmables par l’utilisateur. Sa
mise en oeuvre se fait très facilement à l’aide d’un programmateur, d’un micro-ordinateur et
d’un logiciel adapté.

1- Outils :
Les fabricants des puces programmables fournissent généralement, sur leur site ou avec
les puces, tous les logiciels nécessaires pour les utiliser : compilateur ou synthétiseur VHDL, qui
se chargera de convertir le code VHDL en sa version logique, prête pour la puce ; simulateur, pour
tester le code.

2- ASIC et composants électroniques :

L'électronique moderne se tourne de plus en plus vers le numérique qui présente de
nombreux avantages sur l'analogique : grande insensibilité aux parasites et aux dérives diverses,
modularité et (re)configurabilité, facilité de stockage de l'information etc...
Les circuits numériques nécessitent par contre une architecture plus lourde et leur mode
de traitement de l'information met en œuvre plus de fonctions élémentaires que l'analogique
d'où découle des temps de traitement plus long.
Aussi les fabricants de circuits intégrés numériques s'attachent-ils à fournir des circuits
présentant des densités d'intégration toujours plus élevée, pour des vitesses de fonctionnement
de plus en plus grandes.
D'abord réalisées avec des circuits SSI (Small Scale Integration) les fonctions logiques
intégrées se sont développées avec la mise au point du transistor MOS dont la facilité
d'intégration a permis la réalisation de circuits MSI (Medium Scale Integration) puis LSI (Large
Scale Integration) puis VLSI (Very Large Scale Integration). Ces deux dernières générations ont vu
l'avènement des microprocesseurs et microcontroleurs.
Bien que ces derniers aient révolutionné l'électronique numérique par la possibilité de
réaliser n'importe quelle fonction par programmation d'un composant générique, ils traitent
l'information de manière séquentielle (du moins dans les versions classiques), ne répondant pas
toujours aux exigences de rapidité.
ASIC (Application Specific Integrated Circuits) qui sont des composants où le concepteur
intervient au niveau du dessin de la pastille de silicium en fournissant des masques à un fondeur.
On ne peut plus franchement parler de circuits programmables. Les temps de développement
long ne justifient l'utilisation que pour des grandes séries.
Les PLD, CPLD et FPGA sont parfois considérés comme des ASIC par certains auteurs.
3
 La figure ci-dessous tente une classification possible des circuits numérique :

Nous nous intéresserons surtout aux circuits à architecture programmable à faible temps
Figure 1 Classification des circuits numérique
de développement. Le principe de base des circuits nous intéressant ici consiste à réaliser des
connexions logiques programmables entre des structures présentant des fonctions de bases. Le
premier problème va donc être d'établir ou non suivant la volonté de l'utilisateur, un contact
électrique entre deux points. Aussi, nous intéresserons nous, avant de passer aux circuits
proprement dits et à leur programmation, à ces technologies d'interconnexion.
Mais avant toutes choses, rappelons comment coder une fonction logique.

3- Codage d'une fonction logique :

La base d'une fonction logique, est toujours une fonction combinatoire. Pour obtenir une
fonction séquentielle, il suffira ensuite de réinjecter les sorties sur les entrées, ce qui donnera
alors un système asynchrone. Si on souhaite un
système synchrone, on intercalera avant les sorties,
une série de bascules à front, dont l'horloge
commune synchronisera toutes les données et
évitera bien des aléas de fonctionnement.
Pour coder une fonction combinatoire, trois
solutions sont classiquement utilisées.
N'importe quelle fonction peut être codée
par une somme de produit, par un produit de
somme ou un mélange des deux. On peut
immédiatement en déduire une structure de
circuits, appelé matrice PLA (Programmable Logic
Array). La figure suivante représente une matrice
PLA à 4 entrées et 4 sorties :

Figure 2 codage d'une fonction logique

4
 4- Architectures utilisées :
4-1- PLD (Programmable Logic Device) :

Comme nous l'avons vu, d'abord appelés PAL lors de sa sortie, ce circuit utilise le principe
de la matrice PLA à réseau ET programmable. Bien que pas très anciens pour les dernières
générations, les PLD ne sont presque plus utilisés pour une nouvelle conception. L'un de leur
avantage qu'était la rapidité a disparu, les efforts de recherche des constructeurs portant plutôt
sur les circuits à plus forte densité d'intégration que sont les CPLD et les FPGA.
Le fait que les PLD soient à la base de la conception des CPLD, très en vogue aujourd'hui,
justifie cependant leur étude.
Initialement bipolaire, les cellules de connexions sont aujourd'hui réalisées en
technologie MOS à grille flottante. La structure de base comprend un circuit PLA dont seule la
matrice ET est programmable.
Le multiplexeur 4 vers 1 permet de mettre en circuit ou non la bascule D, en inversant
ou pas Les signaux. Le multiplexeur 2 vers 1 permet de réinjecter soit la sortie, soit l'entrée du
buffer de sortie vers le réseau programmable.

Figure 3 PLD (Programmable Logic Device)

4-2- CPLD (Complex Programmable Logic Device) :

La nécessité de placer de plus en plus de fonctions dans un même circuit a conduit tout
naturellement à intégrer plusieurs PLD (blocs logiques) sur une même pastille, reliés entre eux
par une matrice centrale.
Sur la figure suivante chaque bloc LAB (Logic Array Block) de 16 macrocellules est
l'équivalent d'un PLD à 16 OLMC. Ils sont reliés entre eux par une matrice d'interconnexion (PIA
pour Programmable Interconnect Array).
Un seul point de connexion relie entre eux les blocs logiques. Les temps de propagation
d'un bloc à l'autre sont donc constants et prédictibles.
La phase de placement des différentes fonctions au sein des macrocellules n'est donc pas
critique sur un CPLD, l'outil de synthèse regroupant au maximum les entrées sorties utilisant des
ressources communes.

5
 Figure 4 CPLD (Complex Programmable Logic Device)

4-2- FPGA :

Les FPGA (Field Programmable Gate Arrays ou "réseaux logiques programmables") sont
des composants VLSI entièrement reconfigurables ce qui permet de les reprogrammer à volonté
afin d'accélérer notablement certaines phases de calculs.
L'avantage de ce genre de circuit est sa grande souplesse qui permet de les réutiliser à volonté
dans des algorithmes différents en un temps très court.
Le progrès de ces technologies permet de faire des composants toujours plus rapides et à plus
haute intégration, ce qui permet de programmer des applications importantes.

Les circuits FPGA sont constitués d'une matrice de blocs logiques programmables
entourés de blocs d'entrée sortie programmable. L'ensemble est relié par un réseau
d'interconnexions programmable. Les FPGA sont bien distincts des autres familles de circuits
programmables tout en offrant le plus haut niveau d'intégration logique.

Il y a 4 principales catégories disponible commercialement :

- Tableau symétrique.
- En colonne.
- Mers de portes.
- Les PLD hiérarchique.

Figure 5 Les différentes classe de FPGA

6
 Voici la structure interne d'un FPGA de type matrice symétrique. Il s'agit de l'architecture
que l'on retrouve dans les FPGA de la série XC4000 de chez Xilinx.

Figure 6 Structure interne

L'utilisateur peut programmer la fonction réalisée par chaque cellule (appelée CLB par
Xilinx: Configurable Logic Block):

Figure 7 Schéma bloc

On programme aussi les interconnexions entre les cellules :

Figure 8 Les interconnexions entre les cellules d'un FPGA

Anisi que les entrées et sorties du circuit. L'avantage des FPGA est de pouvoir être
configuré sur place, sans envoi du circuit chez le fabricant, ce qui permet de les utiliser quelques

7
minutes après leur conception. Les FPGA les plus récents sont configurables en une centaine de
millisecondes. Les FPGA sont utilisés pour un développement rapide et bon marché des ASIC.
Inventés par la société Xilinx,le FPGA, dans la famille des ASICs, se situe entre les réseaux
logiques programmables et les prédiffusés. C'est donc un composant standard combinant la
densité et les performances d'un prédiffusé avec la souplesse due à la reprogrammation des PLD.
Cette configuration évite le passage chez le fondeur et tous les inconvénients qui en découlent.

5- Carte électronique ALTERA :

Altera est un fabricant de composants reprogrammables (FPGA, CPLD). Dans ce domaine,
il est en concurrence avec Xilinx, Actel, Lattice ou encore Atmel (appartenant
à Microchip depuis janvier 2016). Altera est aussi à l'origine du processeur softcore NIOS et
du bus Avalon.

Figure 9 carte électronique ALTERA cyclone II

Tableau 1 la famille cyclone

8
 6- SOFTWAR « QUARTUS » :
Quartus est un logiciel proposé par la société Altéra, permettant la gestion complète d’un
flot de conception CPLD ou FPGA. Ce logiciel permet de faire une saisie graphique ou une saisie
texte (description VHDL) d’en réaliser une simulation, une synthèse et une implémentation sur
cible reprogrammable.
L'écriture du code d'un bloc fonctionnel en langage VHDL obéit à une structure immuable.
De ce fait, on peut aisément écrire un générateur plus ou moins sophistiqué pour s'affranchir de
la part rébarbative de ce travail. Il est même possible de générer également le squelette d'un
programme permettant de tester le module. C'est ce que permet le programme QUARTUS
Plusieurs techniques d’entrée
✓ Textuelles : VHDL, Verilog, AHDL.
✓ Editeur de schéma – Synthèse logique – Placement et routage – Simulation
– Analyse temporelle et puissance dissipée – Création de la “netlist” pour
l’analyse temporelle – Programmation du composant.
✓ ISE (Xilinx) a des caractéristiques semblables.

Figure 10 Interface Quartus

9
6-1- Création d'un nouveau projet :

File New Project Wizard OK

Cliquer sur Next puis quand la fenêtre Add Files apparaît recliquer sur Next.

Next Quand la fenêtre EDA Tool Settings apparaît cliquer sur Next une fenêtre
recapitulative apparaît:

10
6-2- Saisie d’un projet :

6.2.1- Création d'un fichier VHDL :

File New

Une fois le code VHDL saisie, il convient de le sauver (File puis Save As) puis d’en vérifier
la syntaxe.

6-3- Compilation :
Durant la compilation, Quartus va réaliser 4 étapes :
✓ La transformation des descriptions graphiques et textuelles en un schéma électronique
à base de portes et de registres : c’est la synthèse logique.
✓ L’étape de Fitting (ajustement) consiste à voir comment les différentes portes et
registres (produit par la synthèse logique) peuvent être placés en fonction des
ressources matérielles du circuit cible (EP2C20F484C7) : c’est la synthèse physique.
✓ L’assemblage consiste à produire les fichiers permettant la programmation du circuit. Ce
sont des fichiers au format Programmer Object Files (.pof), SRAM Object Files (.sof),
Hexadécimal (Intel-Format) Ouput Files (.hexout), Tabular Text Files (.ttf), et Raw Binary
Files (.rbf). Dans notre cas, nous utiliserons toujours le format SOF pour les FPGA et le
format POF pour les CPLD.
✓ L’analyse temporelle permet d’évaluer les temps de propagation entre les portes et le
long des chemins choisis lors du fitting.

11
6-4- Simulation d'un circuit :

✓ La partie du circuit à simuler doit être munie de pins d'entrée/sortie.

✓ Elle doit aussi se trouver au niveau le plus élevé de la hiérarchie. Si ce n'est pas le cas,
pour l'y mettre : dans le "Project Navigator", cliquer avec le bouton droit de la souris sur
le nom du fichier, puis sur Set as Top-Level Entity.
✓ Il faut également vérifier qu'il n'y ait pas d'erreur dans le circuit en cliquant sur Processing
puis sur Start, et enfin sur Start Analysis & Elaboration.
✓ Le circuit étant prêt, il faut maintenant créer le fichier contenant les informations sur les
signaux à appliquer sur les entrées du composant et la liste des signaux que l'on veut
analyser.

Cliquer sur File puis sur New

12
Dans la catégorie "Filter", choisir all names. Cliquer ensuite sur le bouton List.
Ajouter les signaux souhaités dans la fenêtre Selected Nodes, en cliquant sur.
Cliquer sur OK pour fermer les différentes fenêtres et revenir à l'éditeur de signaux.
Afin de simuler le design, il convient de lui injecter des stimuli. Lorsque ces stimuli sont générés
à partir d’un fichier on dit que l’on utilise un fichier de Bench.
6-5- Simulation Fonctionnelle :

Conclusion :
Dans ce chapitre nous avons présenté les différents circuits logiques programmables et
conclure que la technologie FPGA s’inscrit au sommet de l’évolution des composants logiques
programmables et ouvrent de grandes perspectives en termes de cout, rapidité et le contrôle
en temps réel.

13
Chapitre 2 :
Travaux pratiques

14
 1- TP1 : Porte ET :
1-1- Introduction :

L’objectif de cette séance est de se familiariser avec le langage VHDL et ses particularités.
Lors de cette séance, nous avons passé en revue quelques exemples simples. Nous continuons
toujours avec des descriptions simples, mais mettant en évidence à chaque fois une particularité
du langage, pour ce qui concerne la première partie. La seconde partie présente des notions
avancées c’est d’essayer de programmer une porte logique ET sous Quartus.

Figure 11 Désignation d'une porte logique ET

1-2- Code :

library IEEE;

use IEEE.std_logic_1164.all;

entity porte_et is

port( ent1:in std_logic;

ent2:in std_logic;

sortie:out std_logic);

end porte_et;

architecture arch_porte_et of porte_et is

begin

sortie<=ent1 and ent2;

end arch_porte_et;

15
 Figure 12 Code porte ET

1-3- Simulation :

Figure 13 Simulation de la porte ET

1-4- Conclusion :

Pour décrire une fonction logique combinatoire ou séquentielle, nous connaissons

plusieurs représentations : Table de vérité ou table de transitions, Logigrammes,
chronogrammes, diagramme d’états, textes etc.…Ce langage est utilisé pour développer les
circuits logiques programmables.
A partir d’un fichier VHDL, un outil de développement informatique nous permettra la
programmation d’un circuit logique programmable. Ce qui nous à aider à franchir le
comportement de la porte logique AND sous le logiciel Quartus.

16
 2- TP2 : Porte XOR :
2-1- Introduction :

L’objectif de cette séance est d’améliorer nos compétences requis à la première séance
avec le programme de la porte logique ET. Cette fois on a essayés de programmer la porte logique
XOR « OU EXCLUSIF ».

Figure 14 symbole de la porte logique XOR

2-2- Code :

library IEEE;
use IEEE.std_logic_1164.all;
entity porte_xor is
port( ent1:in std_logic;
ent2:in std_logic;
sortie:out std_logic);
end porte_et;
architecture arch_porte_xor of porte_xor is
begin
sortie<=ent1 xor ent2;
end arch_porte_xor;

Figure 15 Code porte XOR

17
2-3- Simulation :

Figure 16 Simulation de la porte XOR

2-4- Conclusion :

À travers ce deuxième, TP on est arrivé à bien maitriser le travail sur le logiciel et la

programmation des portes logiques.

3- TP3 : Bascule D :
3-1- Introduction :
Dans cette séance on à essayer de valider nos compétances requis dans les séances
précédantes. Dans cette séance on a travaillé sur la déscription structurelle en VHDL, à travers la
liaison entre la porte logique ET et la bascule D.

Figure 17 Bascule D

3-2- Code :
library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity bascule is port (
D : in std_logic;
CE : in std_logic;

18
H : in std_logic;
Q : out std_logic;
CLR : in std_logic);
end bascule;
architecture arch_bas of bascule is
begin
process(CLR,CE,H)
begin
if CLR='1' then Q<='0'; else
if CE='1' and (H='0' and H'event) then Q<=D;
end if;
end if;
end process;
end arch_bas;

Figure 18 Code bascule D

3-4- Code porte ET :

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity porteEt is port (
E1 : in std_logic;
E2 : in std_logic;
S : out std_logic);
19
end porteEt;
architecture arch_porteEt of porteEt is
begin
s<=E1 and E2;
end arch_porteEt;

Figure 19 Code porte ET

3-5- Code BASCULE D + porte ET :

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity general is port (
a : in std_logic;
b : in std_logic;
clkEn : in std_logic;
clk : in std_logic;
clear : in std_logic;
c : out std_logic);
end general;
architecture arch_gen of general is
signal D_interne : std_logic ;
component porteEt
port (
E1 : in std_logic;
E2 : in std_logic;

20
S : out std_logic);
end component;
component bascule
port (
D : in std_logic;
CE : in std_logic;
H : in std_logic;
CLR : in std_logic;
Q : out std_logic);
end component;
begin
etiq1 : porteEt port map(E1 => a,E2 => b,s => d_interne);
etiq2 : bascule port map(H => clk,CE => clkEn,clr=>clear,D=>d_interne,Q=>C);
end arch_gen;

Figure 20 Code « Porte ET + Bascule D »

21
3-6- Simulation :

Figure 21 Simulation « Porte ET + Bascule D »

3-7- Conclusion :
Après avoir combiné ce que nous avons appris lors des dernières manipulations, cette
dernière manipulation semble facile.

4- TP4 : Calculatrice digitale :

4-1- Introduction :

Dans cette séance on a passé à programmer des petits programmes un peu plus
compliqués. Plus spécifique une calculatrice digitale

4-2- Code :

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity calc is port (
a: in std_logic_vector(7 downTo 0);
b : in std_logic_vector(7 downTo 0);
op : in std_logic;
s : out std_logic_vector(7 downTo 0));
end calc;
architecture arch_calc of calc is
begin
s<= a+b when op='0'
else a-b;
end arch_calc;
22
 Figure 22 Code calculatrice digitale

4-3- Simulation :

Figure 23 Simulation calculatrice digitale

23
 4-4- Conclusion :

Au tout début, nous avons eu un problème de manipulation, mais après quelques essais,
nous avons pu résoudre le problème.

5- TP5 : compteur 7 segment :

5-1- Introduction :

Dans cette séance on a programmé le compteur 7 segment de façon qu’il compte de 0 jusqu’à 9.

5-2- Code:

library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity affichage is port (
a : in std_logic_vector (3 downto 0);
b: out std_logic_vector(6 downto 0));
end affichage;
architecture arch_affich of affichage is
begin
process(a)
begin
if (a="0000") then b<="1000000";
elsif (a="0001") then b<="1111001";
elsif (a="0010") then b<="0100100";
elsif (a="0011") then b<="0110000";
elsif (a="0100") then b<="0011001";
elsif (a="0101") then b<="0010010";
elsif (a="0110") then b<="0000010";
elsif (a="0111") then b<="1111000";
elsif (a="1000") then b<="0000000";
elsif (a="1001") then b<="0010000";
end if;
end process;
end arch_affich;

24
 Figure 24 Code compteur

5-3- Simulation :

Figure 25 Simulation du code

5-4- Code compteur + 7 segments :

5-4-2- Code compteur :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_STD.ALL;
entity compteur is
port (H:in STD_LOGIC;
RST:in STD_LOGIC;
Q :buffer integer range 0 to 9;

25
Carry :out STD_LOGIC);
end compteur;
architecture arch_compteur of compteur is
begin
process (rst,h)
begin
if RST='1' then Q <= 0 ; carry <= '0';
elsif (H='0' AND H'event) then
if Q = 9 then Q <= 0 ; carry <='1' ;
else Q <= Q+1 ; carry <= '0';
end if;
end if;
end process;
end arch_compteur;

5-4-2- Code compteur :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_STD.ALL;
entity dec is
port ( e : in std_logic_vector(3 downto 0);
segment : out std_logic_vector(6 downto 0));
end dec;
architecture e_arch of dec is
begin
process(e)
begin
case e is
when "0000"=>segment<="1000000";
when "0001"=>segment<="1111001";
when "0010"=>segment<="0100100";
when "0011"=>segment<="0110000";
when "0100"=>segment<="0011001";
when "0101"=>segment<="0010010";
when "0110"=>segment<="0000010";
when "0111"=>segment<="1111000";

26
when "1000"=>segment<="0000000";
when "1001"=>segment<="0000100";
when others => segment<="1001000";
end case;
end process;
end e_arch;
5-4-3- Code diviseur de fréquence :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_STD.ALL;
entity div is
port ( Sv : in std_logic;
HZ : out std_logic);
end div;
architecture arch_div of div is
signal q1 : integer range 0 to 27000000;
begin
process (SV)
begin
if(SV='1' and SV' event) then
if q1<27000000 then q1 <= q1+1 ; hz<='0' ;
elsif q1=27000000 then q1<=0; hz<='1';
end if;
end if;
end process;
end arch_div;
5-4-4- Code général :
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.numeric_STD.ALL;
entity general is
port ( a : in std_logic;
b : in std_logic;
c : out std_logic_vector(6 downto 0)); library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

27
use IEEE.numeric_STD.ALL;
entity gen is
port ( a : in std_logic;
b : in std_logic;
r : out std_logic;
c : out std_logic_vector(6 downto 0));
end gen;
architecture general_arch of gen is
component dec
port ( e : in integer range 0 to 9;
segment : out std_logic_vector(6 downto 0));
end component;
component div is port
( Sv : in std_logic;
HZ : out std_logic);
end component;
component compteur is
port (H:in STD_LOGIC;
RST:in STD_LOGIC;
Q :buffer integer range 0 to 9;
Carry :out STD_LOGIC);
end component;
signal L : integer range 0 to 9;
signal z : std_logic;
begin
inst1 : div port map (a,z);
inst2 : compteur port map (z,b,l,r);
inst3 : dec port map (l,c);
end general_arch;

28
 5-5- Simulation :

Figure 26 simulation compteur 7 segments

5-5- Conclusion :

A la fin de cette séance, on est arrivé à programmer le compteur 7 segments.

6- Conclusion du chapitre :
Dans chapitre nous avons adopté une approche expérimentale pour implémenter notre
solution de suivi d’objet par une commande de moteur pas à pas.
Les algorithmes utilisés ont été validés par simulation sous le logiciel Quartus, le choix des
fonctions logiques binaire permet d’atteindre nos objectifs en un minimum de temps de
traitement.

29
 Conclusion générale
Le travail qui nous a été confié nous a permis de découvrir le monde de la programmation
des systèmes embarqués et le domaine du temps réel, nous avons eu l’occasion de programmer
expérimentalement un circuit logique programmable de type FPGA, sous l’environnement de
développement QUARTUS d’ALTERA sous différents modes de programmation.
Nous avons apporté de l’attention à la conception des blocs fonctionnels sur papier. Ainsi,
après avoir établi la structure des programmes, nous avons pu facilement définir les blocs.
Nous avons été surpris de voir la vitesse avec laquelle ces manipulations ont pu prendre
forme, comparé par exemple au temps qu’il faudrait pour réaliser les mêmes manipulations à
base de programmation de microprocesseur. Une fois les modèles établi, le passage du modèle
au VHDL s’est effectué sans problème.

30
 Bibliographie
✓ Rapport du cours VHDL du Mr EL KARI Abdeljalil
✓ Rapport-mp-vhdl-I2
✓ http://sebastien.bernard.free.fr/cours-tp-td-exo/Cours-E-Langage-description-VHDL.pdf
✓ https://fr.wikipedia.org/wiki/Wikip%C3%A9dia:Accueil_principal
✓ https://www.sigasi.com/?gclid=CjwKCAjwtdeFBhBAEiwAKOIy5zSWNkqddtbGZ7c9u4vMrDL0pR0
1OyybRa9JvlHZH7GArxTm-j6bjhoC2CcQAvD_BwE
✓ http://www.geii.eu/index.php?option=com_content&view=article&id=151&Itemid=695

31
ANNEXES

32
33