PROGRAMME CHAPITRE 0 I. INTRODUCTION II. Conception d'un circuit lectronique numrique l'aide du VHDL III.

.Logiciels pour dbuter en VHDL IV.Exemples CHAP I STRUCTURE DU LANGAGE

I. Conventions lexicalesCaractres utilisables, II. BibliothquesO sont stocks les rsultats III. Entit La vue externe du circuit IV. Architecture La vue interne du circuit V. Paquetage Les objets communs

casse, ...

CHAP II TYPES ET OPERATIONS DE BASES

I. II.

Types entiers C'est le type de base, sur 32 bits

Types numrs Les types Boolens et bits font partie de cette catgorie. III. Types tableau Indispendables pour reprsenter des vecteurs, des matrices, des mmoires. IV. Types fichiersServent effectuer des tests en lisant et/ou gnrant des donnes contenues dans ces fichiers. V. Autres types Une vue d'ensemble des autres types dfinis dans les bibliothques standards. VI. Attibuts Permettent de consulter les caractristiques des types ou d'objets dclars. Il est possible de dclarer ses propres attributs. VII. Oprateurs La palette d'oprateurs standards. VIII. IEEE Bibliothque utilise par tous les outils de synthse et permettant de travailler sur des types logiques 9 tats. CHAP III VHDL STRUCTUREL
I.

Elments de basequ'est-ce qu'un composant, que contient-il ?

Dclaration et instanciation des composants comment dclare-t-on un composant (dclaration) et comment l'appeler pour le connecter (instanciation) ? III. Composants gnriques VHDL offre la possibilit d'avoir des composants gnriques comme par exemple un compteur sur N bits o N est un paramtre qu'il faut indiquer au moment de l'instanciation. Comment fait on pour passer des paramtres ce type de composants IV. Configurations VHDL offre la possibilit d'avoir plusieurs scnarios d'architecture pour un mme composant. Comment configurer le composant ?
II.

CHAPITRE IV VHDL COMPORTEMENTAL Instructions concurrentes et squentiellesVHDL utilise aussi bien les 2 types pour coder le comportement d'un circuit. Quelle diffrence ? II. Processus et synchronisationComment dmarrer un processus ? III. Variables et signauxComment utiliser ces 2 types d'objets dans un processus ? IV. Stuctures de contrleL o vhdl rejoint le C. V. Affectations concurrentesComment crire une quation sans passer par un processus ? VI. Affectations et dlaisPour modliser le temps. Attention, pige. VII. AssertionsComment vrifier une proprit et envoyer un message associ en cours de simulation ? VIII. Sous-programmesComment crer des fonctions et des procdures ? IX. Fonctions de rsolutionQuelle valeur prend un signal affect dans plusieurs processus ?
I.

CHAPITRE 0 I. INTRODUCTION Le VHDL est un langage de description de systmes matriels (HDL), c'est--dire un langage utilis pour dcrire un systme numrique matriel, comme, par exemple, un flip-flop (bascule D) ou un microprocesseur. Il peut modliser un systme par n'importe quelle vue, structurelle ou comportementale, tous les niveaux de description. De plus il peut servir non seulement simuler un systme mais aussi le synthtiser , c'est--dire tre transform par des logiciels adapts (synthtiseurs) en une srie de portes logiques prtes tre graves sur du silicium. A ct du VHDL, Il existe d'autres langages de description de systmes matriel: VERILOG, ABEL. Labrviation VHDL signifie VHSIC Hardware Description Language

(VHSIC : Very High Speed Integrated Circuit). Il est le rsultat des travaux mens dans les annes 70 et 80 par le dpartement d'tat pour la dfense amricain. En 1986, le VHDL a t propos comme standard IEEE(Institute of Electrical and Electronics Engineers). Aprs plusieurs modifications et amliorations, il a t standardis en 1987 sous le standard IEEE 10761987. D'autres standards sont apparus aprs d'autres travaux et le dernier en date est le standard IEEE 1076-2002. Le langage VHDL a t conu pour rpondre plusieurs besoins: Il permet de dfinir la description du circuit lctronique concvoir Le langage de programmation utilis a une forme familire Il permet que le circuit lectronique conu soit test par une simulation avant sa ralisation, ce qui permet d'y apporter des correctifs. Le langage VHDL n'est pas un langage de programmation comme les langages C, JAVA...etc. Il n'est pas destin un compilateur qui va en faire un excutable mais il vise: la simulation, la synthse, la spcification, la documentation.

Les avantages de VHDL : indpendant du constructeur indpendant de la technologie indpendant de la dmarche indpendant du niveau de conception Standard IEEE reconnu par les vendeurs doutils CAO grand nombres de bibliothques : doprateurs de composants de fonction nombreux outils : compilateur, simulateur mais aussi des outils de synthse et de spcification II. Conception d'un circuit lectronique numrique l'aide du VHDL

La fabrication se fait sur des circuits logiques programmables (CPLD, FPGA).

III.

Logiciels pour dbuter en VHDL

diteur Xilinx

Produit ISE

Synthti Simulat Remarq seur eur ues Proprita Oui Oui Simulate Licence

Webpac k4

ire, gratuite, illimit Proprita ire, gratuite, Oui 6 mois renouvel able Proprita ire, gratuite, Oui 6 mois renouvel able

Altera

Quartus II Web Edition5

Oui

ur ModelSi m XE Starter gratuit Simulate ur ModelSi m Altera Edition gratuit

Lattice

ispLever starter6

Non

Actel

Libero7

Proprita ire, gratuite, Oui 1 an renouvel able

Oui

Synthtis eur : Synplify Actel Edition (gratuit), Simulate ur ModelSi m Actel Edition gratuit

Simulateurs uniquement ActiveProprita HDL ire, Tiers Aldec Student gratuite, partie Edition8 1 an Mentor ModelSi Proprita Non Graphics m PE ire, Student gratuite

Oui Oui

Edition9 Simulate ur SMASH Discover y gratuit (avec exemple s en VHDL)

Dolphin Integratio n

Proprita SMASH1 ire, Non 0 gratuite

Oui

IV. Porte AND

EXEMPLES

------------------------------------------------- AND gate -- two descriptions provided -------------------------------------------------library ieee; use ieee.std_logic_1164.all; -------------------------------------------------entity AND_ent is port(x: in std_logic; y: in std_logic; F: out std_logic ); end AND_ent;

-------------------------------------------------architecture behav1 of AND_ent is begin process(x, y) begin -- compare to truth table if ((x='1') and (y='1')) then F <= '1'; else F <= '0'; end if; end process; end behav1; architecture behav2 of AND_ent is begin F <= x and y; end behav2; Porte NAND ------------------------------------------ NAND gate --

-- two descriptions provided ----------------------------------------library ieee; use ieee.std_logic_1164.all; -----------------------------------------entity NAND_ent is port(x: in std_logic; y: in std_logic; F: out std_logic ); end NAND_ent; -----------------------------------------architecture behv1 of NAND_ent is begin process(x, y) begin -- compare to truth table if (x='1' and y='1') then F <= '0'; else F <= '1';

end if; end process; end behv1; ----------------------------------------architecture behv2 of NAND_ent is begin F <= x nand y; end behv2; Porte OR --------------------------------------- OR gate --- two descriptions provided -------------------------------------library ieee; use ieee.std_logic_1164.all; -------------------------------------entity OR_ent is port(x: in std_logic; y: in std_logic; F: out std_logic

); end OR_ent; --------------------------------------architecture OR_arch of OR_ent is begin process(x, y) begin -- compare to truth table if((x='0') and (y='0')) then F <= '0'; else F <= '1'; end if; end process; end OR_arch; architecture OR_beh of OR_ent is begin F <= x or y; end OR_beh; --------------------------------------PORTE NOR

