Synthèse de l’horlogesudriaesme.free.fr/Signal et Telecom - Devriendt/tp/TP 8... · Web viewuse ieee.std_logic_unsigned.all; entity tb_compteur is end entity tb_compteur; architecture

Avice MathieuLacroix MargueriteMartin Damien3B SIS 03

TP8 : VHDL – Synthèse logique

Page 1/32


Sommaire

I. Travail préparatoire.............................................................................................................3A. Généralités....................................................................................................................3B. Description fonctionnelle.............................................................................................4C. Diagrammes de connexion.........................................................................................11

II. Horloge..........................................................................................................................12A. Schéma bloc fonctionnel............................................................................................12B. Principe de fonctionnement........................................................................................12

III. Compteur........................................................................................................................14A. Schéma bloc fonctionnel............................................................................................14B. Principe de fonctionnement........................................................................................15

IV. Synthèse avec isplever...................................................................................................16A. Synthèse de l’horloge.................................................................................................16B. Synthèse avec l’option Area.......................................................................................19C. Synthèse avec l’option Speed.....................................................................................20D. Post-simulation...........................................................................................................21E. Synthèse du compteur................................................................................................25

Page 2/32

Diviseur deFréquence

Compteur0 à 9

BCD/7SegmentsCS

EPLD 2EPLD 1

Afficheur des secondes

4 7

Dp

QUARTZ32768Hz

BoutonMin

4

Buzzer

Reset

Refresh

Horloge ½ s

Reset


I. Descriptif du TP

A. Objectifs

Ce TP à pour but la synthèse d’un programme VHDL. Ce programme devra simuler un compteur de 0 à 9 émettant un bip sonore à chaque incrémentation. Pour réaliser cette synthèse nous utiliserons 2 EPLD LATTICE de la famille ispMACH4A5 dont la description détaillée est donnée en 2ème partie du compte rendu. Le schéma bloc de l’ensemble du système est donné ci-après.

B. Schéma bloc

C. Précisions

L’EPLD 1 ne contiendra que le programme permettant de générer une horloge de période 1 seconde à partir d’un quartz de fréquence 32 768 Hz. A partir de cette

Page 3/32


horloge, on générera une horloge de période 2 fois plus courte (0,5 seconde) qui servira d’horloge pour l’EPLD 2.

L’EPLD 2 contiendra le programme permettant de compter de 0 à 9 ainsi que la fonction permettant la conversion BCD/7 segments nécessaire pour l’affichage.

Les principes de fonctionnement des programmes horloge et compteur sont expliqués respectivement en 3ème et 4ème partie du compte rendu.

Page 4/32


II. Travail préparatoire

A. Généralités

La famille ispMACH4A de Lattice offre une architecture flexible. Les composants qui la composent sont faciles d’usage, ce sont des solutions fiables et prédictibles pour les utilisateurs.Cette famille offre une densité de macro-cellules entre 32 et 152. Elle nous donne également le choix entre deux tensions d’alimentation : 3,3Volt et 5Volt. Dans notre TP les composants utilisés sont de type 5Volt, d’où leur nom : M4A5xx/32.Un des grands avantages de cette famille est qu’elle est compatible avec le standard JTAG norme 1149.1. Ce standard permet à l’utilisateur une programmation aisée du composant et un débugage facilité grâce à l’interface JTAG (Boundary Scan Test).

Caractéristiques principales des composants 5Volt de la famille ispMACH4 :

Nous utiliserons donc des composants ayant au maximum 64 macro-cellules, 32 I/O et usant du JTAG Compliant.

Page 5/32


B. Description fonctionnelle

L’architecture fondamentale des ispMACH4A est constituée de multiples PAL interconnectés par une matrice centrale. Cette matrice permet la communication entre les blocs PAL et les routes conduisant les entrées aux blocs PAL. Ensemble, les blocs de PAL et la matrice de commutation centrale permettent à l’utilisateur de créer une large gamme de design dans un dispositif simple au lieu de devoir utiliser des dispositifs multiples. On a ainsi le diagramme suivant le M4A5-64/32 :

Et le diagramme suivant le M4A5-32/32 :

Page 6/32


Les blocs PAL sont constitués ainsi :

Pour le M4A5-64/32 :

Page 7/32


Pour le M4A5-32/32 :

Page 8/32


Plus en détail, un bloc PAL est constitué de :

