Master IESE

2024-2025

COMPTE RENDU
FPGA

Réalisé par :
Meryame El Haji
Encadré par :
Iman Khalid
Zakaria Bak Pr Mouhcine Razi
 Introduction :
Les FPGA (Field Programmable Gate Array) sont des circuits intégrés numériques configurables par
l'utilisateur après leur fabrication. Contrairement aux circuits classiques à logique fixe, ils offrent une
grande flexibilité en permettant de personnaliser leur architecture selon les besoins spécifiques.
Composés de blocs logiques programmables, de réseaux d'interconnexion et de blocs mémoire, les
FPGA permettent une exécution parallèle, ce qui les rend particulièrement performants pour les
applications nécessitant un traitement intensif. Leur capacité de reprogrammation les rend idéaux
pour le prototypage et les projets évolutifs.

BUT DE TP :
Au cours de ce TP d'initiation aux FPGA, nous allons utiliser la carte électronique embarquant un
circuit FPGA de la société Altera et étudier son fonctionnement de base .

Matérielle :
La suite des logiciels altera QUARTUSE 2

Une carte de développement DE2-115

Le manuel de la carte DE2-115

I. Tp1 :
1. « 7-segment »
Après l'installation du driver USB Blaster, nous avons créé un nouveau
projet où nous allons enregistrer notre travail. Dans ce projet, nous
créons un fichier de type « Block Diagram/Schematic File », dans lequel
nous allons concevoir notre schéma.

• Pour réaliser l’affichage d’un chiffre sur un afficheur 7 segments, il suffit

d’allumer les bons segments LED correspondants sur l’afficheur.
 ➢ Pour afficher le nombre 1 :

Lorsque notre carte est activée à l'état 1, nous avons inséré

5 sorties de type PIN/Output, et nous avons relié le VCC à
la sortie. Ainsi, la branche S que nous relierons au
segment de l'afficheur correspondant sur la carte sera
connectée à la masse.

Après la description du schéma, nous devons indiquer au

logiciel à quelles broches réelles du FPGA correspondent les
sorties que l'on a définies dans le circuit. Cela se fait en suivant
le manuel pour savoir comment connecter l'afficheur
correctement.

Résulta :

D'après la réalisation du schéma et la configuration des portes, nous compilons

notre projet. Ensuite, nous passons à la programmation du FPGA et lançons
l'exécution pour obtenir le résultat suivant (la photo à gauche). Comme nous
avons déjà mentionné, notre carte est activée à l'état 1, et nous devons attendre
que les autres segments s'allument pour afficher le chiffre 1, au lieu d'allumer
seulement les 2 segments du chiffre 1.

➢ Pour afficher le nombre 2 :

Pour afficher le nombre, nous suivons les mêmes étapes que celles indiquées précédemment.
Cette fois-ci, nous ajoutons simplement deux sorties supplémentaires dans le fichier de
schématique pour étendre les segments 5 et 2, afin d'afficher le nombre que nous souhaitons.
 Schéma :
connecter la porte :

2. Compteur de 7-segment :
Dans cette étape, nous avons créé un fichier de type VHDL où nous allons écrire le code VHDL. Ensuite,
il est également nécessaire de connecter les sorties et les entrées aux portes logiques appropriées de la
carte.

• Code vhdl :
3. Chenillard :
Dans un premier temps, on réalise ce programme en VHDL qui implémente un
"chenillard », un circuit qui fait défiler une séquence de LED allumées dans un ordre
précis.
4. Compteur décompteur
 Quand on clique sur le bouton poussoir, le décompte commence à partir de la valeur F, quelle que
soit la valeur présente avant le clic

Et quand on relâche, il commence à compter à partir de 0

Tp3 : finite state machine

Introduction :
· Machine à États Finis (FSM) :
L'élément central de l'architecture FPGA est la machine à états finis (FSM), qui contrôle la séquence de
transitions entre les différents états du système (par exemple, de INIT à V11, de V11 à V12, etc.). Le
signal d'horloge (Clk) synchronise ces transitions. Selon l'état actuel de la FSM, les sorties
correspondantes sont générées pour activer ou désactiver les feux (R1, V1, O1, etc.).