------------------------------------------ NOR gate --- two descriptions provided ----------------------------------------library ieee; use ieee.std_logic_1164.all; ----------------------------------------entity NOR_ent is port(x: in std_logic; y: in std_logic; F: out std_logic ); end NOR_ent; -----------------------------------------architecture behv1 of NOR_ent is begin process(x, y) begin -- compare to truth table if (x='0' and y='0') then

F <= '1'; else F <= '0'; end if; end process; end behv1; architecture behv2 of NOR_ent is begin F <= x nor y; end behv2;

Additionneur 1 bit --------------------------------------------------------- VHDL code for n-bit adder (ESD figure 2.5) -- by Weujun Zhang, 04/2001 --- function of adder: -- A plus B to get n-bit sum and 1 bit carry -- we may use generic statement to set the parameter -- n of the adder. --------------------------------------------------------

library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all; -------------------------------------------------------entity ADDER is generic(n: natural :=2); port(A: B: in std_logic_vector(n-1 downto 0); in std_logic_vector(n-1 downto 0); out std_logic; out std_logic_vector(n-1 downto 0)

carry: sum: ); end ADDER;

-------------------------------------------------------architecture behv of ADDER is -- define a temparary signal to store the result signal result: std_logic_vector(n downto 0); begin -- the 3rd bit should be carry result <= ('0' & A)+('0' & B); sum <= result(n-1 downto 0);

carry <= result(n); end behv; Additionneur 4 bits library IEEE; use IEEE.std_logic_1164.all; use IEEE.numeric_std.all; entity adder4 is port ( a, b : in unsigned(3 downto 0); s : out unsigned(3 downto 0); cout : out std_logic ); end entity; architecture arc of adder4 is signal resultat : unsigned(4 downto 0); begin resultat <= ('0' & a) + ('0' & b); s <= resultat(3 downto 0); cout <= resultat(4); end arc; Comparateur ---------------------------------------------------- n-bit Comparator -- by Weijun Zhang, 04/2001 --- this simple comparator has two n-bit inputs &

-- three 1-bit outputs --------------------------------------------------library ieee; use ieee.std_logic_1164.all; --------------------------------------------------entity Comparator is generic(n: natural :=2); port(A: B: less: equal: greater: ); end Comparator; --------------------------------------------------architecture behv of Comparator is begin process(A,B) begin if (A<B) then less <= '1'; in std_logic_vector(n-1 downto 0); in std_logic_vector(n-1 downto 0); out std_logic; out std_logic; out std_logic

equal <= '0'; greater <= '0'; elsif (A=B) then less <= '0'; equal <= '1'; greater <= '0'; else less <= '0'; equal <= '0'; greater <= '1'; end if; end process; end behv;

CHAPITRE I

Structure du langage

L'analyse d'un modle VHDL peut s'effectuer sur des parties du code ou "units de compilation". Il existe 5 types d'units de compilation : L'entit L'architecture Le paquetage Le corps du paquetage La configuration L'entit et l'architecture sont des units de compilation obligatoires pour dcrire un modle. Les autres units sont optionnelles mais

quasiment indispensables pour concevoir des gros circuits ncessitant une mthode de conception efficace. Une unit de compilation doit tre crite dans le mme fichier et un mme fichier peut contenir plusieurs units de compilation.

I. CONVENTIONS LEXICALES Les conventions lexicales de vhdl sont les mmes que celles utilises en C. Un code vhdl est compos d'une suite d'lments : commentaires dlimiteurs nombres chanes de caractres identificateurs mots-clefs Casse VHDL est insensible la casse. Un mot en majuscule est identique un mot en minuscule. Il est cependant conseill d'avoir des rgles d'criture cohrentes. Par exemple, les mots reservs du langage peuvent tre en majuscule et les autres mots en minuscule. Commentaires Les commentaires doivent tre inclus dans le code, pour augmenter la lisibilit et la documentation. Ils commencent par 2 tirets (--) en se terminent en fin de ligne Il est impratif de documenter vos codes, l'cole comme en entreprise. Identificateurs Ce sont les noms de variables, de signaux, de fonctions, ... Ils ne peuvent contenir que des lettres, des chiffres et le "underscore" _ .

Ils doivent commencer par une lettre. Ils ne peuvent pas contenir d'espace. Les mots-clefs du langage ne peuvent pas tre utiliss comme identificateurs. Expressions Elles se terminent par un point virgule ; Litraux Ce sont des valeurs explicites : 67 est un littral pour le type entier '0' est un littral pour un bit "001" O"562" X"FF1" sont des littraux pour les vecteurs de bits "chaine" est un littral de type chaine de caractres null est un litral pointeur II. BIBLIOTHEQUES

Les bibliothques permettent plusieurs concepteurs de travailler ensemble sur le mme projet et rendent le langage indpendant du systme dexploitation de la machine hte. La cration de la bibliothque ne fait pas partie du langage VHDL Chaque outil VHDL a donc ses propres rgles de cration.. Par exemple avec le simulateur ModeSim il faut crer la bibliothque avec cette commande : vlib BIB L'accs la bibliothque fait partie du langage VHDL. Pour accder la bibliothque BIB il est ncessaire de la dclarer : library BIB; La bibliothque par dfaut est WORK . WORK est aussi le nom symbolique de la bibliothque dans laquelle sont stocks les rsultats. La bibliothque STD est une bibliothque standard fournie avec le langage , elle contient des dfinitions des types et des fonctions de base (integer, BIT, BOOLEAN,...) dans le paquetage STANDARD et des

fonctions sur les caractres dans le paquetage TEXTIO. Par dfaut, les bibliothques STD et WORK nont pas besoin dtre dclares pour tre utilisables. Tout se passe comme si un programme VHDL commenait toujours par : library STD;library WORK; Il est trs pratique d'utiliser les paquetages des bibliothques ce qui permet d'utiliser des objets (constantes, fonctions, composants,...) qui peuvent tre dfinis dans une bibliothque diffrente de celle en cours. C'est le cas des bibliothques standards comme l'IEEE qui dfinit des types et objets normaliss compris par les outils de synthse. Pour utiliser le contenu dun paquetage, il faut dclarer la bibliothque dans laquelle il se trouve (sauf, ventuellement, si cest WORK) et le paquetage : use BIBLIOTHEQUE.PAQUETAGE.all; ou, si lon ne veut pas utiliser tout le paquetage mais un seul objet : use BIBLIOTHEQUE.PAQUETAGE.OBJET; III. ENTITE

L'entit est la description de l'interface du circuit . Elle correspond au symbole dans les reprsentations schmatiques : L'entit prcise : le nom du circuit Les ports d'entre-sortie : Leur nom Leur direction (in, out, inout,...) Leur type (bit, bit_vector, integer, std_logic,...) Les paramtres ventuels pour les modles gnriques L'criture de l'entit pour l'additioneur 1 bit fa peut tre la suivante . Il faut noter la dclaration pralable de la bibliothque IEEE et des paquetages qui permet d'utiliser le type std_logic. (std_logic_1164) et des fonctions arithmtiques (numeric_std).

library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; -entity fa is port ( a, b, cin : in std_logic; s, cout : out std_logic ); end entity; IV. ARCHITECTURE