- Tableau product-termOu product-term array, est constitué d’un certain nombre de termes produit qui forment la base de l’implémentation logique.Les entrées viennent de la matrice centrale et fournissent une implémentation logique. En utilisant des portes AND on arrive à l’allocateur logique (logic allocator).

- Allocateur logiqueOu logic allocator, est l’étape entre les portes AND et les macro-cellules. Ainsi les product terms sont alloués aux macro-cellules grâce à un commutateur. Chaque commutateur product term est associé à une macro-cellule.Ce bloc peut fournir la logique XOR pour la comparaison de données. Mais il peut également travailler avec les bascules D et T pour fournir des opérations de registre S-R et J-K.

Configuration en mode synchrone (4 product terms pour un commutateur):

Configuration en mode asynchrone (2 product terms pour un commutateur):

Page 9/32


- Macro-cellulesOu macrocells, sont composées d’éléments de stockage, de ressources de routages, d’un multiplexeur d’horloge et d’un contrôle d’initialisation.Une macro-cellule a deux modes fondamentaux : synchrone et asynchrone. Le mode choisi affect l’horloge et l’initialisation de la macro-cellule.

Grâce aux macro-cellules, les composants de la famille M4A peuvent réaliser toutes les opérations de logique séquentielle, en offrant par exemple la possibilité de réaliser des bascules D et T synchrone ou asynchrone.Ainsi grâce au bloc [product term – allocateur] logique et à la macro-cellule, chaque bloc PAL peut réaliser toutes les fonctions combinatoires et séquentielles.

- Matrice de multiplexage de sortie Ou Output Switch Matrix, permet de connecter les macro-cellules aux cellules I/O. Cela permet une grande flexibilité dans la détermination des pinout et permet également des changements de design.

Page 10/32


- Cellules d’I/OOu I/O cells sont constituée différemment pour les deux EPLD utilisés.

La différence entre les deux est la présence pour le M4A5-64/32 d’un registre flip-flop qui donne la possibilité de garder en mémoire des données d’entrée.

- Matrice de multiplexage d’entrée Ou Input Switch Matrix, optimise le routage des entrées vers la matrice centrale. Cela permet d’avoir plus de un seul chemin pour entrer dans la matrice générale.

- Génératrice d’horloge Ou PAL Block Clock Generation. Sur nos deux composants, nous avons 2 pins d’horloge, qui peuvent également être utilisées comme des entrées. Ces pins conduisent un signal horloge dans chaque bloc PAL. La génératrice d’horloge fournit 2 signaux d’horloge qui peuvent être utilisés n’importe où dans le bloc PALCela donne une grande flexibilité, par exemple dans le partitionnement des machines d’état.

Page 11/32


C. Diagrammes de connexion

Diagramme de connexion de nos composants de type 44-PIN PLCC.

Avec :

CLK/I Horloge ou entréeGND MasseI/O Entrée/SortieVcc Tension d’alimentationTDI Test donnée entranteTCK Test horlogeTMS Test Mode SelectTDO Test donnée sortante

Page 12/32


III. Horloge

A. Schéma bloc fonctionnel

Signaux d’entrée :

clk_in : horloge de fréquence 32 768 Hz reset : signal asynchrone permettant une remise à zéro du système

Signaux de sortie

clk_sec : horloge de fréquence 1 Hz

B. Principe de fonctionnement

Etape 1 :

On cherche à obtenir à partir d’un oscillateur de fréquence 32 768 Hz une horloge de 1 s. L’idée première est donc de compter 32 768 fois l’impulsion de l’horloge entrante. Pour cela, on définit un signal interne sur 15 bits, 215 = 32 768, qui va servir de compteur d’impulsions du signal d’horloge entrant. Si l’on procède de cette manière le signal d’horloge ne possède pas un rapport cyclique de 50 %.

De ce fait, pour obtenir un rapport cyclique de 50%, il suffit de détecter lorsque le MSB passe de 0 à 1. Ainsi le temps où lequel l’horloge est à l’état 0 et identique à celui où l’horloge est à l’état 1, soit 0,5 seconde.

Page 13/32

HORLOGE clk_sec

reset

clk_in


D14

D13

D12

D11

D10 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0

0

0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0 0 0 0 0 0 0 0 1 00

0 0 0 0 0 0 0 0 0 0 0 0 1 1. . .. . .. . .0 1 1 1 1 1 1 1 1 1 1 1 1 1 00 1 1 1 1 1 1 1 1 1 1 1 1 1 11