· Diviseur d'Horloge :
Un autre composant clé de l'architecture est le diviseur d'horloge, qui prend le signal d'horloge rapide
(Clk) et le divise pour créer des intervalles de temps plus longs, permettant de contrôler la durée
pendant laquelle chaque feu est allumé ou éteint. Cela permet un contrôle plus fin sur la
synchronisation des feux.

· Traitement des Entrées (API et Rst) :

Les entrées API et Rst sont intégrées dans l'architecture FPGA comme des déclencheurs pour des
changements d'état. Lorsque l'API est activé, la FSM répond en transitionnant vers un nouvel état qui
peut autoriser le passage piéton. Le signal de réinitialisation (Rst) force également la FSM à revenir à
l'état initial, réinitialisant ainsi tous les feux et préparant le système à un nouveau cycle.

· Sorties de Feux :
Selon l'état de la FSM et les valeurs des entrées, l'architecture FPGA génère les sorties de feux
correspondantes. Par exemple, si l'état actuel est V11, les feux verts V1 seront activés, et les feux rouges
R1 seront éteints, permettant aux véhicules de passer.

Gestion d’un carrefour

Au croisement de 2 routes, on place des feux tricolores :

R1 feu rouge de l’axe 1

O1 feu orange de l’axe 1

V1 feu vert de l’axe 1

R2 , O2, V2 idem pour l’axe 2

Fonctionnement:

Pour assurer le fonctionment on utilise un horloge d’une seconde .

V1 : dure 8S

V2 : dure 5s
Les feux oronge 1s .

L’axe 1:

vient de passer au vert.

V1 : 1 V2 : 0

R1 : 0 O2 : 0

O1 : 0 R2 : 1

Aprés 8s :

O1=1,

R2=1

Pendent 1s puis:

L’axe 2:

Vient de a:

V1 : 0 V2 : 1

R1 : 1 O2 : 0

O1 : 0 R2 : 0

Dure pendant une 17s

Vocie le cycle de fonctionent (les etats de machines)

 Implementation en vhdl :

1- CREATION DES ENTRés SORTIE EN QUARTUS

Après avoir défini les entrées et sorties du système, nous avons structuré leur rôle comme suit :

• API : Entrée principale (input). Ce signal est déclenché par l'intervention du passager pour
demander un changement d'état dans le système, par exemple pour traverser.
• Clk : Entrée d'horloge (input). Elle pilote la variation des états dans le système. Grâce à ce signal,
les transitions entre différents états sont synchronisées et contrôlées temporellement.
• O1, O2, R1, R2, V1, V2 : Sorties (outputs). Ces signaux représentent les feux routiers :
o O1, O2 : Les feux orange, utilisés pour signaler une transition imminente.
o R1, R2 : Les feux rouges, indiquant un arrêt obligatoire.
o V1, V2 : Les feux verts, autorisant la circulation ou le passage.
• Rst : Entrée de réinitialisation (input). Elle est reliée à un bouton permettant de redémarrer le
système à son état initial. Cette fonctionnalité est cruciale pour réinitialiser le système en cas
d'erreur ou d'arrêt d'urgence.
Voicie les entrés sorties selectioner en contrast avec l’archetecture de notre fpga

LE CODE VHDL ETULISER

LIBRARY ieee;

USE ieee.std_logic_1164.ALL;

USE ieee.numeric_std.ALL;

ENTITY carrefour IS

PORT (

clk, rst, API : IN STD_LOGIC;

R1, V1, O1 : OUT STD_LOGIC;

R2, V2, O2 : OUT STD_LOGIC

);

END carrefour;

ARCHITECTURE Arch OF carrefour IS

-- State declaration
 TYPE etat IS (INIT, V11, V12, V13, V14, V15, V16, V17, V18, OR1, SEC, V21, V22, V23, V24,
V25, OR2);

-- Signal declarations

SIGNAL etat_init, etat_futur : etat := INIT; -- Current and future state

SIGNAL div : unsigned(23 DOWNTO 0) := (OTHERS => '0'); -- Clock divider

-- Clock signal for internal use

SIGNAL clk_div : STD_LOGIC;

BEGIN

-- Clock division

PROCESS(clk, rst)

BEGIN

IF rst = '0' THEN

div <= (OTHERS => '0');

ELSIF rising_edge(clk) THEN

div <= div + 1;

END IF;

END PROCESS;

clk_div <= div(23); -- Divided clock signal

-- State transition logic

