LE VHDL PAR L’EXEMPLE

a

b

Utilisation d’une assignation conditionnelle when :

ARCHITECTURE logique OF comparateur IS

BEGIN

c <= '1' WHEN ( a = b ) ELSE '0';

END logique;

Utilisation de l’équation logique de la comparaison :

ARCHITECTURE operateur OF comparateur IS

BEGIN

c <= not ( a xor b )

END operateur;

Réalisation « matérielle » de l’équation logique avec des

composants xor et inv définis par ailleurs dans une bibliothèque :

Comparateur

i

1

=1

c

a

b

ARCHITECTURE composant OF comparateur IS

SIGNAL i : BIT;

BEGIN

comp1 : xor2 PORT MAP (a,b,i);

comp2 : inv PORT MAP (i,c);

END composant;

A noter que la liaison à l’intérieur de l’architecture doit

être réalisée par un signal , dans cet exemple le signal est de

type bit.

P.Guérangé Présentation du vhdl

Page 6

(a-5) Description modulaire.

Il n’est pas nécessaire de définir tous les composants ou

architectures utilisées dans un design vhdl dans le même fichier

que le fichier principal. Il est possible de découper le projet en

plusieurs morceaux. Ces morceaux sont rangés dans des paquetages.

Ils peuvent être alors utilisés par tout autre projet décrit en

vhdl et qui fera appel à ce paquetage, l’appel est précisé dans

une déclaration use .

Pour illustrer cette description modulaire nous allons à partir

du comparateur de deux fois quatre bits, réaliser un découpage

entre un paquetage de portes logiques élémentaires, et le corps

principal du projet.

Voici tout d’abord la description complète non découpée du

comparateur de deux mots de quatre bits :

-------------------------------------------------------------

-- description d'un opérateur non xor

library ieee;

use ieee.std_logic_1164.all;

ENTITY nonxor IS

PORT ( x , y : IN STD_LOGIC; xn : OUT STD_LOGIC);

END nonxor;

ARCHITECTURE operateur OF nonxor IS

BEGIN

xn <= not ( x xor y );

END operateur;

-------------------------------------------------------------

-- description d'un opérateur et à quatre entrées

library ieee;

use ieee.std_logic_1164.all;

ENTITY and4 IS

PORT ( a , b , c , d : IN STD_LOGIC; e : out STD_LOGIC );

END and4;

ARCHITECTURE operateur OF and4 IS

BEGIN

e <= ((a and b) and ( c and d));

END operateur;

-------------------------------------------------------------

-- description du comparateur de deux fois quatre bits

-------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

ENTITY cmp4 IS

PORT ( a : IN STD_LOGIC_VECTOR(3 downto 0);

b : IN STD_LOGIC_VECTOR(3 downto 0);

aeqb : OUT STD_LOGIC);

END cmp4;

ARCHITECTURE composant OF cmp4 IS

SIGNAL i : STD_LOGIC_VECTOR(3 downto 0);

BEGIN

ic1: nonxor PORT MAP (a(0),b(0),i(0));

ic2: nonxor PORT MAP (a(1),b(1),i(1));

ic3: nonxor PORT MAP (a(2),b(2),i(2));

ic4: nonxor PORT MAP (a(3),b(3),i(3));

ic5: and4 PORT MAP(i(0),i(1),i(2),i(3),aeqb);

END composant;

P.Guérangé Présentation du vhdl

Page 7

La même description mais en préparant la coupure en deux

parties du fichier :

-- fichier cmp41.vhd

------------------------------------------------------------------

-- description d'un opérateur non xor

library ieee;

use ieee.std_logic_1164.all;

ENTITY nonxor IS

PORT ( x , y : IN STD_LOGIC; xn : OUT STD_LOGIC);

END nonxor;

ARCHITECTURE operateur OF nonxor IS

BEGIN

xn <= not ( x xor y );

END operateur;

-------------------------------------------------------------

-- description d'un opérateur et à quatre entrées

library ieee;

use ieee.std_logic_1164.all;

ENTITY and4 IS

PORT ( a , b , c , d : IN STD_LOGIC; e : out STD_LOGIC );