L'architecture est la description interne du circuit. Elle est toujours associe une entit. Une mme entit peut avoir plusieurs architecture. Le mcanisme de configuration (dcrit dans le VHDL structurel) permet d'indiquer l'architecture rattache une entit. L'exemple suivant montre un schma de l'additionneur 1 bit fa et 2 architectures possibles crites en VHDL :

architecture arc1 of fa is -signal resultat : unsigned(1 downto 0); -begin -resultat <= ('0' & a) + ('0' & b) + ('0' & cin); s <= resultat(0); cout <= resultat(1);

architecture arc2 of fa is -begin -s <= a xor b xor cin; cout <= (a and b) or ((a xor b) and cin); -end arc1; --

-end arc1; VHDL = langage dclaratif et typ VHDL est un langage trs dclaratif qui permet au compilateur d'effectuer des vrifications pousses et fiabiliser ainsi l'criture d'un modle. Dans une architecture il est ncessaire de dclarer les objets utiliss et leur type avant la zone dcrivant l'architecture (le corps de l'architecture situ entre begin ... end ). Parmi les objets trs utiliss, figurent les composants (correspondent effectivement aux composants dont on a besoin dans l'architecture pour une description structurelle) et les signaux (equipotentielles reliant les instances de composants et les instructions "concurrentes" et). Les ports dclars dans l'entit sont des signaux utilisables dans l'architecture, il ne faut pas les redclarer. L'exemple ci-dessous illustre l'architecture d'un additionneur 1 bit avec les signaux A, B , Cin (qui sont des ports donc des signaux implicites) , le signal Si et le composant MAJ.

Le schma quivalent de l'additionneur 1 bit peut tre le suivant avec 1 composant MAJ et 2 portes XOR qui peuvent tre codes d'une faon comportementale. Le code VHDL correspondant : entity FA is port ( A, B, Cin : in bit; Entit de l'additioneur 1 bit FA

S, Cout : out bit ); end entity; architecture arc3 of fa is -signal SI : bit; -component MAJ port (X,Y,Z : in bit; M : out bit); end component; La partie dclarative de l'architecture, avant le mot cl begin, permet de dclarer le signal SI et le composant MAJ.

begin -p1 : process(SI, Cin) begin S <= SI xor Cin; end process; -SI <= A xor B; -inst_MAJ : MAJ port map ( X => A, Y => B,Z => Cin, M => Cout); -end arc3;

Dans le corps de l'architecture (entre begin et end) se trouvent les 3 types d'instructions concurrentes de VHDLqui peuvent tre crites dans n'importe quel ordre : Un processus avec le mot cl process Une instruction concurrente d'affectation S <= SI xor Cin ( on dit S reoit Si xor Cin) Une instruction d'appel de composant (instanciation) ou un nom d'instance est donn (INST_MAJ) de faon pouvoir appeler plusieurs composants du mme type Les ports sont des signaux implicites dont le sens doit tre respect. Le compilateur VHDL aurait mis une erreur si dans le corps de l'architecture s'tait trouv l'instruction : Cout <= S and B car S est une sortie qui ne peut pas servir d'entre.

V.

PAQUETAGE

Le paquetage est une collection d'objets rutilisables. Il se compose de 2 units de compilation : La dclaration du paquetage Le corps du paquetage Le contenu de la dclaration du paquetage est visible depuis l'extrieur. alors que le corps dcrit la fonction des objets ncessaires l'utilisation du paquetage. Lorsqu'une unit de compilation utilise un paquetage, la dclaration de celui-ci doit tre analyse en premier. Le corps du paquetage n'est pas toujours ncessaire. Exemple de dclaration de paquetage package PAQ is -subtype MOT is bit_vector(7 downto 0); type RAM is array (natural range <>) of MOT; subtype MRAM is RAM(0 to 1023); -constant N_BITS : positive; constant REL : natural := 8; -component BRIQUE generic (N : positive := 12); port (A,B : in bit; S : out bit); end component; -function MIN(A,B,C : integer) return integer; -end package PAQ; Le paquetage PAQ est dclar avec le mot cl package. Des nouveaux types type et soustypes subtype sont dclars. Dans cet exemple on dclare le type MOT qui est un vecteur de 8 bit, un type RAM qui est un tableau de MOT et un sous type MRAM qui est une RAM de 1024 MOTS. Des constantes "constant" N_BITS et REL sont dclares. N_BITS est un entier > 0 "positive" et REL est un entier naturel "NATURAL" et est initialise la valeur 8. Le composant "component" BRIQUE est dclar ici en prcisnat ces ports et paramtres. La dclaration d'un composant permet son instanciation dans l'architecture de faon

effectuer une description structurelle Le sous-programme ou fonction "function" MIN est dclare dans le paquetage. La description de la fonction ser effectue dans le corps du paquetage.

Exemple de corps de paquetage package body PAQ is -constant N_BITS := 16; -function MIN(A,B:integer) return integer is begin if (A<B) then return A; else return B; end if; end if; end MIN; -function MIN(A,B,C : integer) Le corps du paquetage "package body" permet de dcrire les sous-programmes et d'initialiser les constantes. La constante N_BITS est initialise ici. Elle aurait pu tre utilise localement au corps du sous programme sans tre visible de l'extrieur. Les fonctions peuvent tre surcharges en nom ou en type. Ici 2 fonctions MIN sont dcrites , l'une avec 2 entres et l'autre avec 3 entres

return integer is begin return MIN(A, MIN(B,C)); end MIN; -end package body PAQ;

utilisant celle 2 entres.

CHAP II TYPES ET OPERATIONS DE BASES Objectifs VHDL est un langage typ o il est obligatoire de spcifier le type des objets utiliss. Le tableau ci dessous illustre la classification des types du langage VHDL :

L'objectif de ce chapitre est de vous prsenter les types et les oprateurs. A l'issue de ce chapitre, vous serez en mesure de choisir le meilleur type pour l'objet que vous voulez modliser.

I.

TYPES ENTIERS

Le type entier integer prdfini dans le paquetage standard STD permet de dfinir des nombres signs sur 32 bits entre -2-31 et 231 - 1 . Un sous type subtype permet de dclarer un type hritant des proprits du type pre. Il existe 2 "sous types" subtype associs INTEGER : les entiers naturels et les entiers positifs. Leur dclaration dans le paquetage STD est la suivante :

subtype natural is integer range 0 to integer'high; subtype positive is integer range 1 to integer'high Notez que range permet d'indiquer l'intervalle 'HIGH indique la plus grande valeur du type INTEGER, c'est un attribut de type Les types entiers servent dfinir des indices de tableaux et de boucles. Pour cela il est intressant de les restreindre de faon

contrler les dbordements. Par exemple on peut dclarer : subtype UN_A_DIX is natural range (1 to 10); subtype DIX_A_UN is natural range (10 downto 1); Il s'agit d'objets compatibles entre eux mais avec un ordre d'indexation diffrent. Il est donc possible d'effectuer des oprations entre ces objets En revanche si on avait dclar : type UN_A_DIX is natural range (1 to 10); type DIX_A_UN is natural range (10 downto 1); Les 2 types tant indpendants, une opration entre des objets UN_A_DIX et DIX_A_UN aurait caus une erreur de compilation. II. TYPES ENUMERE

