Systèmes Embarqués

Travaux Pratiques

Préparé par: Encadré par:

 Bensnah Soukayna  Mr Latif Rachid
 Addi Hamdi

Année Universitaire 2022 – 2023

TABLE DES MATIERES
LAB 0: 7 segment BCD decoder Décodeur BCD à 7 segments

I-Objectifs:
II- Principe de fonctionnement
III Compilation
 Code VHDL
 Explication
 Comparaison entre le post mapping\fitting

IV Simulation

Lab 1 : Commande Logique des LEDs

I. L’objectifs
[Link] de fonctionnement
III. Compilation
 Code VHDL
 Explication
 Comparaison entre RTL Viewr, Post-Mapping et Post-fitting
Résumé : Rapport de synthèse
 Etapes de compilation

[Link] 2: Simulation

2
Lab 2 :Additionneur 4 bits avec Affichage des Résultats

I.L’objectifs
[Link] defonctionnement:
III. Compilation
 Code VHDL
 Explication
 Comparaison entre RTL Viewr, Post-Mapping et Post-fitting
 Résumé : Rapport de synthèse
 Etapes de compilation

[Link] 2 : Simulation

Lab 3 : Compteur Modulo N

I.L’objectif s

[Link] de fonctionnement :

III. Compilation
 Code VHDL
 Explication
 Comparaison entre RTL Viewr, Post-Mapping et Post-fitting
 Résumé : Rapport de synthèse

IV. Simulation

3
 Lab0 : 7 segment BCD decoder
Décodeur BCD à 7segments

[Link]:

Ce TP vise à créer une description VHDL d'un décodeur BCD à 7 segments en utilisant les outils Quartus 2 et
Modelsim pour la compilation et la simulation, afin de se familiariser avec ces outils.

4
 II .Principe de fonctionnement

Convertir un nombre en format BCD (Binary Coded Decimal) en une représentation affichable
sur un écran à 7 segments. Le décodeur BCD reçoit en entrée un nombre en BCD sur plusieurs lignes
d'entrée et active les segments appropriés sur l'écran à 7 segments pour afficher le chiffre
correspondant. Chaque segment de l'écran est contrôlé par une sortie spécifique du décodeur BCD.

5
III Compilation

1 Code VHDL :

library IEEE;

use IEEE.std_logic_1164.all;
entity Lab0 is
port (
SW: in STD_LOGIC_VECTOR (3 downto 0);
HEX0: out STD_LOGIC_VECTOR (6 downto 0)
);
end Lab0;
architecture Lab0_arch of Lab0 is
begin
process(SW)
begin
case SW is
when "0000"=>HEX0<="0000001";
when "0001"=>HEX0<="1001111";
when "0010"=>HEX0<="0010010";
when "0011"=>HEX0<="0000110";
when "0100"=>HEX0<="1001100";
when "0101"=>HEX0<="0100100";
when "0110"=>HEX0<="0100000";
when "0111"=>HEX0<="0001111";
when "1000"=>HEX0<="0000000";
when "1001"=>HEX0<="0000100";
when others => HEX0<="1001000";
end case;
end process;

end Lab0_arch;

6
 2 Explication:
près avoir créé le projet dans Quartus 2, nommé "AtelierTP0", nous procédons à la création d'un fichier
VHDL que nous enregistrons sous le nom de "[Link]".
On écrit notre code tel que l’entité au même nom du fichier :

On compile le code afin de vérifier s’il est correct :

L’ensemble du rapport de compilation et d’analyse des performances sont dans cette fenêtre :

7
 La réussite de la compilation est exprimée par un message

Nous vérifions les informations du rapport de compilation, appelé Flow Summary, afin de s'assurer qu'il ne
contient aucune erreur après la compilation.

8
 3 Comparaison entre le post mapping\fitting :
Nous produisons la netlist des descriptions structurées du système, à la fois après le mappage (Post-Mapping) et
après l'ajustement (Post-Fitting).