0 0 0 0 0 0 0 0 0 0 0 0 0 01 0 0 0 0 0 0 0 0 0 0 0 0 0 1.

. .. . .. . .1 1 1 1 1 1 1 1 1 1 1 1 1 0 01 1 1 1 1 1 1 1 1 1 1 1 1 0 11 1 1 1 1 1 1 1 1 1 1 1 1 1 01 1 1 1 1 1 1 1 1 1 1 1 1 1 1

Il suffit alors d’assigner le MSB du compteur à clk_sec afin d’obtenir l’horloge à 1 Hz. Pour l’horloge à 4 Hz, il suffit d’assigner le 13ième bit, soit D12, du compteur à clk_quart_sec.

Etape 2 :

Dans la seconde étape du TP il faut afficher les chiffres de 0 à 9 avec une période de 0,5 secondes soit la moitié de la période précédente. De ce fait il suffit juste de changer le bit

Page 14/32

0.5 s

0.5 s


du compteur en décalant ce bit d’un pas vers la droite, on a alors réaliser une division par 2. C’est donc D13 qui sera assigné à clk_sec afin d’obtenir l’horloge de 2 Hz.

C. Code VHDL

Fichier comportemental :

library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_arith.all;use ieee.std_logic_unsigned.all;

entity horloge is port( clk_in : in std_logic -- horloge à 32,768 kHz ; reset : in std_logic -- reset asynchrone ; refresh : out std_logic -- horloge à 1 Hz à la sortie du composant);end entity horloge;

architecture demo of horloge issignal count : std_logic_vector(14 downto 0); -- variable pour compter les fronts de

l'horloge à 32,768 KHz begin

process (clk_in, reset)begin

-- en cas de resetif (reset = '0') then

count <= (others => '0') ;-- si front d'horloge, on incrémente le compteur de périodeselsif rising_edge(clk_in) then

count <= count + 1 ;end if;

end process;

refresh <= count(14);

end architecture demo;

Test Bench : (utile uniquement pour la simulation)

Page 15/32



entity tb_horloge is end entity;

--définition du testbencharchitecture testbench of tb_horloge is

-- déclaration des signaux de simulationsignal clk_in : std_logic ;signal reset : std_logic ;signal refresh : std_logic ;

begin --process pour le signal reset process begin reset <= '0'; wait for 20 ns; reset <= '1'; wait; end process;

--process pour le signal clk_in process begin clk_in <= '1'; wait for 15259 ns; clk_in <= '0'; wait for 15259 ns; end process;

etiq: entity work.horloge port map( clk_in => clk_in, reset => reset , refresh => refresh);

end architecture testbench;

Page 16/32


IV. Compteur

A. Schéma bloc fonctionnel

Signaux d’entrée :

refresh : horloge de fréquence 32 768 Hz reset : signal asynchrone permettant une remise à zéro du système

Signaux de sortie :

chiffre_sortie : valeur du codeur codée en 7 segments buzzer : signal du buzzer select_sec : signal permettant de sélectionner l’écran d’affichage des secondes

Page 17/32

7

COMPTEUR

AFFICHEUR

refresh

reset

chiffre_sortie

buzzer

select_sec


B. Principe de fonctionnement

Le compteur s’incrémente à chaque front montant du signal refresh à savoir toutes les 0,5 secondes. Cependant le compteur est au format BCD, il faut donc le convertir au format 7 segments ce qui est réalisé par une fonction implémentée au sein de ce module compteur-afficheur. Enfin un buzzer émet un son à chaque changement de chiffre, ce qui est généré par la reproduction de l’horloge.

C. Code VHDL

Fichier comportemental : library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_arith.all;use ieee.std_logic_unsigned.all;

entity compteur is port( refresh : in std_logic -- horloge à 1 Hz ; reset : in std_logic -- reset asynchrone ; chiffre_sortie : out std_logic_vector(6 downto 0) -- chiffre 7 segments ; buzzer : out std_logic -- buzzer ; select_sec : out std_logic -- afficheur des secondes); end entity compteur;

architecture comptage of compteur is

function conversion_BCD_7seg(chiffre_BCD : std_logic_vector(3 downto 0)) return std_logic_vector;

function conversion_BCD_7seg(chiffre_BCD : std_logic_vector(3 downto 0)) return std_logic_vector is begin case chiffre_BCD is when "0000" => return "1000000"; when "0001" => return "1111001"; when "0010" => return "0100100"; when "0011" => return "0110000"; when "0100" => return "0011001"; when "0101" => return "0010010"; when "0110" => return "0000010";