PROCESS(clk_div, rst)

BEGIN

IF rst = '0' THEN

etat_init <= INIT;

ELSIF rising_edge(clk_div) THEN

etat_init <= etat_futur;

END IF;

END PROCESS;

-- State machine logic

PROCESS(etat_init, API)

BEGIN

CASE etat_init IS

WHEN INIT =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

etat_futur <= V11;

WHEN V11 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

etat_futur <= V12;

WHEN V12 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

etat_futur <= V13;

WHEN V13 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

IF API = '0' THEN

etat_futur <= OR1;

ELSE

etat_futur <= V14;

END IF;

WHEN V14 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

IF API = '0' THEN

 etat_futur <= OR1;

ELSE

etat_futur <= V15;

END IF;

WHEN V15 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

IF API = '0' THEN

etat_futur <= OR1;

ELSE

etat_futur <= V16;

END IF;

WHEN V16 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

IF API = '0' THEN

etat_futur <= OR1;

ELSE

etat_futur <= V17;

END IF;

WHEN V17 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

IF API = '0' THEN

etat_futur <= OR1;

ELSE

etat_futur <= V18;

END IF;
WHEN V18 =>

V1 <= '0'; R1 <= '1'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

etat_futur <= OR1;

WHEN OR1 =>

V1 <= '1'; R1 <= '0'; O1 <= '0';

V2 <= '1'; R2 <= '0'; O2 <= '1';

etat_futur <= SEC;

WHEN SEC =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

etat_futur <= V21;

WHEN V21 =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

V2 <= '0'; R2 <= '1'; O2 <= '1';

etat_futur <= V22;

WHEN V22 =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

V2 <= '0'; R2 <= '1'; O2 <= '1';

etat_futur <= V23;

WHEN V23 =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

V2 <= '0'; R2 <= '1'; O2 <= '1';

etat_futur <= V24;

WHEN V24 =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

 V2 <= '0'; R2 <= '1'; O2 <= '1';

etat_futur <= V25;

WHEN V25 =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

V2 <= '0'; R2 <= '1'; O2 <= '1';

etat_futur <= OR2;

WHEN OR2 =>

V1 <= '1'; R1 <= '0'; O1 <= '1';

V2 <= '1'; R2 <= '0'; O2 <= '1';

etat_futur <= INIT;

WHEN OTHERS =>

etat_futur <= INIT; -- Default return to INIT

END CASE;

END PROCESS;

END Arch;

CODE VHDL DANS QUARTUS

Pour verifier le fonctionement de notre code on simule est en compart le resultat donner par notre
enoncer

Les états generer par le RTL sont

correct alors notre code
fonctionne correctement

Voici le montage généré pour obtenir le même résultat sans l'utilisation de FPGA :
Dans ce montage, nous avons utilisé des composants électroniques classiques tels que des résistances,
des condensateurs, des amplificateurs opérationnels, ou même des microcontrôleurs pour obtenir les
mêmes fonctionnalités qu'un FPGA. Ce montage permet de réaliser des opérations logiques ou des
traitements de signal de manière similaire, mais sans recourir à un FPGA. L'objectif de cette approche
est de trouver une solution alternative qui pourrait être plus économique ou plus facile à mettre en
œuvre_pour_des_applications_spécifiques.
 CONCLUSION
L’implémentation du code FPGA décrivant le fonctionnement de notre système dans Quartos a
grandement contribué à la conception pratique de notre système. L’émulateur fourni par Quartus est
un outil puissant, car il est capable de vérifier et même de synthétiser les états du système. De plus, il
génère automatiquement un montage résultant, ce qui facilite considérablement la tâche de
conception des circuits et réduit de manière significative le temps de développement.

Grâce à ses fonctionnalités avancées, Quartus permet d’effectuer des simulations fonctionnelles et
temporelles, ce qui aide à détecter et corriger les erreurs avant le déploiement physique sur un FPGA.
Cela évite les itérations coûteuses et chronophages sur du matériel réel. En outre, l'outil offre une
interface conviviale pour gérer des projets complexes, incluant des outils d'analyse des performances,
de routage, et de consommation énergétique.

L’utilisation de Quartus ne se limite pas à la validation logicielle. La possibilité de générer des fichiers
de configuration pour divers FPGA permet un déploiement rapide et efficace du design sur du matériel
réel.