Master 1 VHDL Course

u1 : xor2 PORT MAP (e1=>A(0),e2=>B(0),s=>S(0)); u2 : xor2 PORT MAP (e1=>A(1),e2=>B(1),s=>inter1); u3 : and2 PORT MAP (e1=>A(0),e2=>B(0),s=>inter2); u4 : xor2 PORT MAP (e1=>inter1,e2=>inter2,s=>S(1));

0

end structurelle;

www.istic.univ-rennes1.fr

2.2.3 Architecture : Description mixte

. Au sein d'une même architecture, il est possible d'utiliser du comportemental et du structurel

21

reset

D

S_inter

clk

b a

Adder

s

ENTITY integration IS PORT( a : IN bit_vector(0 to 1); reset, clk : IN bit; s : OUT bit_vector(0 to 1));

END integration; ARCHITECTURE mixte OF integration IS SIGNAL b,s_inter :bit_vector(0 to 1); COMPONENT adder

PORT(a,b : IN bit_vector(0 to 1); s : OUT bit_vector(0 to 1)); END COMPONENT;

VHDL

BEGIN

PROCESS(clk) BEGIN

IF clk = '1' THEN

IF reset = '1' THEN b <= ''00''; ELSE b <= s_inter; END IF;

END IF;

END PROCESS; u1 : adder PORT MAP (a=>a,b=>b,s=>s_inter); s <= s_inter;

0

END mixte;

www.istic.univ-rennes1.fr

3. Types

22

. Types :

. VHDL interdit l’association de 2 signaux de type différent . Types disponibles

- Scalaires (Scalar)

. Entiers (integer) . Flottants (Real) . Enumérés (Enumerated) . Physiques (Physical)

- Composés (Composite)

. Tableaux (Array)

- Collection d’objets de même type

. Enregistrements (Record)

- Collection d’objets de type différent

- Access et File

. Types pour la manipulation de fichiers ou sur les pointeurs

0

www.istic.univ-rennes1.fr

3. Types

23

. Sous-types :

. Restrictions :

SUBTYPE chiffre IS integer RANGE 0 TO 9; SUBTYPE octet IS bit_vector(0 TO 7);

. 2 sous-types prédéfinis

SUBTYPE natural IS integer RANGE 0 TO higher_integer; SUBTYPE positive IS integer RANGE 1 TO higher_integer;

. Association d’un sous-type au type à partir duquel il a été défini : autorisé

. Association entre 2 sous-types différents issus du même type : autorisé

0

www.istic.univ-rennes1.fr

3.1 Types : Scalaires

24

. Types entiers (INTEGER)

-231 + 1  entier  231 - 1

TYPE chiffre_ascendant IS RANGE 0 TO 9; TYPE chiffre_descendant IS RANGE 9 DOWNTO 0;

Notations de valeurs -154 147

2#01010111# (binaire)

16#3FFF# hexadécimal

. Types flottants (REAL)

Approximation discrète de l'ensemble des réels dans un intervalle donné

TYPE real IS RANGE -1.0E38 TO 1.0E+38;

0

www.istic.univ-rennes1.fr

3.1 Types : Scalaires

25

. Types énumérés :

Ensemble de valeurs désignées par des identificateurs ou des caractères

TYPE boolean IS (false, true);

TYPE bit IS ('0','1');

TYPE std_logic IS ('U', ’X', ’O', ’1' ’Z', ’W', ’L', ’H' , ’-');

TYPE jour IS (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);

Remarques :

. Chaque caractère ou chaîne de caractères au sein d'un même type

doit être distinct

. Possibilité d'utiliser le même caractère dans 2 types distincts

0

www.istic.univ-rennes1.fr

3.1 Types : Scalaires

26

. Types physiques :

Valeurs numériques de quantités physiques

TYPE time IS RANGE -2 147 483 647 TO 2 147 483 647

UNITS

ps = 1000 fs; ns = 1000 ps; us = 1000 ns; ms = 1000 us; sec = 1000 ms; min = 60 s; hr = 60 min;

END UNITS;

0

www.istic.univ-rennes1.fr

3.2 Types : Composés

27

. Types tableaux

. Bornes fixées à la définition du type