END and4;

ARCHITECTURE operateur OF and4 IS

BEGIN

e <= ((a and b) and ( c and d));

END operateur;

-------------------------------------------------------------

-- description du comparateur de deux fois quatre bits

-------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

ENTITY cmp4 IS

PORT ( a : IN STD_LOGIC_VECTOR(3 downto 0);

b : IN STD_LOGIC_VECTOR(3 downto 0);

aeqb : OUT STD_LOGIC);

END cmp4;

ARCHITECTURE composant OF cmp4 IS

-- on précise içi la déclaration des composants que l'on souhaite utiliser dans

la description principale.

--

COMPONENT nonxor PORT ( x , y : IN STD_LOGIC; xn : OUT STD_LOGIC);

END COMPONENT;

COMPONENT and4 PORT ( a , b , c , d : IN STD_LOGIC; e : out STD_LOGIC );

END COMPONENT;

-----------------

SIGNAL i : STD_LOGIC_VECTOR(3 downto 0);

BEGIN

ic1: nonxor PORT MAP (a(0),b(0),i(0));

ic2: nonxor PORT MAP (a(1),b(1),i(1));

ic3: nonxor PORT MAP (a(2),b(2),i(2));

ic4: nonxor PORT MAP (a(3),b(3),i(3));

ic5: and4 PORT MAP(i(0),i(1),i(2),i(3),aeqb);

END composant;

P.Guérangé Présentation du vhdl

Page 8

Coupure en deux parties et réalisation du paquetage portes :

-- paquetage de portes élémentaires

--

-- fichier portes.vhd

library ieee;

use ieee.std_logic_1164.all;

PACKAGE portes IS

COMPONENT nonxor PORT ( x , y : IN STD_LOGIC; xn : OUT STD_LOGIC);

END COMPONENT;

COMPONENT and4 PORT ( a , b , c , d : IN STD_LOGIC; e : out STD_LOGIC );

END COMPONENT;

END portes;

-------------------------------------------------------------

-- description d'un opérateur non xor

--

library ieee;

use ieee.std_logic_1164.all;

ENTITY nonxor IS

PORT ( x , y : IN STD_LOGIC; xn : OUT STD_LOGIC);

END nonxor;

ARCHITECTURE operateur OF nonxor IS

BEGIN

xn <= not ( x xor y );

END operateur;

-------------------------------------------------------------

-- description d'un opérateur et à quatre entrées

--

library ieee;

use ieee.std_logic_1164.all;

ENTITY and4 IS

PORT ( a , b , c , d : IN STD_LOGIC; e : out STD_LOGIC );

END and4;

ARCHITECTURE operateur OF and4 IS

BEGIN

e <= ((a and b) and ( c and d));

END operateur;

Le paquetage déclare les composants contenus à l’intérieur. Ces

composants sont utilisables par tous les projets l’indiquant par

une instruction use.

P.Guérangé Présentation du vhdl

Page 9

Voiçi le projet du comparateur quatre bits utilisant le

paquetage portes :

-- comparateur de deux fois quatre bits

--

-- utilisation d'un paquetage de composants extérieurs

-- nommé portes

--

-- fichier cmp42.vhd

-------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

use work.portes.all;

ENTITY cmp4 IS

PORT ( a : IN STD_LOGIC_VECTOR(3 downto 0);

b : IN STD_LOGIC_VECTOR(3 downto 0);

aeqb : OUT STD_LOGIC);

END cmp4;

ARCHITECTURE composant OF cmp4 IS

SIGNAL i : STD_LOGIC_VECTOR(3 downto 0);

BEGIN

ic1: nonxor PORT MAP (a(0),b(0),i(0));

ic2: nonxor PORT MAP (a(1),b(1),i(1));

ic3: nonxor PORT MAP (a(2),b(2),i(2));

ic4: nonxor PORT MAP (a(3),b(3),i(3));

ic5: and4 PORT MAP(i(0),i(1),i(2),i(3),aeqb);

END composant;

Cette description est la plus concise. Elle permet de plus de