Post-Mapping

Post-Fitting

4 Code VHDL :

9
 Lorsque nous voulons appliquer des contraintes de temps à notre conception dans TimeQuest
Timing Analyzer, nous avons deux options : une netlist post-fit ou une netlist post-map.
La netlist post-map est disponible après une simple synthèse de la conception. En revanche,
la netlist post-fit n'est disponible qu'après l'ajustement et contient des informations de synchronisation.
Le processus de mapping met en œuvre le comportement spécifié dans la technologie choisie,
mais n'affecte pas les ressources physiques spécifiques des éléments individuels. La simulation à ce
niveau modélise les délais de porte de manière assez précise, mais utilise des moyennes statistiques
pour les délais de câblage.

IV . Simulation
Apres la compilation de la descriptionappropriée ,on passe à la vérification du comportement temporel
et fonctionnel de description flot de données , structurelles et comportementales .

On lance le logiciel de simulation Modelsim et on fait appel au code compilé dans Quartus

10
 Le téléchargement du projet est nécessaire

11
 On commence la simulation on passons à la bibliothèque work

On sélectionne notre programme pour lancer la simulation

12
 nosentree et sorrties sont là

on sélectionne tout les signaux et fait add to wave pour les visualiser

13
 on modifie les propriétés de chaque signal ; couleur….

On définit les entrées Bcd de type Clock

14
 On execute

15
 Lab1 : Commande Logique des LEDs

16
 I. L’objectif s :
L'objectif de ce TP est de se familiariser avec les outils de conception et de découvrir les différentes technologies
FPGA. Pour l'implémentation embarquée, la carte utilisée dans ce TP est la FPGA-DE0 d'Intel-Altera, qui est de type
Cyclone III.

II. Principe de fonctionnement :

SW2 SW1 SW LE LED LED5 LED4 LED3 LED2 LED1 LED0

0 D7 6

0 0 0 0 0 0 0 0 0 0 1
0 0 1 0 0 0 0 0 0 1 0
0 1 0 0 0 0 0 0 1 0 0
0 1 1 0 0 0 0 1 0 0 0
1 0 0 0 0 0 1 0 0 0 0
1 0 1 0 0 1 0 0 0 0 0
1 1 0 0 1 0 0 0 0 0 0
1 1 1 1 0 0 0 0 0 0 0

Le SW représente l’entrée du système (Switch) et LED est la sortie de système.

17
III. Partie 1 : Compilation
1. Code VHDL

Library IEEE; architecture Behavioral of Lab1 is

;
use IEEE.std_logic_1164.all; begin

process(SW(0),SW(1),SW(2))

entity Lab1 is begin

port( LEDG(0) <= (NOT SW(0)) and (NOT SW(1)) and

(NOT SW(2)) ;
SW : in std_logic_vector(2 downto 0);
LEDG(1) <= (SW(0)) and (NOT SW(1)) and
LEDG : out std_logic_vector(7 downto 0)
(NOT SW(2)) ;
);
LEDG(2) <= (NOT SW(0)) and ( SW(1)) and
end Lab1 (NOT SW(2));

LEDG(3) <= ( SW(0)) and ( SW(1)) and (NOT

SW(2)) ;

LEDG(4) <= (NOT SW(0)) and (NOT SW(1)) and

( SW(2)) ;

LEDG(5) <= ( SW(0)) and (NOT SW(1)) and (

SW(2)) ;

LEDG(6) <= (NOT SW(0)) and ( SW(1)) and (

SW(2)) ;

LEDG(7) <= ( SW(0)) and ( SW(1)) and ( SW(2))

;

endprocess;

endBehavioral;

18
 2. Explication

Dans cette manipulation, nous allons expérimenter la commande des LED, qui seront déclarées en tant que
vecteur de sortie, à l'aide des interrupteurs qui seront également un vecteur de [Link] code au dessus est plus
au moins optimisé que celui-ci :

entity Lab1 is