Un type numr est un type dfini par une numration exhaustive : type COULEURS is (ROUGE, JAUNE, BLEU, VERT, ORANGE); L'ordre de dclaration est important. Lors de l'initialisation d'un signal de type enumr T, le signal prend la valeur T'LEFT. Par exemple un signal de type COULEURS sera ROUGE en dbut de simulation. Dans le paquetage STANDARD de la bibliothque STD, plusieurs types numrs sont dfinis : type boolean is (FALSE, TRUE); type bit is ('0', '1'); type severity_level is (NOTE, WARNING, ERROR, FAILURE); type character is ( NUL, SOH, STX, ETX,..., '0','1', ...); Notez que la valeur d'un bit est quivalente un caractre et est

toujours entre quotes : '0' et '1' diffrents des entiers 0 et 1. Dans le paquetage STD_LOGIC_1164 de la bibliothque IEEE, le type STD_ULOGIC est dfini par : type std_ulogic is ('U', 'X, 'O', '1', 'Z', 'W', 'L', 'H', '-'); Ceci permet d'avoir 9 tats significatifs de la logique. Ces tats illustrent les cas o le signal est soumis de multiples affectations. Dans ce cas chaque valeur un niveau de priorit. La liste suivante donne la signification de ces 9 valeurs en commenant par la valeur de plus grande priorit : Au dmarrage les signaux sont dans un tat inconnu 'U'. 'X' indique un conflit, le signal est affect d'un ct '1' et d'un autre '0'. '0' et '1' correspondant aux valeurs booleennes du signal. 'Z' correspond l'tat haute 'impdance". 'W' est la valeur d'un signal reli 2 rsistances de tirage, une tirant 0 et l'autre 1. 'H' et 'L' sont des valeurs d'un signal reli respectivement une rsistance de tirage 1 et 0. '-' est un tat indiffrent. Utile pour dcrire les tables de vrit. Le type numr est aussi trs utile pour dfinir les tats d'une machine tats d'une faon symbolique, sans avoir dfinir le codage. III. TYPES TABLEAU

Les types TABLEAU ou array sont des collections d'objets de mme type, indxs par des entiers ou des numrs. Exemples : type bus is array (0 to 31) of bit; type RAM is array (0 to 1024, 0 to 31) of bit; type PRIX is ranger 0 to 1000; type COULEURS is (BLANC, BLEU, VERT, ROUGE, JAUNE, NOIR, ARC_EN_CIEL); type PRIX_PEINTURES is array (COULEUR range BLANC to NOIR) of PRIX;

Un tableau peut avoir une taille inconnue donc non contraint, par exemple le type BIT_VECTOR de la bibliothque STD est un tableau de dimension 1 (vecteur) de taille quelconque :

type bit_vector is array (natural range <>) of bit; et le type STD_ULOGIC_VECTOR de la bibliothque IEEE : type std_ulogic_vector is array (natural range <>) of std_logic_vector; La contrainte de taille est alors exprime dans la dclaration de l'objet : signal toto bit_vector(31 downto 0); signal titi std_ulogic_vector(7 downto 0); Il faut noter que l'indexation peut tre MSB en tte (31 downto 0) , la plus courante, ou LSB en tte (0 to 31). Attention, une affectation de signaux vectoriels ayant des indexations diffrente provoque une inversion des composantes du signal. La valeur d'un vecteur peut tre reprsente dans une base diffrente : "001100" = 0"14" = X"0C" Il peut y avoir des tableaux de tableaux ou des tableaux plusieurs dimensions; Les affectations diffrent quelque peu comme illustr dans l'exemple suivant : type TAB1 is array(0 to 2) of bit_vector(7 downto 0); type TAB2 is array(0 to 3, 1 to 8) of bit; signal A : TAB1; signal B : TAB2; -begin --tableau de tableau A(0) <="01001111"; A(2)(5) <= '1'; -- tableau 2 dimensions B(3,5) <= '0'; --

end exemple; Notation d'agrgat Cette notation permet d'initialiser les tableaux facilement. Exemple : type OPTYPE is (ADD,SUB,MUL,DIV,BRA); type T is array ( 1 to 10) of OPTYPE; signal A : T; -A <= (ADD,SUB,MUL,DIV,BRA); A <= (ADD,SUB,5=>BRA,4=>DIV,3=>MUL); A <= (ADD,2|4=>SUB,others => DIV); -Cet exemple illustre l'affectation par position et la position par dnomination. Notez l'utilisation de la clause 'others' pour complter automatiquement les valeurs du tableau.

IV.

TYPES FICHIERS

Les types fichiers FILE permet l'change de donnes entre l'extrieur et le simulateur VHDL. Il est utilis principalement pour crer des fichiers de test ou TESTBENCH de modles. Le paquetage TEXTIO de la bibliothque STD dfinit un type fichier texte TEXT et des procdures pour accder aux lignes du fichier et aux chanes dans la ligne. Pour l'utiliser il est ncessaire de le dclarer en dbut de fichier : use STD.TEXTIO.ALL; Un fichier peut tre soit en lecture soit en criture mais pas les 2 en mme temps. L'exemple comment suivant illustre 2 processus permettant respectivement de lire le fichier "entrees.dat" et d'crire les rsultats dans "sorties.dat" :

LECTURE: process variable L: line;-- le type LINE est un pointeur file ENTREES: text open READ_MODE is "entrees.dat"; -fichier spcifi variable A: bit_vector(7 downto 0); -- variables lire variable B: natural range 0 to 11; begin readline(ENTREES, L); -- lecture d'une nouvelle ligne dans le fichier read(L, A); -- lecture dans la ligne du 1er symbole => BIT VA <= A; -- utilisation pour la simulation read(L, B); -- lecture dans la ligne du 2me symbole => entier VB <= B; -- utilisation pour la simulation wait for 20 ns; -- attente de 20 ns; end process LECTURE; -ECRITURE: process(S) variable L: line; file SORTIES: text open WRITE_MODE is "sorties.dat"; begin write(L, S); -- criture de S dans la ligne write(L, string'(" t = ")); -- criture de texte dans la ligne write(L, now); -- criture du temps de simulation dans la ligne writeline(SORTIES, L); -- criture de la ligne dans le fichier end process ECRITURE; V. AUTRES TYPES

Types rels Il existe un type rel prdfini REAL. Il permet de reprsenter des nombres entre -1.0E+38 1.0E+38. Il n'est pas synthtisable. Voici quelques exemples d'affectation d'un signal de type rel : A <= 1.0; B <= 5.9E10; C <= -8.5E20; Notez la prsence obligatoire du point.

Types physiques VHDL permet de dfinir des types physiques pour reprsenter une grandeur physique, comme le temps, la tension, etc... Un type physique est la combinaison d'un type entier et d'un systme d'unit.Le type TIME, est le seul type physique prdfini : type time is range $- to $+ -- l'intervalle dpend de la machine units fs; ps = 1000 fs; ns = 1000 ps; us = 1000 ns; Ms = 1000 us; sec = 1000 ms; min = 60 sec; hr = 60 min; end units; Les simulateurs VHDL utilsent la fonction now, de la bibliothque STD , qui retourne le temps physique de type TIME. Type STRING Ce type permet de dfinir les chanes de caractres. Il est dfinit comme un tableau d'lments de type CHARACTER dans la bibliothque STD. type string is array (positive range <>) of character; -"ceci est une chane de caractre" Type enregistrement RECORD Ce type permet de dfinir un objet dont les composantes sont htrognes. type OPTYPE is (MOV, ADD, SUB, JMP, CALL) type INSTRUCTION is record --

OPCODE : OPTYPE; ADR : bit_vector(7 downto 0); OP2 : bit_vector(7 downto 0); -end record;