TYPE octet IS ARRAY (7 DOWNTO 0) OF bit;

TYPE memoire IS ARRAY (0 TO 255) OF octet;

. Bornes fixées à chaque déclaration d'un objet de type tableau

TYPE vecteur IS ARRAY (integer RANGE <>) OF std_logic;

SIGNAL mon_vecteur : vecteur(1 TO 20)

. L'indice peut-être un type entier défini par déclaration

TYPE adresse IS RANGE 0 TO 255;

TYPE memoire IS ARRAY (adresse) OF octet;

. Tableaux prédéfinis

TYPE std_logic_vector IS ARRAY (natural RANGE <>) OF std_logic;

TYPE string IS ARRAY (positive RANGE <>) OF character; 0

www.istic.univ-rennes1.fr

3.2 Types : Composés

28

. Types enregistrements

. Ensemble d'éléments nommés avec des types pouvant être différents

TYPE instruction IS

RECORD

code_operatoire : operation;

addresse : octet;

operande1, operande2 : integer RANGE 0 TO 15;

END RECORD;

. Accès à un champ particulier

instruction.code_operatoire <= soustraction;

0

www.istic.univ-rennes1.fr

3.3 Types : Classes

29

. Types et sous-types : . 3 classes

- Types prédéfinis

. Standard VHDL initial IEEE.1076

- Types complémentaires

. Standard VHDL initial IEEE.1164

- Types définis par l’utilisateur

0

www.istic.univ-rennes1.fr

3.3 Types : Classe - les Prédéfinis

30

Prédéfinis

Integer

bit

Boolean

Real

Time

Natural

Positive

Bit_vector

Remarque : Synthèse logique - time : non - real : non - integer : Favoriser les entiers « bornés »

0

www.istic.univ-rennes1.fr

3.3 Types : Classe - les complémentaires

31

. Standard IEEE 1164 - les signaux multivaleurs (package std_logic_1164)

- std_ulogic et std_ulogic_vector

. Std_ulogic se caractérise par 9 valeurs

- ‘ U ’ : non initialisé - ‘ X ’ : niveau inconnu (conflit fort) - ‘ 0 ’ : niveau bas - ‘ 1 ’ : niveau haut - ‘ Z’ : haute impédance - ‘W ’ : niveau inconnu (conflit faible) - ‘ L ’ : niveau bas - ‘ H ’ : niveau haut - ‘ - ’ : niveau quelconque

. Std_logic : SUBTYPE std_logic IS RESOLVED std_ulogic; - VHDL interdit la connexion de 2 sorties entre elles - Introduction des signaux "résolus" (Resolved Signal) - Possibilité d'interconnecter plusieurs sorties ensemble 0

. IEEE 1076.3 - la synthèse logique et les traitements arithmétiques

www.istic.univ-rennes1.fr

- signed et unsigned

32

X 0

1 Z W L

TYPE stdlogic_table IS ARRAY(std_ulogic, std_ulogic) OF std_ulogic; ------------------------------------------------------------------- -- resolution function ------------------------------------------------------------------- CONSTANT resolution_table : stdlogic_table := ( --------------------------------------------------------- -- | U -- --------------------------------------------------------- -- 'U', ( 'U', 'X', ( 'U‘ , 'X', ( 'U', 'X', ( 'U', 'X', ( 'U', 'X', ( 'U', 'X', ( 'U', ( 'U', 'X', ( 'U',‘ X',

'U' ), 'U', 'X' ), 'X', 'X' ), '0', 'X' ), '1', 'X' ), 'H', 'X' ), 'W', 'W', 'X' ), 'H',‘ X' ), 'X' )); 'X',

'U', 'X', 'X', '1', '1', '1', '1', '1', 'X',

'U', 'X', '0', '1', 'L', ‘W', 'L', 'W', 'X',

'U', 'X', '0', '1', 'W', 'W', 'W‘, 'W‘, 'X',

'U', 'X', '0', '1', 'Z', 'W', 'L', 'H', 'X',

'U', 'X', '0', 'X', '0', '0', '0', '0', 'X',

- |

H

-- | U | -- | X | -- | 0 | -- | 1 | -- | Z | -- | W | -- | L | -- | H | -- | - |