port ( --- SW0 : in std_logic; --switch 0

--- SW1 : in std_logic;--switch 1

--- SW2 : in std_logic;--switch 2

-- LEDG0 : out std_logic; -- LED 0

-- LEDG1 : out std_logic;-- LED 1

-- LEDG2 : out std_logic;-- LED 2

-- LEDG3 : out std_logic;-- LED 3

-- LEDG4 : out std_logic;-- LED 4

-- LEDG5 : out std_logic;-- LED 5

-- LEDG6 : out std_logic;-- LED 6

-- LEDG7 : out std_logic -- LED 7 );

end Lab1;

19
 3. Comparaison entre RTL Viewr, Post-Mapping et Post-fitting
RTLViewer
Le niveau de transfert de registre (RTL) est une méthode de description des architectures microélectroniques.
Dans la conception RTL, le comportement d'un circuit est défini en termes d'envois de signaux ou de transferts de
données entre registres, ainsi que les opérations logiques effectuées sur ces signaux. Le RTL est utilisé dans les
langages de description matérielle (HDL) tels que Verilog et VHDL pour créer des représentations de circuits à
un niveau élevé, à partir desquelles des représentations à des niveaux inférieurs et le câblage réel peuvent être
dérivés.

Post-Mapping

Post-Fitting
Il est possible de voir le schéma avant et après l’intégration dans le FPGA. Tools – Netlist Viewers
- Technologie Map Viewver (Post Fitting). Quartus crée le symbole correspondant à la synthèse
obtenue.

Ça nous permet aussi de visualiser les LOGIC_CELL et r la structure logique après optimisation

20
21
 4. Résumé : Rapport de synthèse
Flow Summary

Analysis & Synthesis Summary

22
 Ressources Utilisation

Assembler Summary

TimeQuest Timing Analyzer Summary

23
IV. Simulation
Cette manipulation est basée sur l’outil de simulation ModelSim.

Nous avons crée un nouveau projet ModelSim, et nous avons ajouté le fichier vhdl compilé dans
la première partie contenant le code de la description VHDL.

Après la simulation voici le résultat :

24
On a ajouté tout les signaux à la partie Wave comme suit :

On utilise la fonction FORCE pour préciser les valeur des entrées et tester le résultat

Pour le switch 0, on a forcé la valeur 1

Pour le switch 1, on a forcé la valeur 1

Pour le switch 2, on a forcé la valeur 0

25
 Après la simulation, coici le résultat.

Selon la table de vérité proposé au début dans le cas de SW = 011 , on aura la LED 3 qui sera
allumée.

Dans le cas SW=000, on aura la LED 0

26
 Cette fois si, on va désactiver le FORCE, et on va travaillé avec le clock ; qu’on va régler comme
suit :

Clk SW0 =100

Clk SW1=75

Clk SW2 =50

27
 Après la simulation , on aura un résultat avec le clock réglé pour ben visualiser les résultants
d’une façon arbitraire

28
 Lab2 : 7 segment BCD decoder
Décodeur BCD à 7segments

29
 I. L’objectifs
Le but de ce TP est de proposer une architecture d’un additionneur 4 bits avec affichage des résultats
dans les LEDs et afficheurs 7 segments via Quartus 2 d’Intel -Altera et ensuite passer à la simulation à
l’aide de MODELSIM.

La carte proposée dans ce TP pour l’implémentation embarquée est FPGA-DE0 d’Intel-Altera de type
Cyclone III.

II. Principe de fonctionnement:

Le principe de fonctionnement de ce TP est fondé sur un additionneur 4 bits. Les entrées de ce
système sont 8 switches (2 * 4 bits) est comme sortie les LEDs et 4 afficheurs 7 segments. Le mot à
afficher est le suivant : « S=XX ». XX représente la somme en décimal. Le reset permet la remise à
zéro des processus de cet additionneur.

III. Compilation

1 .Code VHDL
Le code VHDL que nous avons conçu pour Cette manipulation est le suivant :