construire son projet avec des blocs compilés à part ce qui

facilite la mise au point.

Ces paquetages peuvent être partagés avec d’autres projets, le

travail en équipe de développement est possible avec le VHDL.

(a-6) Exercices.

[1] Reprendre les exemples ci-dessus et réaliser la synthèse

d’un additionneur de deux fois 1 bit avec retenue en entrée.

[2] Mettre l’additionneur élémentaire dans le paquetage portes

puis réaliser la synthèse d’un additionneur de deux mots de quatre

bits.

P.Guérangé Présentation du vhdl

Page 10

(a-7) le multiplexeur.

Utilisons un multiplexeur pour illustrer les assignations

conditionnelle when et sélective with.

mux

s0

s1

a

b

c

d

0

1

0

1

2

3

x

Utilisation de l’assignation conditionnelle when :

-- multiplexeur

--

-- fichier mux1.vhd

-------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

ENTITY mux1 IS

PORT ( a,b,c,d : IN STD_LOGIC;

s : IN STD_LOGIC_VECTOR(1 downto 0);

x : OUT STD_LOGIC);

END mux1;

ARCHITECTURE archmux OF mux1 IS

BEGIN

x <= a WHEN ( s="00" ) ELSE

b WHEN ( s="01" ) ELSE

c WHEN ( s="10" ) ELSE

d;

END archmux;

Utilisation de l’assignation sélective with :

-- multiplexeur

--

-- fichier mux2.vhd

-------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

ENTITY mux2 IS

PORT ( a,b,c,d : IN STD_LOGIC;

s : IN STD_LOGIC_VECTOR(1 downto 0);

x : OUT STD_LOGIC);

END mux2;

ARCHITECTURE archmux OF mux2 IS

BEGIN

WITH s SELECT

x <= a WHEN "00" ,

b WHEN "01" ,

c WHEN "10" ,

d WHEN OTHERS;

END archmux;

P.Guérangé Présentation du vhdl

Page 11

(B) LES OPERATIONS SEQUENTIELLES ET LE PARALLELISME.

(b-1) La logique synchrone, la bascule D.

Le vhdl permet de décrire des fonctionnements parallèles. La

‘brique’ de base de ces descriptions est le process.

Le process est une construction qui ne s’éxécute que sur un

changement détecté dans l’un des signaux auxquels il est

sensible.

d

D

clk

Q

q

-- bascule D active sur front

--

-- fichier dff1.vhd

-------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

ENTITY dff1 IS

PORT ( d : IN STD_LOGIC;

clk : IN STD_LOGIC;

q : OUT STD_LOGIC);

END dff1;

ARCHITECTURE archdff OF dff1 IS

BEGIN

P1: PROCESS (clk)

BEGIN