FUNCTION resolved(s : std_ulogic_vector ) RETURN std_ulogic IS

VARIABLE result : std_ulogic := 'Z'; -- weakest state default

BEGIN

IF (s'LENGTH = 1) THEN RETURN s(s'LOW); ELSE

FOR i IN s'RANGE LOOP

result := resolution_table(result, s(i));

END LOOP;

END IF; RETURN result;

END resolved;

0

www.istic.univ-rennes1.fr

3.3 Types : Classe - les définis par l'utilisateur

33

. Types définis à une application d’un type ou d’un sous-type

TYPE memoire IS ARRAY (integer RANGE<> ) OF octet;

VARIABLE ma_memoire : memoire (15 DOWNTO 0);

. Types définis à une application d’un sous-type

SUBTYPE octet IS std_logic_vector (7 DOWNTO 0 );

SIGNAL adresse : octet;

0

www.istic.univ-rennes1.fr

4. Objets : Constantes, Variables, Signaux

34

. Utilisation des constantes et des variables : proche des langages traditionnels . Utilisation des signaux : spécification au langage de description du matériel

. Constantes (Constant)

. Objets internes à valeurs fixes et définitives . Synthèse : Mise à VCC ou au GND  Surface nulle . Déclaration : constant nom : type := valeur; . Exemple :

CONSTANT modulo : integer := 17 ;

. Variables (Variable)

. Objets permettant de conserver une valeur pendant un certain temps . Utilisable qu'au sein d'un processus (définition dans le process) . Exemple:

VARIABLE octet1 : std_logic_vector(0 TO 7) := "00000001";

0

www.istic.univ-rennes1.fr

4. Objets : Constantes, Variables, Signaux

35

. Variable

library IEEE; use IEEE.STD_LOGIC_1164.ALL;

entity synthese_var is

Port ( a : in STD_LOGIC;

b : in STD_LOGIC; c : in STD_LOGIC; clk : in STD_LOGIC; y : out STD_LOGIC);

end synthese_var;

architecture Behavioral of synthese_var is

BEGIN

PROCESS(clk) VARIABLE tmp : STD_LOGIC; BEGIN

if rising_edge(clk) then

tmp := a and b; y <= tmp or c;

end if;

END PROCESS;

end Behavioral;

a b c

clk

Synthèse

y

0

www.istic.univ-rennes1.fr

4. Objets : Constantes, Variables, Signaux

36

. Signaux (signal)

. Utilisation en mode concurrent et séquentiel . Déclaration dans une "zone" concurrente . Signaux internes, temporaires . Synthèse (représentation matérielle : un fil ou une mémoire) . Absence de mode

. Synthèse d'une VARIABLE  Synthèse d'un SIGNAL . Une valeur courante . Une valeur future

0

www.istic.univ-rennes1.fr

4. Objets : Constantes, Variables, Signaux

37

. Signaux (signal)

. Synthèse d'une VARIABLE  Synthèse d'un SIGNAL

library IEEE; use IEEE.STD_LOGIC_1164.ALL;

entity synthese_signal is

Port ( a : in STD_LOGIC;

b : in STD_LOGIC; c : in STD_LOGIC; clk : in STD_LOGIC; y : out STD_LOGIC);

end synthese_signal;

architecture Behavioral of synthese_signal is SIGNAL tmp : STD_LOGIC; BEGIN

PROCESS(clk) BEGIN

if rising_edge(clk) then

tmp <= a and b; y <= tmp or c;

end if;

END PROCESS;

end Behavioral;

a

b

clk

c

Synthèse

tmp

y

Synthèse

www.istic.univ-rennes1.fr

0

5. Attributs

38

. Informations supplémentaires sur les types et objets . Utilisation : T'att avec T un objet ou un type et att un attribut

. Attributs d'un scalaire

T'left T'right T'low T'high

-> Limite gauche de T -> Limite droite de T -> Limite basse de T -> Limite haute de T

. Attributs d'un ensemble discret

-> Numéro de la position de X dans T

T'pos(X) T'val(N)-> Valeur à la position N dans T T'leftof(X) T'rightof(X) T'pred(X)