library IEEE;

SW(4), SW(5), SW(6), SW(7), SW(8),

SW(9)) -- inputs

variable s: integer; -- initialiser s

PORT(
variablecout1:integer;--initialisercout1

outstd_logic_vector(4downto0);--sum,cout
cout3:integer;

downto0)--7segmentdisplaysfors -- initialiser cout3

); variable cout4: integer;

-- initialiser cout4

38
 --CATS DE RESULTATS S, CATS DE Cout

IF((SW(6)='1'xorSW(1)='1')xorSW(0)='1')THEN

s:=s+1;

cout1 := 0;

ELSIF(((SW(6)='1'xorSW(1)='1')andSW(0)='1')or(SW(6)='1'andSW(1)='1'))THEN s

:=0;

cout1:=1;

ELSIF(SW(6)='1'andSW(1)='1'andSW(0)='1')THEN--specialcase

s:=s+1;

cout1 := 1;

end if;

IF ((SW(7) = '1' xor SW(2) = '1') or cout1 = 1) THEN

s:=s+2;

cout2 := 0;

ELSIF(((SW(7)='1'xorSW(2)='1')andcout1=1)or(SW(7)='1'andSW(2)='1'))THEN

s:=s+0;

cout2 := 1;

ELSIF(SW(7)='1'andSW(2)='1'andcout1=1)THEN--specialcase

s:=s+2;

cout2 := 1;

end if;

39
 --sLEDSturnon/off,7-Segmentdisplay

IFs=0THEN

LEDG(0) <= '0'; -- "string", 'int'

LEDG(1)<='0';

LEDG(2)<='0';

LEDG(3)<='0';

HEX0<="1000000";--'0'

HEX1<="1111111";--OFF

ELSIF s = 1 THEN

ELSIFs=15THEN LEDG(0)

<='1';

LEDG(1)<='1';

LEDG(2)<='1';

LEDG(3)<='1';

HEX1 <= "1111001"; -- '1'

HEX0<="0010010";--'5' END IF;

HEX3<="0010010";HEX2<="1011011";

ENDPROCESS;

END FULADDER;

40
41
 2. Explication
Dans cette manipulation nous allons réaliser l’opération d’addition de deux nombres A et B de 4
bits chacun et puis afficher le résultat de la sommation dans 4 afficheurs 7 segments deux indiquant
le résultat et les autres pour afficher « S= »

LIBRARY ieee; Begin --component instantiation

USE ieee.std_logic_1164.all; I1:comparator port map (Comp_in=>link,

z=>outComp);
use work.circuit_components.all;
I2:CircuitAportmap(CircA_in=>link(3
entity lab2 is downto0),CircA_out=>outCircuitA);
port (SW : in std_logic_vector(8 downto 0); I3:muxportmap(a=>link(3),
HEX0,HEX1,HEX2,HEX3:outstd_logic_vector(0to6); b=>outCircuitA(3),
s=>outComp,m=>outMux(3));
LEDG:outstd_logic_vector(8downto0));
I4:mux port map (a=>link(2),
end; b=>outCircuitA(2), utComp,m=>outMux(2));

architecture behavior of lab2 is

--signal statement

signal outComp,c1,c2,c3 : std_logic;

signaloutCircuitA:std_logic_vector(3downto0);

signaloutMux:std_logic_vector(3downto0);

42
 3. Comparaison entre RTL Viewr, Post-Mapping et Post-fitting
RTLViewer

43
Post-Mapping

44
Post-Fitting

Tools – Netlist Viewers - Technologie Map Viewver (Post Fitting). Quartus crée le symbole
correspondant à la synthèse obtenue.

Ça nous permet aussi de visualiser les LOGIC_CELL et la structure logique après optimisation

45
 4. Résumé : Rapport de synthèse

Flow Summary

Analysis & Synthesis Summary

46
 RessourcesUtilisation

Assembler Summary