Page 18/32


when "0111" => return "1111000"; when "1000" => return "0000000"; when "1001" => return "0010000"; when others => return "0011100"; end case; end function conversion_BCD_7seg; signal chiffre : std_logic_vector(3 downto 0);

begin

process(reset,refresh) begin if reset = '0' then chiffre <= (others=>'0'); elsif rising_edge(refresh) then chiffre <= chiffre + 1;

if chiffre = "1001" then chiffre <= (others=>'0');

end if; end if; end process; process(reset,refresh) begin if reset = '0' then buzzer <= '0'; else buzzer <= refresh; end if; end process; process(refresh) begin if rising_edge(refresh) then chiffre_sortie <= conversion_BCD_7seg(chiffre); end if; end process; select_sec <= '1';

end architecture comptage;

Page 19/32


Test bench :


entity tb_compteur is end entity tb_compteur;

architecture tb_comptage of tb_compteur is signal refresh : std_logic; -- horloge à 1 Hz signal reset : std_logic; -- reset asynchrone signal chiffre_sortie : std_logic_vector(6 downto 0); -- chiffre 7 segments signal buzzer : std_logic; -- buzzer signal select_sec : std_logic ; -- afficheur des secondes

begin process begin reset <= '0'; wait for 20 ns; reset <= '1'; wait; end process; process begin refresh <= '1'; wait for 15259 ns; refresh <= '0'; wait for 15259 ns; end process; etiq: entity work.compteur port map ( refresh => refresh , reset => reset , buzzer => buzzer , select_sec => select_sec , chiffre_sortie => chiffre_sortie );

end architecture tb_comptage;

Page 20/32


V. Synthèse avec isplever

A. Synthèse de l’horloge

Pour réaliser la synthèse de notre EPLD nous utilisons l’espace de travail de ISPLEVER dans lequel on crée un projet, on obtient l’environnement suivant :

La synthèse s’effectue donc en lançant successivement les étapes visibles dans la partie « Proccesses for current source ».

Lorsqu’on lance la synthèse on commence par lancer le processus « Optimization Constraint ». Ce processus va permettre de définir les contraintes du placement routage notamment le choix de l’optimisation de la vitesse d’exécution ou de la surface occupée dans le composant.

Page 21/32


Une fois cette opération réalisée, il faut alors définir l’emplacement des broches d’entrées/sorties de l’EPLD avec le logiciel « Constraint Editor ».

Page 22/32


Comme spécifié dans le sujet nous avons défini : Broche 7 : reset actif à l’état basBroche 11 : clk_in de fréquence 32 kHzBroche 37 : refresh qui vaut 1 Hz dans l’étape 1 et 2 Hz dans l’étape 2.

Page 23/32


Le résultat de la synthèse avec l’option Area génère un fichier de résultats, « fitter report », qu’il est utile d’analyser.

B. Synthèse avec l’option Area

Project_Summary~~~~~~~~~~~~~~~

Project Name : syntheseProject Path : C:\DOCUMENTS AND SETTINGS\1AG4A\BUREAU\TP8 VHDLProject Fitted on : Thu Jan 17 15:17:40 2008

Device : M4A5-64/32Package : 44PLCCSpeed : -10Partnumber : M4A5-64/32-10JCSource Format : Pure_VHDL

// Project 'synthese' was Fitted Successfully! //

Compilation_Times~~~~~~~~~~~~~~~~~Reading/DRC 0 secPartition 0 secPlace 0 secRoute 0 secJedec/Report generation 0 sec --------Fitter 00:00:00

Page 24/32


Design_Summary : (permet de voir le nombre d’I/O ainsi que le nombre de bascule utilisées)~~~~~~~~~~~~~~

Total Input Pins : 2 Total Output Pins : 1 Total Bidir I/O Pins : 0 Total Flip-Flops : 15 Total Product Terms : 34 Total Reserved Pins : 0 Total Reserved Blocks : 0

Device_Resource_Summary (permet de voir le nombre de macro-cellules utilisées, le nombre ~~~~~~~~~~~~~~~~~~~~~ d’entrées d’horloge et de pins utilisées)

Total Available Used Available UtilizationDedicated Pins Input-Only Pins .. .. .. --> .. Clock/Input Pins 2 1 1 --> 50%I/O Pins 32 2 30 --> 6%Logic Macrocells 64 17 47 --> 26% Input Registers 32 0 32 --> 0% Unusable Macrocells .. 0 ..