-> Valeur à une position à gauche de X dans T -> Valeur à une position à droite de X dans T -> Valeur à une position au dessous de X dans T

T'succ(X)

-> Valeur à une position au dessus de X dans T

0

www.istic.univ-rennes1.fr

5. Attributs

39

. Exemples - Attributs d'un type scalaire

Type adr is integer range 7 downto 0;

adr'left = 7 adr'right = 0 adr'low = 0 adr'high = 7

. Exemples - Attributs d'un type « ensemble discret »

Type MVL4 is ('U', '0', '1', 'Z');

MVL4'pos('1') = 2 MVL4'val(0) = 'U' MVL4'rightof('1') = 'Z'

MVL4'leftof('1') = '0' MVL4'succ(2) = 'Z' MVL4'prec(2) = '0'

0

www.istic.univ-rennes1.fr

5. Attributs

40

. Attributs d'un tableau

 Limite gauche de l'intervalle des indices de la dim. N de A  Limite droite de l'intervalle des indices de la dim. N de A  Limite basse de l'intervalle des indices de la dim. N de A  Limite haute de l'intervalle des indices de la dim. N de A  Intervalle des indices de la dim. N de A

A'left(N) A'right(N) A'low(N) A'highof(N) A'range(N) A'reverse_range(N)  Intervalle inverse des indices de la dim. N de A  Longueur de l'intervalle des indices de la dim. N de A A'length(N)

. Attributs d'un signal

S'stable(t)  Renvoie une valeur booléenne à true si S est constant

depuis au moins t

S'event  Renvoie une valeur booléenne à true si S a changé depuis

le dernier cycle de simulation

0

www.istic.univ-rennes1.fr

5. Attributs

41

. Exemples : Attributs d'un tableau

type word is bit_vector(31 downto 0); type memory is array(7 downto 0) of word; variable mem : memory;

mem'left = 7 mem'left(3) = 31 mem'right = 0 mem'low = 0 mem'high = 7 mem'high(5) = 31

mem'range = 7 downto 0 mem'range(3) = 31 downto 0 mem'reverse_range = 0 to 7 mem'length = 8 mem'length(3) = 32

0

www.istic.univ-rennes1.fr

6. Exécution parallèle et séquentielle

42

. Particularisme du VHDL : Exécution parallèle ou séquentielle

. Exécution parallèle

. Exécution par défaut . Les instructions au sein d'une architecture sont exécutées en parallèle ou de manière concurrente . Exécution concurrente = Exécution combinatoire . Chaque opération dans une architecture est exécutée à chaque instant

. Exécution séquentielle

. Nécessité d'utiliser un PROCESS . Le process est activé à chaque fois qu'un signal déclaré dans sa liste de sensibilité change de valeur. . Les instructions sont exécutées séquentiellement . Les modifications des signaux (signal) sont effectives à la fin du process

0

www.istic.univ-rennes1.fr

6. Exécution parallèle et séquentielle

43

. Exécution mixte

. Possibilité d'associer dans une même architecture des modules à exécution parallèle et séquentielle . Exemple : Comparateur synchrone à une horloge clk

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY comp_synch IS PORT ( a, b, clk, reset : IN bit; qs : OUT bit); END comp_synch; ARCHITECTURE archi_mixte OF comp_synch IS SIGNAL q : bit; BEGIN

q<='1‘ WHEN a=b ELSE '0'; PROCESS(clk, reset) BEGIN

Synthèse

a

b

Comparateur

qs

q

clk

Reset