47
 TimeQuest Timing Analyzer Summary

48
 5 .Etapes de compilation
Après la création d’un nouveau projet sous le nom de l’entité, nous avons ajouté ce code à ce
projet.

Puis nous avons compilé ce code, afin d’avoir le résultat suivant :

Nous avons généré Le Netlist des descriptions structurées de système, le RTL Viewer, le post
Mapping et le Post fitting qu’on a vu dans la partie précédente.

49
IV. Partie 2 : Simulation

Cette manipulation sera simulée par l’outil de simulation Modélisme.

Nous avons créé un nouveau projet Modélisme, et nous avons ajouté le fichier vhdl compilé dans
la première partie contenant le code de la description VHDL.

Après la simulation voici le résultat :

Après la réussite de la compilation du

code, on a visualisé le code pour
s’assurer.

Par la suite on s’est assuré des

Entrées ET sorties.

50
 On a ajouté tous les signaux à la partie Wave comme suit :

On utilise la fonction FORCE pour préciser les valeurs des entrées et tester le résultat Pour le

switch 0, qui désigne le reste, on a forcé la valeur 0

Pour le switch 2et le switch 6, on a forcé la valeur 1

Pour les autres switch (SW2 …SW9), on a forcé la valeur

51
Après la simulation, voici le résultat.

L’opération d’addition du nombre 1 avec le nombre 2 avec un reste 0 dans le cas de SW =

0001000100, on aura la LED 0 LED 1 qui seront allumées. Ce qui présente le nombre 3 en binaire,

l’afficheur HEX0 affiche le nombre 3 et l’autre afficheur HEX1 est éteint.

52
 Dans le cas SW=1000000011, la sommation du nombre 8 avec le nombre 1 avec un reste de 1
on aura la LED 1 et LED 3 allumées alors on a le résultat 10 affiché.

53
 Lab3 : Compteur Modulo N
Travail

54
55
 I. L’objectif du TP :

L’objectif de ce TP est de proposer une architecture d’un compteur modulo N avec affichage des
résultats dans les LEDs et des afficheurs 7 segments via Quartus II d’intel-Altera et de validercette
architecture en utilisant l’outil de simulation ModelSim. Le but de la partie II est l’implémentation
embarquée de l’architecture proposée d’un compteur modulo N avec affichage des résultats dans
les LEDs et les afficheurs 7 segments.

II. Principe de fonctionnement :

Le principe de fonctionnement de ce TP est basé sur un compteur modulo N. Le compteur a

comme limite de compter de 0 à 30 selon le choix de l’utilisateur. Si le choix dépasse cette limite,
l’afficheur affiche une erreur sinon il affiche le résultat de comptage de l façon suivante :

C = XX
XX représente le résultat en décimal. En cas d’erreur

XX = Er
Le reset permet la remise à zéro du compteur.

 Le SW représente l’entrée du système ou l’utilisateur va indiquer le N à compter.

 Le reset sera un bouton Key.

56
 III. Partie 1 : Compilation
1. Code VHDL
Le code VHDL que nous avons conçu pour cette manipulation est le suivant :
library IEEE;

use IEEE.std_logic_1164.all;

use IEEE.numeric_std.all;

entity LAB_3 is

port

CLOCK_50 : in std_logic;

KEY0: in std_logic;

SW : in std_logic_vector(4 downto 0);

HEX0, HEX1, HEX2,HEX3: out std_logic_vector(6 downto 0);

LEDG : out std_logic_vector(4 downto 0)

);

end entity;

architecture arc of LAB_3 is

signal q :unsigned (7 downto 0);

signal q_int :unsigned (7 downto 0);

signal tmp : unsigned (7 downto 0);

signal e :unsigned (1 downto 0);

signal err : unsigned (1 downto 0);

begin

--q_int <= "00000000";

process (CLOCK_50,KEY0,SW,q_int)

variable SW_int : integer;

variable q_int_int : integer;

begin