CSM Outputs/Total Block Inputs 132 42 90 --> 31%Logical Product Terms 320 36 284 --> 11%Product Term Clusters 64 11 53 --> 17%

On peut ainsi voir que : Le quart des macro-cellules est utilisé. Ce qui est raisonnable. Le nombre de product terms utilisé est faible (11% de ceux disponible) L’implantation de l’horloge en mode AREA utilise 15 bascules.

On peut aussi voir le “ Timing report “ afin de determiner la fréquence maximale d’utilisation.

Section fMAX

Maximum Operating Frequency: 44.44 MHz Clock Source From: clk_in Logic Levels: 3 Path Delay: 22.5 ns

Page 25/32


C. Synthèse avec l’option Speed

Project_Summary~~~~~~~~~~~~~~~

Project Name : syntheseProject Path : C:\DOCUMENTS AND SETTINGS\1AG4A\BUREAU\TP8 VHDLProject Fitted on : Thu Jan 17 15:20:38 2008

Device : M4A5-64/32Package : 44PLCCSpeed : -10Partnumber : M4A5-64/32-10JCSource Format : Pure_VHDL

// Project 'synthese' was Fitted Successfully! //

Compilation_Times~~~~~~~~~~~~~~~~~Reading/DRC 0 secPartition 0 secPlace 0 secRoute 0 secJedec/Report generation 0 sec --------Fitter 00:00:00

Design_Summary~~~~~~~~~~~~~~ Total Input Pins : 2 Total Output Pins : 1 Total Bidir I/O Pins : 0 Total Flip-Flops : 15 Total Product Terms : 21 Total Reserved Pins : 0 Total Reserved Blocks : 0

Device_Resource_Summary~~~~~~~~~~~~~~~~~~~~~~~ Total Available Used Available UtilizationDedicated Pins

Page 26/32


Input-Only Pins .. .. .. --> .. Clock/Input Pins 2 1 1 --> 50%I/O Pins 32 2 30 --> 6%Logic Macrocells 64 15 49 --> 23% Input Registers 32 0 32 --> 0% Unusable Macrocells .. 0 ..

CSM Outputs/Total Block Inputs 132 49 83 --> 37%Logical Product Terms 320 22 298 --> 6%Product Term Clusters 64 4 60 --> 6%

On peut aussi voir le “ Timing report “ afin de determiner la fréquence maximale d’utilisation.

Section fMAX

Maximum Operating Frequency: 105.26 MHz Clock Source From: clk_in Logic Levels: 1 Path Delay: 9.5 ns

D. Post-simulation

Une fois que Model Sim a été ouvert, nous compilons le fichier « .vho », puis nous compilons le fichier de testbench se rapportant à notre entité horloge. Ce fichier testbench sert donc à la fois à la pré-simulation et à la post-simulation.

Page 27/32


Page 28/32


La post-simulation doit confirmer les résultats de pré-simulation. Pour indiquer les contraintes de fonctionnement, après réalisation de la synthèse, il faut inclure le fichier d’extension « .sdf ».

Page 29/32


Une fois le fichier « .sdf » sélectionné, il faut alors spécifier la région qui correspond à l’étiquette se trouvant dans notre testbench à savoir « etiq ».

Puis la post-simulation se lance :

Page 30/32


Nous voyons que notre horloge possède bien une période d’horloge de 1 seconde. Néanmoins il faut observer les temps de propagation entre le front montant d’horloge en entrée et l’événement associé en sortie : 6 ns. Ce temps de retard, que l’on retrouve avec les 2 options (AREA et SPEED) est dû au temps de calcul du composant.

E. Synthèse du compteur

Assignation des broches

Broche 7 : reset actif à l’état bas Broche 11 : refresh provenant de l’EPLD1 Broche 27 : buzzer sonnant à chaque changement de chiffre Broche 40 : select_sec sert à sélectionner l’afficheur des secondes Broche 29 à 31 et 36 à 39 : sert à envoyer le chiffre codé sur 7 segments

Page 31/32


Page 32/32

Documents

Synthèse de l’horlogesudriaesme.free.fr/Signal et Telecom - Devriendt/tp/TP 8... · Web viewuse ieee.std_logic_unsigned.all; entity tb_compteur is end entity tb_compteur; architecture