IF reset='0' THEN qs<='0'; ELSIF (clk'event AND clk='1') THEN qs <= q; END IF;

END PROCESS;

END archi_mixte;

www.istic.univ-rennes1.fr

0

7. Instructions

44

. Deux types d'exécution : Deux familles d'instructions

. Instructions réservées au mode d'exécution parallèle ou concurrente

- Toutes les opérations sont exécutées simultanément - L'ordre d'écriture n'a aucune importance

I1

I2

I3

. Instructions réservées au mode d'exécution séquentielle - Chaque opération est effectuée l'une après l'autre - L'ordre d'écriture a une grande importance

0

www.istic.univ-rennes1.fr

I1

I2

I3

7.1 Instructions de type parallèle

45

. Assignation inconditionnelle . Assignation conditionnelle

signal <= {expression WHEN condition} ELSE expression

ARCHITECTURE flot_de_donnees OF xor IS BEGIN

c <= '0' WHEN a = '0' AND b = '0' ELSE '1' WHEN a = '0' AND b = '1' ELSE '1' WHEN a = '1' AND b = '0' ELSE '0' WHEN a = '1' AND b = '1' ELSE '0';

END flot_de_donnees;

0

www.istic.univ-rennes1.fr

7.1 Instructions de type parallèle

46

. Assignation sélective

WITH sélecteur SELECT signal <= {expression WHEN valeur_sélecteur,

expression WHEN OTHERS};

ARCHITECTURE flot_de_donnees OF mux IS SIGNAL selection : std_logic_vector(0 TO 1); SIGNAL a,b,c,d,s : std_logic_vector(0 TO 7); BEGIN

WITH selection SELECT s <= a WHEN "00"; b WHEN "01"; c WHEN "10"; d WHEN OTHERS;

END flot_de_donnees;

0

www.istic.univ-rennes1.fr

7.1 Instructions de type parallèle

47

. Assignation d'un composant

label : nom_du_composant PORT MAP (association des ports)

ARCHITECTURE arch_full OF full_adder IS SIGNAL inter : bit; COMPONENT half_adder PORT (a,b,cin : IN bit;

cout,s : OUT bit);

END COMPONENT; BEGIN

u1 : half_adder PORT MAP (a=>a(0),b=>b(0),cin=>cin,cout=>inter,s=>s(0)); u2 : half_adder PORT MAP (a=>a(1),b=>b(1),cin=>inter,cout=>cout,s=>s(1));

END arch_full;

. Instruction GENERATE

label : FOR variable_boucle IN val_iniale TO val_finale GENERATE {instructions parallèles} END GENERATE label

0

www.istic.univ-rennes1.fr

48

7.1 Instructions de type parallèle

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY mod_gen IS

GENERIC(N : integer := 4); PORT(

a,b : IN std_logic_vector(N DOWNTO 1); cin : IN std_logic; s : OUT std_logic_vector(N DOWNTO 1); cout : OUT std_logic);

END mod_gen ARCHITECTURE structurel OF mod_gen IS COMPONENT ADDER PORT(a,b,cin : IN std_logic;s,cout : OUT std_logic); END COMPONENT SIGNAL carry : std_logic_vector(N-1 DOWNTO 1); BEGIN

gene : FOR I IN 1 TO N GENERATE ls_bit : IF i=1 GENERATE

ls_cell : adder PORT MAP(a(1),b(1),cin,s(1), carry(1));

END GENERATE ls_bit; middle_bit : IF i>1 and i<N GENERATE

middle_cell : adder PORT MAP(a(i),b(i),carry(i-1),s(i), carry(i));

END GENERATE middle_bit; ms_bit : IF i=N GENERATE

ms_cell : adder PORT MAP(a(N),b(N),carry(N-1),s(N), cout);

END GENERATE ms_bit;

END GENERATE gene;

END structurel;

0

www.istic.univ-rennes1.fr

7.1 Instructions de type parallèle

49

. Instruction PROCESS

- Toutes les instructions comprises dans le PROCESS sont exécutées séquentiellement

- Instruction concurrente : possibilité d'en utiliser plusieurs

- Tous les PROCESS sont exécutés en parallèle

- Activation d'un PROCESS : 2 possibilités

[label] : PROCESS(liste_signaux)

[label] : PROCESS

-- Partie déclarative du process

-- Partie déclarative du process

BEGIN

-- Corps du process

END PROCESS [label]

BEGIN

WAIT UNTIL (liste_signaux) -- Corps du process

END PROCESS [label]

0

www.istic.univ-rennes1.fr

7.1 Instructions de type parallèle

50

. Instruction PROCESS : Attribut event

. But : Savoir si le signal auquel il est associé a été modifié . Très utile dans un PROCESS déclenchable par plusieurs signaux distincts . Exemples :

IF CLK'event THEN exécution; END IF;

- Exécution si CLK passe à 0 ou à 1

IF CLK'event AND CLK='1' THEN exécution; END IF;

- Déclenchement sur front montant

. Standard IEEE 1164 : Définition de deux fonctions rising_edge(CLK) et falling_edge(CLK)

0

www.istic.univ-rennes1.fr

7.2. Instructions de type séquentiel

51

. Ces instructions sont uniquement utilisées dans un Process

. Assignation inconditionnelle de variables et de signaux Même traitement que pour le mode parallèle

SIGNAL sig : integer; PROCESS(clk)

VARIABLE var : integer := 0;

BEGIN

sig <= sig + 1; var := var + 1;

END PROCESS;

. Instruction IF

IF expresssion_booleenne THEN

instructions_sequentielles

END IF;

IF up_down = '1' THEN s <= s + 1;

ELSE

END IF;

s <= s - 1;

0

www.istic.univ-rennes1.fr

7.2. Instructions de type séquentiel

52

. Instruction CASE

CASE expresssion is

{WHEN valeur_expression => instructions_sequentielles}; {WHEN OTHERS => instructions_sequentielles};

END CASE;

CASE selection IS

WHEN '0' => s <= a; WHEN '1' => s <= b; WHEN OTHERS => NULL;

END CASE;

. Instruction LOOP

instruction_pour_iteration LOOP

instructions_sequentielles

END LOOP;

VARIABLE indice,resultat : INTEGER := 0; Boucle1 : WHILE indice < 10 LOOP

indice := indice + 1; resultat := resultat + adresse(indice);

END LOOP boucle1;

VARIABLE indice,resultat : INTEGER; Boucle2 : FOR indice IN 0 TO 9 LOOP

resultat := resultat + adresse(indice);

0

END LOOP boucle2;

www.istic.univ-rennes1.fr

7.2. Instructions de type séquentiel

53

. Instruction NEXT

NEXT label_boucle WHEN condition

VARIABLE indice,resultat : integer := 0; Boucle1 : WHILE indice < 10 LOOP

indice := indice + 1; NEXT boucle1 WHEN indice = 5; resultat := resultat + adresse(indice);

END LOOP boucle1;

VARIABLE indice,resultat : integer; Boucle2 : FOR indice IN 0 TO 9 LOOP NEXT boucle2 WHEN indice = 5; resultat := resultat + adresse(indice);

END LOOP boucle2;

. Instruction EXIT

EXIT label_boucle WHEN condition

VARIABLE indice,resultat : integer := 0; Boucle1 : WHILE indice < 10 loop

indice := indice1 + 1; EXIT boucle1 WHEN indice = 5; resultat := resultat + adresse(indice);

END LOOP boucle1;

VARIABLE indice,resultat : integer; Boucle2 : FOR indice IN 0 to 9 LOOP EXIT boucle2 WHEN indice = 5; resultat := resultat + adresse(indice);

END LOOP boucle2;

0

www.istic.univ-rennes1.fr

7.2. Instructions de type séquentiel

54

. Instruction NULL

Instruction sans aucun effet

CASE commande_moteur IS

WHEN avant => marche_avant; WHEN arriere => marche_arriere; WHEN statuquo => NULL;

END CASE;

. Instruction ASSERT

Vérification d'une condition spécifique Information d'une éventuelle violation de cette condition ASSERT condition REPORT message SEVERITY {note/warning/error/Failure}

PROCESS(clk) BEGIN IF clk='1' THEN

ASSERT d'STABLE(15 ns); REPORT "setup non respecté" SEVERITY warning; … END IF; END PROCESS;

www.istic.univ-rennes1.fr

0

7.3. Instructions : Exemple

55

. Multiplexeur 8 bits : 4 vers 1

1ère phase : définition des entrée/sorties (ENTITY)

Entrées

Multiplexeur 8 bits 4 vers 1

Sorties

Entree1

Entree2

Entree3

Entree4

8

8

8

8

Multiplexeur 8 bits 4 vers 1

8

Sortie

Sel

0

www.istic.univ-rennes1.fr

7.3. Instructions : Exemple

56

. Multiplexeur 8 bits : 4 vers 1

2ème phase : définition du fonctionnement ou de la structure

(ARCHITECTURE)

- Solution 1 : Instruction IF

- Solution 2 : Instruction CASE

0

www.istic.univ-rennes1.fr

7.3. Instructions : Exemple

57

. Multiplexeur 8 bits : 4 vers 1 - Solution 1 : Instruction IF

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY mux41 IS

PORT(entree1,entree2,entree3,entree4: IN std_logic_vector(0 TO 7);

sel: IN std_logic_vector(0 to 1); sortie : OUT std_logic_vector(7 DOWNTO 0));

END mux41; ARCHITECTURE comportementale OF mux41 IS BEGIN

PROCESS(sel) BEGIN

IF (sel="00") THEN sortie<=entree1; ELSIF (sel="01") THEN sortie<=entree2; ELSIF (sel="10") THEN sortie<=entree3; ELSE sortie<=entree4;END IF;

END PROCESS; END comportementale;

www.istic.univ-rennes1.fr

0

7.3. Instructions : Exemple

58

. Multiplexeur 8 bits : 4 vers 1

- Solution 2 : Instruction CASE

LIBRARY ieee; USE ieee.std_logic_1164.all; ENTITY mux41 IS

PORT(entree1,entree2,entree3,entree4: IN std_logic_vector(0 TO 7);

sel: IN std_logic_vector(0 to 1); sortie : OUT std_logic_vector(7 DOWNTO 0));

END mux41; ARCHITECTURE comportementale OF mux41 IS BEGIN

PROCESS(sel) BEGIN CASE sel IS

WHEN "00" => sortie<=entree1; WHEN "01" => sortie<=entree2; WHEN "10" => sortie<=entree3; WHEN OTHERS => sortie<=entree4;

END CASE; END PROCESS; END comportementale;

0

www.istic.univ-rennes1.fr

8. Opérateurs standards

59

. Remarque : Le VHDL est un langage développé initialement pour la modélisation et la simulation, par conséquent certains opérateurs sont à déconseiller en synthèse

. Opérateurs logiques

Nom

Type opérandes

Signification

And

Nand

Or

Nor

Xor

Xnor

Not

Boolean Bit ou Bit_vector

Et

Non et

Ou

Non ou

Ou exculsif

Egal

Non

0

www.istic.univ-rennes1.fr

8. Opérateurs standards

60

. Opérateurs logiques

. Exemple 1

SIGNAL a,b,c : bit_vector(0 TO 1);

c <= a AND b;

Synthèse

. Exemple 2

SIGNAL d, e, f, g : bit;

g <= (d AND e) AND f;

Synthèse

a(0)

b(0)

a(1)

b(1)

d e f

c(0)

c(1)

g

0

www.istic.univ-rennes1.fr

8. Opérateurs standards

61

. Opérateurs relationnels

Nom

Type opérandes

Signification

=

/=

< <=

>

>=

. Exemple

Entrées : Tout scalaire Sortie : Boolean

Egal

Non égal

Inférieur

Inférieur ou égal

Supérieur

Supérieur ou égal

SIGNAL a,b : bit_vector(1 DOWNTO 0); SIGNAL s : bit;

process(a,b) BEGIN IF a > b THEN s <= ‘1’; ELSE s <= ‘0’; END IF;

END process;

Synthèse

a0 a1 !b0

a0 !b1 !b0

a1

!b1 www.istic.univ-rennes1.fr

s

0

8. Opérateurs standards

62

. Opérateurs de décalages

Nom

Type opérandes

Signification

Bit_vector

A gauche

A droite

Circulaire gauche

Circulaire droit

Sll

Srl

Rol Ror . Exemple ENTITY sll_example IS PORT(sel: IN bit;

a : IN bit_vector(3 DOWNTO 0); b : OUT bit_vector(3 DOWNTO 0));

Synthèse

END sll_example; ARCHITECTURE comportementale OF sll_example IS BEGIN

PROCESS(sel) BEGIN if sel='1' then b <= a sll 1;end if; END PROCESS; END comportementale;

www.istic.univ-rennes1.fr

a0

a1

a2

a3

'0'

0

sel

b0

b1

b2

b3

8. Opérateurs standards

63

. Opérateurs arithmétiques

Nom

Type opérandes

Signification

+

-

* /

abs

**

mod

rem

Integer, Real

Integer

Incrémentation de 1 ou addition

Décrémentaion de 1 ou soustraction

Multiplication

Division

Valeur absolue

Puissance

Modulo

Reste

. Autres opérateurs

Nom

Type opérandes

&

Bit, Bit_vector

Signification

Concaténation

0

www.istic.univ-rennes1.fr

. Exemple : addition

S = (A + B) + (C - 1) T = ((A + B) + C - 1)

Synthèse

. Exemple : multiplication

8. Opérateurs standards

64

A

B C

A

B C

- 1

CC : 3

S

- 1

T

. Opération de multiplication "*" permet d'utiliser le type INTEGER . Différents résultats de synthèse

- Contraintes - Nature des entrées (puissance de 2) - Bibliothèques de composants disponibles (Package standard de synthèse)

0

www.istic.univ-rennes1.fr

8. Opérateurs standards

65

. Opérateur de concaténation

Nom

Type opérandes

&

Bit, Bit_vector

Signification

Concaténation

ENTITY concatenation_example IS

PORT(a : IN bit_vector(3 DOWNTO 0);

b : IN bit; c : OUT bit_vector(5 DOWNTO 0));

END concatenation_example; ARCHITECTURE comportementale OF

concatenation_example IS

BEGIN

C <= not B & "101" & not A(2 DOWNTO 1);

END comportementale;

Synthèse

A(1)

A(2)

VDD GND VDD

B

0

C(0)

C(1)

C(2) C(3) C(4)

C(5)

www.istic.univ-rennes1.fr

9. Description hiérarchique

66

. Descriptions plus simples

. Rapidité de simulation et donc rapidité de mise au point

. Fiabilité accrue

. Réutilisation de sous-ensembles

. Concepts :

COMPONENT, GENERIC, PACKAGE,

PROCEDURE ET FONCTION LIBRARY, CONFIGURATION

. Amélioration de la modularité

. Utilisation d'un élément décrit à l'extérieur de la description utilisatrice

. Compilation distincte et stockage dans la bibliothèque WORK :

. le composant

. l'entité/architecture utilisatrice de ce composant

0

www.istic.univ-rennes1.fr

9.1 Description hiérarchique : Component

67

. Description structurelle . Utilisation de composants

2 phases : - Déclaration

- Instanciation

Adder1.vhd

ENTITY half_adder IS PORT( a,b,cin : IN bit;

cout,s : OUT bit);

END half_adder;

ARCHITECTURE arch_half OF half_adder IS BEGIN

s <= a xor b XOR cin; cout <= (a AND b) OR (a AND cin) OR (b AND cin);

END arch_half;

Adder2.vhd

ENTITY full_adder IS PORT(

a,b : IN bit_vector(1 DOWNTO 0); cin : IN bit; cout : OUT bit; s : out bit_vector(1 DOWNTO 0));

END full_adder;

ARCHITECTURE arch_full OF full_adder IS SIGNAL inter : bit; COMPONENT half_adder PORT (a,b,cin : IN bit; cout,s : OUT bit);

END COMPONENT; BEGIN u1:half_adder PORT MAP (a(0),b(0),cin,inter,s(0)); u2:half_adder PORT MAP (a(1),b(1),inter,cout,s(1)); END arch_full;

0

www.istic.univ-rennes1.fr

9.2 Description hiérarchique : Generic

68

. Possibilité d'utiliser un même objet plusieurs fois avec des tailles différentes . Paramètres à définir lors de l'instanciation . Possibilité d'instancier des entités/architectures fonctionnellement identiques mais de taille différente

ENTITY adder is

. Déclaration d'un additionneur

GENERIC (largeur : integer :=8); -- valeur par défaut

PORT(

a,b: IN signed_vector(largeur-1 DOWNTO 0);

s : OUT signed_vector(largeur DOWNTO 0);

END adder;

. Instanciation avec une largeur de 16 bits

ARCHITECTURE arch_adder OF adder IS BEGIN

s <= a + b;

END arch_adder;

U0 : adder GENERIC MAP (largeur => 16) 0

PORT MAP (a=>a,b=>b,s=>s);

www.istic.univ-rennes1.fr

9.3 Description hiérarchique : Package

69

.