SW_int := to_integer(unsigned(SW));

if (SW_int < 31) and (SW_int > 0) THEN

57
 e <= "00";
end if;
if KEY0 = '0' then
end if;
q_int <= (others =>'0');
end if;

HEX3 <= "1000110";

elsif rising_edge (CLOCK_50) then
HEX2 <= "0110111";
_int <= q_int + 1;
CASE affichage IS

WHEN 1 =>
q_int_int := to_integer(unsigned(q_int));
LEDG <= "11110";
if (q_int_int = SW_int) then
WHEN 2 =>
q_int <= (others =>'0');
LEDG <= "11101";

WHEN 3 =>
end if;
LEDG <= "11100";
end if;
WHEN 4 =>
elsif (SW_int >30 ) or (SW_int < 0) then
LEDG <= "11011";
e <= "11";
WHEN 5 =>
end if;
LEDG <= "11010";
end process;
WHEN 6 =>
q <= q_int;
LEDG <= "11001";
tmp <= q_int;
WHEN 7 =>
err <= e;
LEDG <= "11000";
process (tmp,err)
WHEN 8 =>
variable affichage :integer;
LEDG <= "10111";
begin
WHEN 9 =>
if ( err = "00") then
LEDG <= "10110";
affichage := to_integer(unsigned(tmp));
WHEN 10 =>
CASE affichage IS
LEDG <= "10101";
WHEN 0 | 10|20 |30 =>
WHEN 11 =>
HEX0 <= "1000000";
LEDG <= "10100";
WHEN 1 |11|21 =>
WHEN 12 =>
HEX0 <= "1111001";
LEDG <= "10011";
WHEN 2|12|22 =>
WHEN 13 =>
HEX0 <= "0100100";
LEDG <= "10010";

58
 WHEN 3|13|23=> WHEN 14 =>

HEX0 <= "0110000"; LEDG <= "10001";

WHEN 4|14|24 => WHEN 15 =>

HEX0 <= "0011001"; LEDG <= "10000";

WHEN 5|15|25 => WHEN 16 =>

HEX0 <= "0010010"; LEDG <= "01111";

WHEN 17 =>

WHEN 6|16|26 => LEDG <= "00010"; LEDG <= "01110";

HEX0 <= "0000010"; WHEN 18 =>

WHEN 30 =>
WHEN 7|17|27 => LEDG <= "01101";

HEX0 <= "1111000"; WHEN 19 =>

LEDG <= "00001";
WHEN 8|18|28 => LEDG <= "01100";

WHEN OTHERS => WHEN 20 =>

HEX0 <= "0000000";

WHEN 9|19|29 => LEDG <= "01011";

LEDG <= "11111";
HEX0 <= "0010000"; WHEN 21 =>

WHEN OTHERS => END CASE; LEDG <= "01010";

HEX0 <= "1111111"; WHEN 22 =>

END CASE; LEDG <= "01001";

elsif (err = "11") then
if (affichage>0) and (affichage<10) then WHEN 23 =>
HEX0 <= "1010000";
HEX1 <= "1000000"; LEDG <= "01000";

else if (affichage>9) and (affichage<20) then HEX1 <= "0000110"; WHEN 24 =>

HEX1 <= "1111001"; LEDG <= "00111";

HEX3 <= "1000110";
else if (affichage>19) and (affichage<30) then WHEN 25 =>

HEX1 <= "0100100"; HEX2 <= "0110111"; LEDG <= "00110";

else if (affichage=30) then HEX1 <= "0110000"; WHEN 26 =>

LEDG <= "00000";
end if; LEDG <= "00101";
end if ;
WHEN 27 =>

end process;
LEDG <= "00100";
end arc;
WHEN 28 =>

LEDG <= "00011";

WHEN 29 =>

59
 Après la compilation du code propose, sous Le cyclone IV E , on aye le résultat de compilation
suivant

60
 2. Explication détaillée