L'affectation d'un objet de type RECORD peut s'effectuer de diffrentes faons : signal INST1 : INSTRUCTION; signal INST2 : INSTRUCTION: -begin -INST1 <= (MOV, "00011100", X"FF"); INST2.ADR <= X"8A"; -end; Les RECORD sont trs utiles pour les entits dont les ports peuvent tre amens changer en nombre et en type. Les ports sont alors de type RECORD et ne changent pas. En cas de modification il suffit de modifier le contenu du type RECORD plutt que de modifier les ports dans les entits. Type pointeur ACCESS Les pointeurs sont peu utiliss en VHDL car on leur prfre les tableaux indics qui peuvent tre synthtisables, la diffrence des pointeurs. Nous ne les tudieront pas dans ce cours.

ATTRIBUTS Il s'agit de caractristiques de types ou d'objet qu'il est possible d'utiliser dans le modle. Ils sont reprsents de cette faon : <OBJET>'<ATTRIBUT> Il existe des attributs sur les types, sur les objets de type tableau et sur les signaux. Il est possible de crer ces propres attributs. Certains outils de synthse en tirent profit pour passer des arguments de synthse. Attributs sur les types L'exemple suivant illustre les principaux attributs de type : type COULEUR is (BLEU, ROUGE, VERT); -COULEUR'left renvoie BLEU COULEUR'right renvoie VERT COULEUR'pos(BLEU) renvoie 0 COULEUR'val(0) renvoie BLEU COULEUR'succ(BLEU) renvoie ROUGE COULEUR'pred(ROUGE) renvoie BLEU

Attributs sur les objets de type tableau exemples : type MOT is bit_vector(7 downto 0); type TAB is array (4 downto 0) of MOT; signal NOM : MOT; signal TABLEAU : TAB; MOT'LEFT renvoie 7; MOT'LENGTH renvoie 8; TABLEAU'RIGHT renvoie 0;

TABLEAU'RANGE renvoie 4 downto 0; Ces attributs sont trs utiles pour crer des indices ou pour crire des sous-programmes manipulant des tableaux de taille variable. Attributs sur les signaux Ils servent indiquer les caractristiques d'volution temporelle des signaux. Exemples : CLK'EVENT renvoie un BOOLEAN indiquant si le signal CLK a chang. CLK'DELAYED(1 ns) est un signal identique CLK dcal de 1 ns. Attributs dfinis par le concepteur Ils permettent d'associer des caractristiques propres aux objets. Certains outils de synthse ont leurs propres attributs pour rentrer des contraintes de synthse dans le code. L'exemple suivant dfini le brochage de certains signaux. Exemple : ATTRIBUTE NUMERO_BROCHE : POSITIVE; ATTRIBUTE NUMERO_BROCHE of ENTREE1 is 12; ATTRIBUTE NUMERO_BROCHE of ENTREE2 is 17; VI. OPERATEURS

Les oprateurs prdifinis en VHDL sont classiques. Ils ne portent que sur les types prdfinis, BOOLEAN, BIT, INTEGER. Il faut donc dfinir une surcharge d'oprateur lorsqu'il s'agit d'effectuer des oprations sur un nouveau type. Il faut noter l'absence du xnor et la diffrence entre REM et MOD pour exprimer le reste de la division. Type d'oprations Logiques Relationnels oprateurs and, or, nand, nor, xor, not =, /=, < , <=, > , <= notes

Arithmtique

*, / , mod, rem

Divers

**, abs, &

(A rem B) a le signe de A (A mod B) a le signe de B ** : exponentiation abs : valeur absolue & : concatnation

CHAP III VHDL STRUCTUREL Objectifs La description structurelle d'un circuit complexe en vhdl prsente de nombreux avantages: Unearchitecture hirarchique comprhensible : il est plus simple de sparer un circuit en un ensemble de blocs plus petits, ayant des fonctions bien identifies. Ces blocs pourront alors tre dcrits sous forme comportementale, ou bien leur tour tre spars en blocs encore plus simples. Une synthse logique efficace : la synthse est un processus lent (en terme de temps de calcul). Plus un bloc est gros et complexe, plus sa synthse prendra du temps. Il vaut donc mieux travailler sur des blocs plus petits, plus simples synthtiser, et rassembler le tout la fin. L'objectif de ce chapitre est de voir prcisment comment coder une reprsentation structurelle d'un circuit, autrement dit : comment dclarer des blocs (qu'on appellera composant) comment utiliser un composant (qui devient une "instance") et dclarer la faon dont il est connect. comment choisir l'architecture d'un composant quand il y en a plusieurs (configurations) I. ELMENTS DE BASE