IF (clk'event AND clk='1') THEN

q <= d;

END IF;

END PROCESS p1;

END archdff;

La description de la bascule D repose sur le process ici repéré

par l’étiquette P1.

Ce process est sensible à l’entrée clk. Il ne s’éxécute que si

il y a un changement sur l’entrée clk.

Lors de l’éxécution les instructions composant le process

s’éxécutent séquentiellement.

Les sorties du process ne sont affectées qu’à la fin du

déroulement de celui-ci.

P.Guérangé Présentation du vhdl

Page 12

Nous voyons ici l’utilisation d’un attribut du signal clk. Il

s’agit de l’attribut ‘event , celui-ci est vrai lorsqu’un

changement sur le signal clk vient de se produire.

Ne pas oublier que les valeurs possibles du signal clk sont:

‘U’ ‘X’ ‘0’ ‘1’ ‘Z’ ‘W’ ‘L’ ‘H’ ‘-’ si il est du type std_logic.

La condition logique clk’event and clk=‘1’ détecte donc un

front montant sur clk.

D’autres attributs prédéfinis sont disponibles,

il est aussi possible de créer des attributs

personnalisés.

(b-2) La bascule D avec un reset asynchrone.

Complétons la description de la bascule précédente pour y

ajouter un reset asynchrone.

d

D

clk

reset

Q

q

R

-- bascule D active sur front

--

-- fichier dff2.vhd

-------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

ENTITY dff2 IS

PORT ( d : IN STD_LOGIC;

reset : IN STD_LOGIC;

clk : IN STD_LOGIC;

q : OUT STD_LOGIC);

END dff2;

ARCHITECTURE archdff OF dff2 IS

BEGIN

p1: PROCESS (clk,reset)

BEGIN

IF (reset='1') THEN

q <= '0';

ELSIF (clk'event AND clk='1') THEN

q <= d;

END IF;

END PROCESS p1;

END archdff;

P.Guérangé Présentation du vhdl

Page 13

(b-3) Description d’un compteur de quatre bits.

Nous décrivons ci-dessous un compteur de quatre bits. Le

comptage s’effectue directement par l’addition

count <= count + 1;

Cette opération sur la variable de type std_logic_vector est

possible par l’utilisation du paquetage std_arith.

library ieee;

use ieee.std_logic_1164.all;

entity counter is port(

clk, load: in std_logic;

data:

count:

end counter;

in std_logic_vector(3 downto 0);

buffer std_logic_vector(3 downto 0));

use work.std_arith.all;

architecture archcounter of counter is

begin

upcount: process (clk)

begin

if (clk'event and clk= '1') then

if load = '1' then

count <= data;

else

count <= count + 1;

end if;

end if;

end process upcount;

end archcounter;

(b-4) Exercices.

[1] Compléter la description ci-dessus pour ajouter la

possibilité d’un reset et d’un preset asynchrones.

[2] Décrire un compteur de huit bits avec chargement synchrone

et sorties trois états.

P.Guérangé Présentation du vhdl

Page 14

(C) LES MACHINES D’ETATS.

(c-1) Détection de début et de fin d’impulsion.

Réalisons un système séquentiel détectant le début et la fin

d’une impulsion. Le chronogramme désiré est le suivant :

s

sds

sfs

Le bilan des entrées et sorties est décrit ci-dessous, on y a

ajouté la possibilité d’un reset avec l’entrée rst.

s

rst

clk

sds

sfs

Synthèse de la machine d’état (voir texte ci-dessous) :

L’état est mémorisé dans un signal state de type states. Le

type states précise la liste des valeurs possibles, c’est un type

énuméré.

Un process sensible aux signaux clk et rst gère les évolutions

de la machine d’état.

Les sorties sont calculées d’après la valeur de l’état dans des

assignations concourantes de type <= ;

Les assignations <= et le process sont simultannément activées

et chacun s’éxécute dès que sa condition d’activation est réalisée

à savoir :

• un changement de rst ou clk pour le process.

• un changement de la variable state pour sds et sfs.

P.Guérangé Présentation du vhdl

Page 15

(c-2) Machine de Moore.

Voici la machine de Moore répondant au cahier des charges ci-

dessus :

s

sds

S1

/s

S0

S2

s

S3

sfs

/s

Et la description vhdl correspondante :

--

-- Machine de Moore avec decodage combinatoire des sorties

--

-- P.Guérangé

library ieee;

use ieee.std_logic_1164.all;

entity moore1 is port(

clk,rst : in std_logic;

s : in std_logic;

sds,sfs : out std_logic);

end moore1;

library ieee;

use ieee.std_logic_1164.all;

architecture archmoore1 of moore1 is

type states is (s0,s1,s2,s3);

signal state : states:=s0;

begin

moore:process(rst,clk)

begin

if (rst='1') then

state <= s0;

elsif ((clk'event) and (clk='1')) then

case state is

when s0 => if (s='1') then state <= s1;

else state <= s0; end if;

when s1 => state <= s2;

when s2 => if (s='0') then state <= s3;

else state <= s2; end if;

when s3 => state <= s0;

end case;

end if;

end process;

sds <= '1' WHEN (state=s1) else '0';

sfs <= '1' WHEN (state=s3) else '0';

end archmoore1;

P.Guérangé Présentation du vhdl

Page 16

(c-3) Codage des états :

Le codage des états est réalisé de façon transparente par le

compilateur. Il est néanmoins possible d’imposer un codage

particulier en utilisant des directives de synthèse.

Les directives de synthèse sont écrites sous la forme

d’attribut attaché à diférentes parties du code vhdl.

Ici pour le codage des états nous utilisons l’attribut

enum_encoding si nous voulons coder nous-mêmes les états:

syntaxe : attribute enum_encoding of type_name:type is ”string”

type states is (s0,s1,s2,s3);

attribute enum_encoding of states:type is ” 00 01 10 11 ”;

D’autres codages sont possibles avec l’attribut state_encoding

comme par exemple le codage one_hot_zero, one_hot_one, sequential,

ou gray. Décrivons ces codes :

Sequential : le codage est binaire normal.

Codage one_hot_zero : dans ce codage chaque code comporte un

seul bit à 1, le code tous les bits nuls est utilisé.

Appliqué au cas précédent le codage donne (s0: 000) (s1: 001)

(s2: 010) (s3: 100)

Codage one_hot_one : dans ce codage chaque code comporte un

seul bit à 1, le code tous les bits nuls n’est pas utilisé.

Appliqué au cas précédent le codage donne (s0: 0001) (s1: 0010)

(s2: 0100) (s3: 1000)

Syntaxe : attribute state_encoding of type-name is value;

Avec value choisit parmi sequential, one_hot_zero, one_hot_one,

gray.

type states is (s0,s1,s2,s3);

attribute state_encoding of states:type is gray;

Les codages de type one_hot_xxx consomment plus de bascules

qu’un codage binaire. Les équations sont cependant plus simples et

le gain global est plus intéressant dans le cas de composants

programmables possédant un grand nombre de registre internes.

P.Guérangé Présentation du vhdl

Page 17

(c-4) Machine de Mealy.

Reprenons le même problême en le décrivant avec une machine de

Mealy. Le graphe de cette machine est décrit ci-dessous :

/s

S0

sds

s

/s

sfs

S1

s

Voiçi la description vhdl correspondante :

-- Machine de Mealy

--

-- P.Guérangé

------------------------------------------------------------

library ieee;

use ieee.std_logic_1164.all;

entity mealy1 is port(

clk,rst : in std_logic;

s : in std_logic;

sds,sfs : out std_logic);

end mealy1;

library ieee;

use ieee.std_logic_1164.all;

architecture archmealy1 of mealy1 is

type states is (s0,s1);

begin

mealy:process(rst,clk,s)

variable state : states:=s0 ;

begin

if (rst='1') then

state := s0;

elsif ((clk'event) and (clk='1')) then

case state is

when s0 => if (s='1')

then state := s1;

else state := s0;

end if;

when s1 => if (s='0')

then state := s0;

else state := s1;

end if;

end case;

end if;

-- envoi des sorties

if (state=s0) and (s='1')

then sds <= '1'; else sds <= '0';

end if;

if (state=s1) and (s='0')

then sfs <= '1'; else sfs <= '0';

end if;

end process;

end archmealy1;

P.Guérangé Présentation du vhdl

Page 18

La machine d’état présentée a une structure différente de la

machine de Moore. Ici l’état est mémorisé dans une variable

appartenant au process. ( Et non plus à l’architecture comme dans

le cas précédent. )

Les évolutions de la machine d’état sont prises en compte en

donnant une valeur à la variable state par l’opérateur

d’affectation := .

Les sorties sont donc gérées à l’intérieur du process en

fonction de la valeur de la variable etat.

(c-5) Exercices.

[1] Modifier les machines d’états précédentes pour rendre la

détection de début et de fin d’impulsion insensible à un parasite

sur l’entrée s. Ce parasite ne dure pas plus d’un top d’horloge

clk.

[2] Synthèse d’un banc mémoire.

Une interface entre un calculateur et un banc mémoire répond à

la machine d’état présentée à la page ci_après.

Le bilan des entrées sorties est le suivant :

Interface

Banc

mémoires

DOUT

b

WE

b

Système à

micro

Processeur

ADDR

REQ

RW

b

DA

WC

b

b

Les signaux actifs bas sont repérés avec la lettre b à la fin.

Réaliser la synthèse en vhdl de cette machine.

P.Guérangé Présentation du vhdl

Page 19

/REQ+/ADDR

Wait

REQRWbADDR

REQ/RWbADDR

Read1

/DOUT

b

/WE

b

Write1

/REQ +

/ADDR

Read2

/DOUT

b

/DA

b

Read3

REQ*ADDR

Valeur par défaut

des sorties

DOUT

b =1

DAb=1

WEb=1

=1

WC

b

/WE

b

Count1

/WE

b

Count2

/WE

b

Count3

/REQ +

/ADDR

/WE

b

/WC

b

Write2

/WC

b

Write3

REQ*ADDR

P.Guérangé Présentation du vhdl

Page 20

(D) DIRECTIVES DE SYNTHESE.

(d-1) Imposer les broches utilisées.

Il est souvent nécessaire d’imposer le brochage lors d’une

synthèse. L’attribut pin_numbers permet de donner les numéros de

broche aux signaux d’entrées et sorties du composant. Cet attribut

est attaché à l’entité.

syntaxe : attribute pin_numbers of my_design:entity is ”string”

”string” = ”sig1:1 ” & ”sig2:3 ” & ”sig3:5”

(d-2) Choix du composant.

L’attribut part_name permet d’imposer le composant à utiliser.

syntaxe : attribute part_name of my_design:entity is ”C371”

(d-3) Exemple d’utilisation des attributs de synthèse.

entity seq_lum3 is port(

RAZb : in std_logic;

DEPART : in std_logic;

ARRET : in std_logic;

FIN_COMPTAGE : in std_logic;

INTER : in std_logic_vector(6 downto 0);

CLK : in std_logic;

LED_ROUGE : out std_logic;

LOAD_C : out std_logic;

VALID_C : out std_logic;

CLOCK_C : out std_logic;

PROGRAMME : out std_logic_vector(2 downto 0));

attribute part_name of seq_lum3: entity is "C22V10";

attribute pin_numbers of seq_lum3: entity is

" clk:1 " &

" depart:2 " &

" fin_comptage:3 " &

" razb:4 " &

" inter(0):5 " &

" inter(1):6 " &

" inter(2):7 " &

" inter(3):8 " &

" inter(4):9 " &

" inter(5):10 " &

" inter(6):11 " &

" clock_c:22 " &

" load_c:21 " &

" programme(1):20 " &

" led_rouge:19 " &

" programme(2):18 " &

" programme(0):17 " &

" arret:13 " &

" valid_c:16 ";

end seq_lum3;

(d-4) Exercice.

Reprendre la description de la machine d’état de la gestion du

banc mémoire en imposant le choix du Pal20R4 et le brochage ci-

dessous :

P.Guérangé Présentation du vhdl

Page 21

Brochage retenu :

TYPE

Horloge

Entrée

Entrée

Entrée

NOM

CLK

R/Wb

REQ

ADDR

1

2

3

4

5

6

7

8

9

10

11

12

NOM

TYPE

WCb

WEb

DAb

DOUTb

Sortie

Sortie

Etat

Etat

Etat

Etat

Sortie

Sortie

24

23

22

21

20

19

18

17

16

15

14

13

P.Guérangé Présentation du vhdl

Page 22

Annexe 1 : bibliographie

[1] Manuels livrés avec le logiciel Warp 2

-> le manuel de référence pour le langage et des

exemples.

-> le guide de l’utilisateur pour les tutorials.

[2] VHDL Initiation , application aux composants programmables.

Polycopié de formation Cypress.

[3] Circuits numériques et synthèse logique un outil le vhdl.

Collection Masson Technologies J.Weber et M.Meaudre

[4] VHDL For Programmable Logic. par Kevin Skahill

Edition Cypress.

[5] VHDL du langage à la modélisation.

Collection informatique, CNET ENST, R.Airiau, J-M Bergé,

V.Olive, J.Rouillard.

Ouvrage général sur le vhdl, n’est pas directement

orienté vers la synthèse de composant programmable.

P.Guérangé Présentation du vhdl

Page 23