Dans cette manipulation nous allons essayer de créer un compteur modulo N. Le N est un nombre
entier compris entre 0 et 30 entré par l’utilisateur.

Du coup, une erreur doit être déclenché une fois l’utilisateur entre une valeur hors de la marge
mentionnée

Nous avons créer pour cela une variable pour la gestion de l’erreur.

Le résultat du compteur doit être affiché sur des 7 Segments nombre par nombre selon le clock.

C = XX

If N 30 alors XX =Er

Généralement nous alons basé notre code sur un compteur asynchrone modulo 8,et on va changer
8 par la valeur entrée par l’utilisateur.

61
 3. Comparaison entre RTL Viewr, Post-Mapping et Post-fitting
RTLViewer

Register Transfer Level (RTL) est une méthode de description des architectures
microélectroniques.

Dans la conception RTL, le comportement d'un circuit est défini en termes d'envois de signaux ou
de transferts de données entre registres, et les opérations logiques effectuées sur ces signaux. Le RTL
est utilisé dans les langages de description matérielle (HDL) comme Verilog et VHDL pour créer
des représentations d'un circuit à haut niveau, à partir duquel les représentations à plus bas niveau et
le câblage réel peuvent être dérivés.

Post-Mapping

62
Post-Fitting

Il est possible de voir le schéma avant et après l’intégration dans le FPGA. Tools – Netlist
Viewers - Technologie Map Viewver (Post Fitting).

Quartus crée le symbole correspondant à la synthèse obtenue.

Ça nous permet aussi de visualiser les LOGIC_CELL et r la structure logique après optimisation.

63
 4. Résumé :Rapport de synthèse
Flow Summary

Analysis & Synthesis Summary

64
 Fitter Summary

TimeQuest Timing Analyzer Summary

65
 Assembler Summary

5. Etapes de compilation
Après la création d’un nouveau projet sous le nom de l’entité, nous avons ajouté le code à ce
projet.

Puis nous avons compilé ce code, pour finalement avoir le résultat suivant :

Nous avons générer Le Netlist des descriptions structurées de système à savoir le RTL Viewer,
le post Mapping et le Post fitting qu’on a vu dans la partie précédente.

66
 IV. Partie 2: Simulation

Cette manipulation est basée sur l’outil de simulation ModelSim.

Nous avons crée un nouveau projet ModelSim, et nous avons ajouté le fichier vhdl compilé dans
la première partie contenant le code de la description VHDL.

Après la simulation voici le résultat :

Après la compilation du
code, on a visualisé le
code pour s’assurer.

Par la suite on s’est

assuré des entrées et
sorties qu’on ajouté à la
fenêtre wave pour

67
 On a ajouté tout les signaux rentrée sorties à la partie Wave comme suit :

On utilise la fonction FORCE pour préciser les valeur des entrées et tester le résultat

Pour le switch , c’est l’entrée qui va prendre la valeur N préciser par l’utilisateur, alors dans la
simulation on peut la forcer à n’importe quelle valeur nous voulons, dans ce cas nous allon essayer
la valeur 3 en décimal , alors SW =00011

Le Clock sera aussi configuré.

Alors que Key est un boutton qui fait la tache du RESET A lors avant de commencer on le remet
à 0 pour initialiser le signal interne q à 0.

Puis on le remet à 1 et on observe les changements.

68
 KEY = 0 SW = 00011 clock= 0101010101010101010101010100101….. err = 00

KEY = 1 SW = 00011 clock= 0101010101010101010101010100101….. err = 00

Les Afficheurs 7 segments afficheront C = XX , XX c’est la valeur en décimal

Quand le key est remis à zero, les valeurs commence à changer à chaque implusion du clock, et
il compte de 0 à 3.

69
 EY = 1 SW = 11111 clock= 0101010101010101010101010100101….. err =11

Ici l’erreur = 11, alors la valeur entrée par l’utilisateur est supérieure à 30.

Alors les hex afficheront : C = ER

70
71