VHDL permet l'assemblage de "composants" ce qui constitue une description structurelle. Ce composant peut tre appel plusieurs fois dans un mme circuit. Pour diffrencier ces mmes composants, il est ncessaire de leur donner un nom d'"instance". L'appel d'un composant se dit aussi "instanciation" De faon instancier un composant il est ncessaire de connatre : Le prototype du composant (ses ports d'entre et de sortie). La directive component peut tre utilise cette fin. A quelle entit et architecture est li chaque instance de composant. Ce lien peut tre connu grce l'unit de configuration.

Il est important de noter : La dclaration du composant (directive component ) est redondante textuellement avec celle de l'entit associe mais permet : Une compilation indpendante entre l'entit associe au composant et le circuit utilisant le composant. La conception descendante. Le composant peut tre dclar avant l'entit associe. La configuration est une unit de compilation optionnelle, trs utile pour les gros circuits. Par exemple pour acclrer la simulation , un mme composant peut tre associ un couple entit/architecture dtaill et synthtisable ou un autre couple plus abstrait et plus rapide simuler. Pour ne pas utiliser de configuration, une rgle frquente est d'utiliser le mme nom pour le composant et l'entit associe, c'est le cas pour ModelSim et les outils de synthse FPGA. La description structurelle est ncessaire pour simuler un circuit dont les vecteurs stimulis sont eux mmes issus d'un modle VHDL. Le modle de plus haut niveau fait donc appel au circuit tester (Device Under Test) et d'un gnrateur de stimulis. Ces deux objets sont instancis dans un mme circuit, gnralement appel "testbench" (mais ce n'est pas une obligation) qui est autonome : il n'aura pas d'entres ni de sorties. Exemple : le circuit top, servant simuler le circuit "module a" doit tre autonome : son entit n'a pas d'entre ni de sortie.

Cas particulier de la simulation : circuit "top" sans entre ni sortie

II.

DCLARATION ET INSTANCIATION DES COMPOSANTS

Dclaration Le mot cl component sert dclarer le prototype d'interconnexion. La syntaxe est presque identique celle de l'entit : component AND_2 port ( a : in bit; b : in bit; s : out bit); end component; Pour crer rapidement un composant, une opration copier/coller de l'entit en enlevant le litral "IS" suffit.

Instanciation : L'instanciation d'un composant se fait dans le corps de l'architecture de cette faon : <NOM_INSTANCE>:<NOM_COMPOSANT> port map(LISTE DES CONNEXIONS); Exemple: entity AND_3 is port( e1 : in bit; e2 : in bit; e3 : in bit; s : out bit ); end entity; Dans cet exemple , 2 instances de composant "and2" sont appeles pour crer une porte ET 3 entres. L'association des ports du

-architecture arc of AND_3 is -signal z : bit; component and2 port ( a : bit; b : bit; s : bit); end component; -begin inst1 : and2 port map (a=>e1, b=>e2 , s=>z); inst2 : and2 port map (z, e3, s); end arc

composants aux signaux de l'instance se fait l'aide de la clause port map. La syntaxe des associations est soit par nom o chaque broche du composant est associe un signal : cas de inst_1 positionnelle o l'ordre des signaux correspond l'ordre des broches : cas de inst_2

GENERICITE Dclaration Un composant peut tre gnrique en dfinissant les paramtres qui seront vus comme des constantes chaque instance de composant. Il est ainsi possible de n'avoir qu'un seul composant pour diffrentes instances ayant des paramtres diffrents. Dans la dclaration du composant, la clause generic sert passer les paramtres au composant. Dans l'exemple suivant, l'entier positif N indique le nombre de bits de l'additionneur.

component ADD generic ( N : positive range 0 to 16 ); port

Le paramtre N permet de dimensionner la taille de l'additionneur, il est dclar avec la clause generic

( A: in std_logic_vector(N-1 downto 0); B: in std_logic_vector(N-1 downto 0); S: out std_logic_vector(N1 downto 0) ); end component; De mme l'entit associe au composant doit comporter la clause generic pour dclarer le(s) paramtre(s) entity ADD is generic ( N : positive range 0 to 16 ); port ( A: in std_logic_vector(N-1 downto 0); B: in std_logic_vector(N-1 downto 0); S: out std_logic_vector(N-1 downto 0) ); end entity ADD; Instanciation : L'instanciation d'un composant se fait dans le corps de l'architecture de cette faon :

architecture arc of mult is component ADD generic ( N : positive range 0 to 16); port ( A: in std_logic_vector(N-1 downto 0); B: in std_logic_vector(N-1 downto 0); S: out std_logic_vector(N-1 downto 0)); end component; signal OP1,OP2,S std_logic_vector(N-1 downto 0); ... -begin inst_ADD : ADD generic map(N=>12); port map(A=>OP1, B=>OP2,S=>S); ... end arc;

La clause generic map dans l'instanciation du composant ADD permet de fixer la valeur du paramtre.

Instanciation de multiples composants Les paramtres ne sont parfois pas suffisants pour crire un code gnrique : on peut aussi vouloir instancier un nombre variable de composants (en fonction d'un paramtre, par exemple). Ceci est fait au moyen des mots-clef for generate..et if generate. Exemple 1 : on veut dcrire un multiplieur gnrique, tel que : L'architecture Carry Lookhead (CLA) est utilise s'il doit manipuler des nombres de largeur infrieure 8 bits, L'architecture en arbre de Wallace est utilise sinon.

L'exemple ci-dessous fait appel la clause IF GENERATE en testant le paramtre width. Notez que : le ELSE n'existe pas (oubli de VHDL ?) et qu'il faut refaire un 2me IF. l'instruction IF GENERATE a besoin obligatoirement d'une tiquette

use work.pack.all; -- paquetage o sont dclars les composants CLA-multplier -- et WAL_multiplier entity multiplier is generic( width : positive :=8;); port( a : in signed(width-1 downto 0); b : in signed(width-1 downto 0); product : out (2*width-1 downto 0)); end entity; -architecture arc of multiplier is -begin -CLA_gen : if width < 8 generate inst_cla : CLA_multiplier

L'exemple ci-contre fait appel la clause IF GENERATE en testant le paramtre width. Notez que : le ELSE n'existe pas (oubli de VHDL ?) et qu'il faut refaire un 2me IF. l'instruction IF GENERATE a besoin obligatoirement d'une tiquette

generic map (width) port map(a, b, product); -end generate CLA_gen; -WAL_gen : if width >= 8 generate inst_wal : WAL_multiplier generic map (width) port map(a, b, product); end generate WAL_gen; -end arc; --

Exemple 2 : l'exemple classique de l'additionneur n bits... On utilise ici une boucleFOR GENERATE pour instancier automatiquement les diffrentes primitives ainsi que les noeuds les connectant entre elles. Notez qu'il n'est pas ncessaire de dclarer la variable de boucle mais que l'instruction FOR GENERATE ncessite une tiquette.

entity Nbit_adder is generic( SIZE = 4); port ( a,b : in unsigned(SIZE-1 downto 0); ci : in std_logic; sum : out unsigned(SIZE-1 downto 0); co : out std_logic);

end entity; -component FA port(A,B,Cin : in std_logic; S, Cout : out std_logic); end component; -architecture arc of Nbit_adder is -signal c :unsigned(SIZE downto 0);; -begin -C(0) <= Cin; co <= C(SIZE); -G: for I in 0 to N-1 generate inst: FA port map(A(I), B(I), C(I), sum(I), C(I+1)); end generate G; -end arc;

LA CONFIGURATION VHDL dispose d'un mcanisme appel "configuration" permettant d'associer une instance de composant un couple entit/architecture. La configuration est une unit de compilation part, tout comme l'entit et l'architecture. Pour la plupart des outils , la configuration est optionnelle. Le lien composant/entit s'effectue gnralement en imposant un nom de l'entit identique celui du composant, et le lien entit/architecture s'effectue soit en considrant la dernire architecture compile, soit l'outil impose une architecture unique. La configuration est donc l'unit de compilation de plus haut niveau car elle permet l'laboration de l'ensemble (l'dition de liens) pour pouvoir simuler. Son intrt apparat pour grer des gros circuits o plusieurs architectures sont possibles pour une mme entit. C'est la cas quend il existe des modles d'abstraction diffrentes, ce qui est trs utilis pour les mthodes de conception "top down". Par exemple une quipe peut avoir des modles abstraits de tous les blocs de faon acclrer les

temps de simulation et travailler sur plusieurs architectures du bloc concevoir. Il existe plusieurs faons de configurer un projet : configuration hirarchique configuration plat configuration immdiate instanciation de configuration Configuration hirarchique Pour chaque entit, une configuration est cre. Dans chaque configuration, la clause use configuration est utilise pour les instances de composant de niveau infrieur. configuration CF_AND2 of AND_2 is for arc end for; end configuration CF_AND2; La configuration est vide car l'entit AND_2 n'a pas d'instances de composant. La configuration existe toutefois car tous les composants utiliss doivent avoir une configuration dans cette mthode.

configuration CF_AND3 of AND_3 is for arc for all : AND2 use configuration work.CF_AND2; end for; end for; end configuration CF_AND3;

Le composant AND2 est instanci dans AND_3. A chaque instance la configuration CF_AND2 est utilise.

Pour les gros circuits, il est fortement recommand d'utiliser ce type de configuration car c'est la plus simple maintenir. Configuration plat

Elle peut tre unique et indique les liens entit/architecture explicitement avec la clause use entity(architecture). Elle est utilise pour des circuits simples car il n'est pas ncessaire d'avoir des fichiers de configuration au niveau hirarchique infrieur. configuration CF_AND3_APLAT of AND_3 is for arc for i1 : AND2 use entity work.AND2(a1); end for; for i2 : AND2 use entity work.AND2(a2); end for; end for; end configuration CF_AND3_APLAT; Configuration immdiate Les associations entit/architecture des composants peuvent tre dclars directement dans l'architecture avant le corps de l'architecture. Elle est rserve aux petits circuits pour des essais de diffrentes architectures. architecture arc of TOP is for all : AND2 use configuration work.CF_AND2; end for; for inst_block1 : compo use entity work.ctr(arc); end for; begin I1 : AND2 port map (...); I2 : AND2 port map (...); inst_block1 : compo port map (...); end arc; Instanciation de configuration Dans ce cas , il n'est pas ncessaire de dclarer de composant et

l'instanciation se fait en spcifiant le couple entit/architecture. La conception dans ce cas est ncessairement "bottom-up" et non "topdown" car il faut obligatoirement avoir concu les entits appeles au niveau le plus haut. architecture arc of TOP is begin I1 : entity work.and2(arc1) port map (...); I2 : entity work.ctrl(arch) port map (...); end arc; Cette mthode ne ncessite pas de configuration. Elle est la plus simple mais peut tre aussi moins adapte aux gros circuits du fait de la conception "bottom up" uniquement.

CHAP IV VHDL COMPORTEMENTAL Objectifs Passons maintenant aux descriptions comportementales. Dans ce type de descriptions, il y a plusieurs niveaux. Nous allons ici tudier les principales descriptions : celle au niveau des quations boolennes, appele aussi parfois flot de donnes. Ce type de reprsentation modlise les circuits combinatoires, non pas en instanciant des portes, mais sous forme d'quations boolennes. Pour les circuits squentiels, il faudra faire appel un niveau plus abstrait, appel RTL.

Les objectifs de ce chapitre sont de comprendre : Les diffrences entre instructions concurrentes et squentielles. Les processus et les diffrences entre variables et signal. Les structures de contrle utilises dans les processus. Les affectations concurrentes des signaux, les raccourcis d'criture. Les diffrents types de dlais dans les affectations. Comment vrifier une proprit par les assertions. Les diffrents types de sous-programmes. INSTRUCTIONS CONCURRENTES ET SEQUENTIELLES Comme tout langage de description de matriel, le VHDL dcrit des structures par assemblage d'instructions concurrentes dont l'ordre d'criture n'a aucune importance, contrairement aux instructions squentielles qui sont excutes les unes aprs les autres, comme c'est la cas du C. VHDL offre cependant la possibilit d'utiliser des instructions squentielles, plus naturelles pour l'homme, par le biais de processus process. Les processus peuvent avoir leurs propres variables locales variable. Les objets manipuls par les instructions concurrentes sont les signaux signal qui disposent chacun d'un chancier de faon effectuer une simulation d'instructions concurrentes sur une machine squentielle (l'ordinateur). Il existe 3 principales instructions concurrentes : Les processus, qui offrent la possibilit d'utiliser des instructions squentielles. Les instanciations de composants (tudies aux chapitre prcdent propos du VHDL structurel) les affectations concurrentes de signaux, qui peuvent tre conditionnelles Il existe galement les assertions et les procdures concurrentes qui ont la mme syntaxe que les assertions et procdures squentielles (tudies en fin de ce chapitre) mais utilises en dehors des processus.

PROCESSUS ET SYNCHRONISATION Les diffrentes tches d'un programme vhdl s'excutent en parallle les unes des autres. Ces tches sont appeles processus. Toutes les instructions concurrentes sont en fait des processus mais la dclaration explicite de processus par le mot cl process permet de construire sa propre instruction par le biais d'instruction squentielles internes au processus. Un processus peut avoir des variables locales. Le fonctionnement du processus est rgi par les rgles suivantes : Un processus est une boucle infinie , lorsqu'il arrive la fin du code, il reprend automatiquement au dbut Un processus doit tre sensible des points d'arrt de faon le synchroniser. La synchronisation est donc indique par un point d'arrt qui est vnement particulier. Il existe 2 types de points d'arrts : Le processus est associ une "liste de sensibilit" qui contient une liste de signaux qui rveillent le processus lors d'un changement d'un des signaux. Sa syntaxe est process(liste de signaux) Le processus a des instructions d'arrt wait dans sa description interne. Le wait est sensible soit un signal soit un temps physique Les variables sont internes au processus et sont affectes immdiatement, contrairement aux signaux qui eux ne sont pas affects directement mais par le biais de leur chancier qui est mis jour en fin de processus avec la nouvelle valeur et le temps d'affectation qui correspond un delta-cycle aprs le signal ayant rveill le processus. Synchronisation des processus par WAIT L'instruction WAIT permet de mettre des points d'arrt dans le corps du processus. La syntaxe de l'instruction est la suivante : wait [on S1,S2,...] [until CONDITION] [for DUREE] o S1 et S2 sont des signaux, CONDITION est une expression gnrant un boolen, et DUREE est le temps physique d'attente. L'instruction WAIT n'est pas synthtisable avec la condition de dure.

Elle est trs utile pour les testbench pour gnrer prcisment des formes de vecteurs d'entre. L'exemple suivant gnre une trame de 10 impulsions espaces de 100 microsecondes. trame : process -- le processus peut avoir une tiquette, ici "trame" -- il n'y a pas de liste de sensibilit donc il faut des "wait" pulse <= '0'; -- pulse est 0 en dbut de trame for i in 0 to 9 loop -- on gnre 10 impulsions larges de 2 priodes d'horloge wait until clk'event and clk='1'; pulse <= '1'; wait until clk'event and clk='1' pulse <= '0'; end loop; wait for 100 us; -- aprs 100 us on reprend le process donc pulse va repasser 0 end process; Synchronisation des processus par liste de sensibilit La liste des signaux rveillant le processus est indique dans la liste de sensibilit suivant cette syntaxe : process(liste de sensibilit). Cette mthode est tout fait quivalente celle consistant utiliser un wait on liste la fin du corps du processus. L' exemple suivant permet de coder la logique combinatoire. process(x,y) begin if x='1' then z<=y; else z<='0'; end if; end process; -De quelle fonction s'agit-il ? Notez la prsence dans la liste de sensibilit des entres uniquement. Attention un processus correspondra de la logique combinatoire seulement si :

la liste de sensibilit contient TOUTES les entres, sinon la fonctionnalit n'est pas respecte car l'entre omise ne rveille pas le processus Il faut traiter TOUS les cas dans le chemin de contrle, sinon il y a implicitement mmorisation de la sortie pour les cas non traits Si ces rgles ne sont pas respectes, le processus est squentiel.

Pour fiabiliser le processus squentiel , nous avons vu qu'il tait fortement recommand de fonctionner en mode synchrone, c'est dire avec l'utiliation d'un horloge qui chantillonne le calcul. Autrement dit un processus squentiel synchrone a une liste de sensibilit qui se rduit simplement l'horloge. Les signaux cods dans ce processus seront donc des sorties de bascule D. S'il est impratif d'initialiser les bascules (cas des machines tats), le reset asynchrone peut tre employ. Dans ce cas il faut le rajouter dans la liste de sensibilit car il est prioritaire sur l'horloge quand il est actif. La syntaxe gnrique d'un bloc de logique squentiel est donc la suivante: process(clk, n_reset) -begin if n_reset='0' then sortie <= (others=>'0'); -- tous les bits de sortie sont initialiss 0 par le reset elsif clk'event and clk='1' then liste d'instructions codant "sortie" end if; end process; --

SIGNAUX VS VARIABLES Les signaux sont quivalents des variables globales assurant les communications entre processus. Ils sont quivalents des quipotentielles si le code est synthtisable. Les signaux ne sont pas mis jour tout de suite mais la fin du processus avec un delta-cycle

de retard par rapport au signal ayant dclench le processus. Les signaux sont affects avec l'instruction <= qui se dit aussi "reoit" plutt que "gal" car le signal va recevoir cette valeur en fin de processus avec un delta-cycle de retard. Les variables sont locales chaque processus et sont mises jour immdiatement. Elles sont trs utiles pour effectuer un codage squentiel classique comme avec le langage C. Les variables sont dclares juste avant le corps du processus et sont affectes avec l'instruction d'affectation immdiate := de faon bien ne pas confondre avec l'instruction <= "reoit" pour les signaux. Les variables gardent leur valeur quand le processus est termin. Dans l'exemple suivant, a,b,c sont des signaux et x une variable. Enfin de processus, a et b vont prendre la valeur a+1 aprs un delta-cycle alors que c prendre la valeur a aprs un delta-cycle. process (a) variable x : std_logic; begin x := a+1; a <= a+1; b <= x; c <= a; end if; end process; -STRUCTURES DE CONTRLE Dans les processus, il est possible d'utiliser des structures de contrle similaires celles du C : les instructions de test (if, case) les boucles (loop, for loop, while loop) Instruction IF L' instructions IF reposent sur le test d'une condition qui gnre un boolen. Si celui ci est "TRUE" l'instruction qui suit est excute Syntaxe du IF:

if condition1 then instruction; [elsif condition2 then instruction;] ... [else instruction;] end if; Pour coder un processus combinatoire, l'utilisation du ELSE est obligatoire de faon traiter toutes les combinaisons (sinon il y a mmorisation donc c'est da la logqiue squentielle) Instruction CASE L' instructions CASE reposent sur le test d'un signal ou d'une variable. En fonction de la valeur, une instruction spcifique est excute Syntaxe du CASE : case A is when -7 => B := 10; C :='0' when -3 => B :=15; C :='0'; when others => B :=2; C :='1'; end case; Pour coder un processus combinatoire, l'utilisation du when others est obligatoire de faon traiter toutes les combinaisons (sinon il y a mmorisation donc c'est da la logqiue squentielle) Instruction de boucle L1: for i in 0 to 10 loop ... L2: loop ... L3 : while non _stop_L3 loop ... exit L2 when stop_L2; next L3 when suite_L3; if stop_L1 then exit L1;

end if; end loop L3; end loop L2; end loop L1; Il faut noter : Les indices de boucles (ici i pour L1) ne sont pas dclarer Les tiquettes de boucles (L1,L2,L3) sont optionnelles L'excution peut tre altre avec les clauses next et exit Exemple : la boucle loop de cet exemple permet de compter le nombre de bits 1 d'un signal. library ieee; use ieee.std_logic_1164.all; use ieee.numeric_std.all; -entity nb_un is port ( a : in unsigned(7 downto 0); s : out unsigned(3 downto 0) ); end entity; -architecture rtl of nb_un is begin process(a) variable x : unsigned (3 downto 0); begin x:= (others => '0'); for i in 0 to 7 loop x := x + ('0' & a(i)); end loop; s <= x; end process; end rtl; Le paquetage IEEE.numeric.std permet d'avoir accs aux fonction arithmtiques sur les types vecteurs non-signs unsigned ou signs signed. Remarquez que l'addition se fait en concatnant chaque bit avec '0' car l'oprateur + du paquetage n'opre pas sur un bit simple.

AFFECTATIONS CONCURRENTES DE SIGNAUX Ces affectations sont des instructions concurrentes au mme titre que les processus et les instanciations de composants. Le codage comportemental d'une architecture repose sur l'utilisation de ces 3 types d'instructions concurrentes qui peuvent apparatre dans n'importe quel ordre. Une instruction concurrente est quivalente un processus et correspond un raccourci d'criture pour viter le verbosit du processus. Exemple : Architecture avec processus architecture arc of adder is begin process(A,B,Cin) begin S <= A xor B xor Cin; Architecture avec affectation concurrente architecture arc of adder is begin S <= A xor B xor Cin; end arc;

Affectation concurrente conditionnelle Il existe galement des instruction concurrentes conditionnelles permettant d'effectuer des raccourcis d'criture pour remplacer des processus simples base de IF et CASE Exemples : Architecture avec processus architecture arc of adder is begin process(A,B,Cin) begin if A = '0' then S <= B xor Cin; elsif B = '0' then S <= not(Cin); else Architecture avec affectation concurrente architecture arc of adder is begin S <= B xor Cin when A = '0' else not Cin when B = '0' else Cin;

S <= Cin; end if; end process; end arc; architecture arc of MUX is begin process(SEL) begin case SEL is when 0 => sortie <= A; when 1 => sortie <= B; when 2 => sortie <= C; when others => sortie <= D; end case; end process; end arc;

architecture arc of MUX is begin with SEL select sortie <= A when 0, B when 1, C when 2, D when others; end arc;

Pour les fonctions combinatoires, il est souvent plus prudent d'utiliser les affectations concurrentes plutt que les processus o il est possible d'omettre un signal d'entre dans la liste de sensibilit. Il faut toutefois avoir un chemin de contrle exhaustif et toujours avoir la clause else ou when others pour ne rien omettre.

AFFECTATIONS ET DLAIS VHDL permet de spcifier des dlais dans les affectations. Il existe deux types d'affectations avec dlai : affectation avec dlai inertiel : x <= 3 after 2 ns; ou plus explicitement x <= inertial 3 after 2 ns; affectation avec dlai de transport : x = transport 3 after 2 ns;

Le type inertiel permet de "filtrer" les variations de X trop courtes par rapport au dlai de la transaction. Par exemple si x est 1 pendant 1ns, l'affectation x <= 3 after 2 ns; ne changera pas la forme d'onde de x qui restera 0. Contrairement au mode inertiel , le type transport n'opre pas de "rjection des parasites". Il respecte les temps de propagation mais est certainement moins raliste que le mode inertiel. ASSERTIONS Les assertions permettent de vrifier une proprit et gnrer un message d'erreur si cette proprit n'est pas vrifie. La syntaxe est la suivante : assert CONDITION [report MESSAGE] [severity NIVEAU]; o CONDITION = condition gnrant un boolen. Cette condition doit tre vraie pour que rien ne se passe MESSAGE = chane de caractres renseignant le fait que la condition n'a pas t remplie NIVEAU = niveau d'erreur. Ilen existe 4 prdifinis : NOTE,WARNING, ERROR, FAILURE Les assertions peuvent font aprtie du domaine squentiel (dans un processus) ou du domaine concurrent exemple : assert NOW < 10 ms -- NOW est une fonction renvoyant le temps physique report "Fin de simulation" severity failure

SOUS-PROGRAMMES IL existe 2 types de sous-programmes: Les fonctions Les procdures

Les sous-programmes font partie du domaine squentiel et ont la mme utilit que pour les autres langages de programmation : regrouper les instructions qu'on utilise souvent. Les procdures font peuvent tre appeles aussi bien dans le domaine squentiel que concurrent La diffrence entre fonctions et procdures sont les suivantes: paramtres d'appels valeur retourne fonction non modifiable (entres) oui function F(A: unsigned(3 downto 0)) return std_logic is ... begin ... end function F; procdure les sorties sont modifiables non procedure P(A: in unsigned(3 downto 0)) S : out std_logic ) is ... begin ... end procedure P;

syntaxe

Par rapport la fonction, La procdure permet d'avoir plusieurs sorties, mais condition de dclarer les entres et les sorties comme dans une entit ou composant. Exemples : Fonction de calcul de minimum et maximum en procdure. procedure MinMax( a,b : in unigned (7 downto 0); min : out unsigned(7 downto 0); max : out unsigned(7 downto 0)) is begin if (a < b) then min <= a; max <= b; else min <= b; max <= a; end if; end procedure MinMax;

MinMax(x, y, z, t); Il faut 2 fonctions min et max pour avoir lquivalent en fonction. Voici l'exemple de min :