02 Ccts Comb Avancesv 21

Cours #2
Techniques avancées
de conception de circuits combinatoires
Pierre Langlois
http://creativecommons.org/licenses/by-nc-sa/2.5/ca/
INF3500 : Conception et implémentation de systèmes numériques

(notes, section 4.2)
Flot de conception de circuits numériques
vérification de la puce
annotation
vérification par simulation
des délais
code HDL
génération du
schéma synthèse implémentation fichier de puce
génération configuration
de code
diagramme HDL
d’états
contraintes
(temps et
espace)
Extraction statique des métriques d’implémentation

(ressources, délai, puissance)
INF3500 : Conception et implémentation de systèmes numériques 2

Plan pour aujourd’hui
• Exemple de circuit combinatoire (problème du vote)
– Code VHDL: différentes options pour la description
– Quelques techniques de vérification par simulation
• Vérification de circuits combinatoires
– Banc d’essai de base (sections 7.1 et 7.2)
– Générer des vecteurs de test (sections 7.4 et 7.5)
– Vérification automatique des réponses (section 7.6)
• Conception de circuits arithmétiques (section 5.5.1) et ,
t d
– Exemple: convertisseur RGB à CMYK ic_s ributs
m er , att
– Trucs et astuces
H DL e.nu ures
de V s iee océd
c és kage et pr
v an pac ns
a
p ts pes, nctio
nce x ty l, fo
o u a
+ C uvea th_re e …
r
No e.ma nco
e
iee lus
p
et
Exemple de design de circuit combinatoire
• Un comité composé de quatre personnes a besoin d’un mécanisme de vote
secret pour les amendements sur la constitution du comité. Un amendement est
approuvé si au moins 3 personnes votent pour.
• Concevoir un circuit logique qui accepte 4 entrées représentant les votes. La
sortie du circuit doit indiquer si l’amendement est accepté.

Table de vérité, équation et circuit logique
amendement
# vote1 (A) vote2 (B) vote3 (C) vote4 (D)
approuvé (F)
0 0 0 0 0 0
1 0 0 0 1 0
2 0 0 1 0 0
3 0 0 1 1 0
4 0 1 0 0 0
5 0 1 0 1 0
6 0 1 1 0 0
7 0 1 1 1 1
8 1 0 0 0 0
9 1 0 0 1 0
10 1 0 1 0 0
11 1 0 1 1 1
12 1 1 0 0 0
13 1 1 0 1 1
14 1 1 1 0 1
15 1 1 1 1 1
F  A' BCD  AB' CD  ABC ' D  ABCD ' ABCD

 A' BCD  ABCD  AB' CD  ABCD  ABC ' D  ABCD  ABCD ' ABCD
 BCD ( A' A)  ACD ( B' B)  ABD (C 'C )  ABC ( D' D)
 BCD (1)  ACD (1)  ABD (1)  ABC (1)
 BCD  ACD  ABD  ABC
Équivalence entre les trois représentations
Code VHDL, trois approches par flot de données
library IEEE; -- équation non réduite

use IEEE.STD_LOGIC_1164.all; architecture flotdonnees2 of vote is
signal A, B, C, D : std_logic;
entity vote is begin
port ( (A, B, C, D) <= lesvotes; -- pour simplifier l'écriture
lesvotes: in std_logic_vector(3 downto 0); approbation <=
approbation : out std_logic (not(A) and B and C and D)
); or (A and not(B) and C and D)
end vote; or (A and B and not(C) and D)
or (A and B and C and not(D))
-- table de vérité réduite or (A and B and C and D);
architecture flotdonnees1 of vote is end flotdonnees2;
begin
with lesvotes select
approbation <=
'1' when "0111",
'1' when "1011",
'1' when "1101", -- équation réduite
'1' when "1110", architecture flotdonnees3 of vote is
'1' when "1111", signal A, B, C, D : std_logic;
'0' when others; begin
end flotdonnees1; (A, B, C, D) <= lesvotes; -- pour simplifier l'écriture
approbation <=
(B and C and D)
or (A and C and D)
or (A and B and D)
or (A and B and C);
end flotdonnees3;

Code VHDL, approche comportementale
-- compter les votes, sans restriction sur le type de -- compter les votes, avec restriction sur le type de
compte compte
architecture comportementale1 of vote is architecture comportementale2 of vote is
begin begin
process(lesvotes) process(lesvotes)
variable compte : integer; variable compte : natural range 0 to lesvotes'length;
begin begin
compte := 0; compte := 0;
for k in 0 to lesvotes'length - 1 loop for k in lesvotes'range loop
if lesvotes(k) = '1' then if lesvotes(k) = '1' then
compte := compte + 1; compte := compte + 1;
end if; end if;
end loop; end loop;
if compte >= 3 then if compte >= 3 then
approbation <= '1'; approbation <= '1';
else else
approbation <= '0'; approbation <= '0';
end if; end if;
end process; end process;
end comportementale1; end comportementale2;

Parenthèse: Types communément utilisés en VHDL

type source
catégorie valeurs
ou sous-type de la définition
boolean type prédéfini FALSE et TRUE
bit type prédéfini ‘0’ et ‘1’
256 caractères de la norme ISO 8859-
1, avec des abréviations reconnues et
character type prédéfini certaines qui sont propres à VHDL
Les 128 premiers sont les caractères
ASCII.
integer type prédéfini plage minimale de –231 + 1 à 231 – 1
natural sous-type prédéfini 0 à 231 – 1
positive sous-type prédéfini 1 à 231 – 1
real typiquement
type prédéfini
scalaires –1.7014111E±308 à 1.7014111E±308
‘U’ : valeur inconnue, pas initialisée
‘X’ : valeur inconnue forcée
‘0’ : 0 forcé
‘1’ : 1 forcé
Package
std_logic ‘Z’ : haute impédance (pas connecté)
std_logic_1164
‘W’ : inconnu faible
‘L’ : 0 faible
‘H’ : 1 fabile
‘-‘ : peu importe (don’t care)
bit_vector type prédéfini tableau de bit
string type prédéfini tableau de character
Package
std_logic_vector tableau de std_logic
std_logic_1164
composés Package tableau de std_logic, interprété
unsigned
numeric_std comme un nombre binaire non signé
Package tableau de std_logic, interprété
signed comme un nombre binaire signé
numeric_std en complément à deux 8
Parenthèse: Opérateurs en VHDL

type de type de type de
l’opérande de l’opérande de l’expression
catégorie opérateurs gauche droite
and, or, nand, nor, xor,

logique bit, boolean
xnor, not
relation =, /=, <, <=, >, >= scalaire ou tableau boolean
sll (déc. logique gauche),

srl (déc. logique droite),
sla (déc. arithmétique gauche), tableau de bit comme
décalage integer l’opérande de
sra (déc. arithmétique droit), ou boolean
gauche
rol (rotation gauche),
ror (rotation droite)
+, -, *, /,
abs (valeur absolue), type
mod (modulo), type numérique type
arithmétique rem (reste) numérique numérique
** (exponentiation) integer
concaténation & tableau ou type énuméré tableau

(notes, section 2.5.12)
Parenthèse: attributs en VHDL

• En VHDL, les attributs permettent d’obtenir de l’information à propos de types,
signaux, variables, etc.
• VHDL inclut des attributs prédéfinis, et on peut en définir de nouveaux.
• Quelques attributs prédéfinis utiles:
Utilisation de l’attribut Résultat
A’left, A’right Indice le plus à gauche, le plus à droite du vecteur A
A’low, A’high Indice le plus bas, le plus haut du vecteur A
A’range La gamme des indices du vecteur A
A’length Le nombre d’éléments du vecteur A
T’left, T’right, T’low, T’high La valeur la plus à gauche, à droite, la plus basse, la plus
élevée du type T
T’Image(x) La représentation textuelle de la valeur x dans le type T.
T’Value(s) La valeur dans le type T de la chaîne de caractères s.
S’event Vrai si un événement s’est produit sur le signal S.

Vérification sans banc d’essai,
à l’aide d’outils d’un simulateur
• Démonstration avec Active-HDL.
• La vérification sans banc d’essai est satisfaisante pour les petits circuits.
• Différents types de stimulateurs pour les ports d’entrée.
– horloge
– formule
– valeur
– compteur
– prédéfinie
– (pseudo) aléatoire

Parenthèse:
mais où trouver de l’information et des réponses?
• Démonstration de l’utilisation de l’aide de Active-HDL.
• Newsgroup comp.lang.vhdl, comp.arch.fpga.
• Google …

• Retour sur l’exemple de circuit combinatoire (problème du vote)
t d
m er , att
H DL e.nu ures
de V s iee océd
c és kage et pr
v an pac ns
a
p ts pes, nctio
nce x ty l, fo
o u a
r
No e.ma nco
e
iee lus
p
et
Retour sur le flot de conception de circuits numériques
vérification de la puce
annotation
vérification par simulation
des délais
code HDL
génération du
schéma synthèse implémentation fichier de puce
génération configuration
de code
diagramme HDL
d’états
contraintes
(temps et
espace)
Extraction statique des métriques d’implémentation

(ressources, délai, puissance)

Vérification: concepts fondamentaux

• La vérification est un processus par lequel on vérifie qu’un design rencontre bien
ses spécifications.
• La vérification complète d’un circuit est normalement un problème très difficile.
• Dans l’industrie de la conception numérique, on considère en général que le
processus de vérification nécessite autant d’efforts que le processus de
conception lui-même.
• La vérification d’un circuit est un art qui repose sur la maîtrise de trois principes:
– la compréhension de la spécification;
– le contrôle des entrées et de signaux internes du circuit à vérifier; et,
– l’observation des sorties, des signaux internes et de l’état du circuit à vérifier.

Vérification par banc d’essai

• Un banc d’essai permet d’appliquer des vecteurs de test à un circuit et
d’observer sa sortie dans le but de vérifier qu’il rencontre ses spécifications.
• Un banc d’essai doit effectuer les tâches suivantes :
– instancier le circuit à vérifier;
– générer des vecteurs de test et les appliquer aux ports d’entrée du circuit;
– [utile]: générer automatiquement des réponses attendues aux vecteurs de test;
– [utile]: comparer les réponses du circuit aux réponses attendues, et indiquer toute
différence entre les deux par une condition d’erreur.
banc d’essai
réponses attendues
observation
génération de
des réponses
vecteurs de succès/échec
test et de
comparaison
réponses
aux réponses
attendues
attendues
fichier de vecteurs de test circuit à vérifier réponses fichier des
stimuli et
résultats
réponses

Exemple: circuit combinatoire à vérifier
Cin
S
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
T3
X T1
entity add3bits is
port ( Y
Cin : in std_logic;
X : in std_logic; T2 Cout
Y : in std_logic;
Cout : out std_logic;
S : out std_logic
);
end add3bits;
architecture flotDeDonnees of add3bits is
signal T1 : std_logic;
Spécification:
begin
S <= T1 xor Cin;

La sortie [Cout S] doit représenter sur deux bits
Cout <= T3 or T2;
T1 <= X xor Y;
la somme des trois bits d’entrée Cin + X + Y.
T2 <= X and Y;
T3 <= Cin and T1;
end flotDeDonnees;

Banc d’essai de base en VHDL
library ieee;
pas de ports d’entrée use ieee.std_logic_1164.all;
ni de sortie entity add3bitsTB is
end add3bitsTB;
architecture arch1 of add3bitsTB is
component add3bits -- déclaration du module à vérifier

port (Cin, X, Y : in std_logic; Cout, S : out std_logic);
end component;
-- signaux pour les vecteurs de tests

signal Cin : std_logic;
signal X : std_logic;
signal Y : std_logic; Il faut vérifier manuellement si la
-- signaux pour les réponses spécification est rencontrée.
signaux internes du signal Cout : std_logic;
banc d’essai signal S : std_logic;
begin
-- instanciation du module à vérifier le module à vérifier est ici
UUT : add3bits port map (Cin, X, Y, Cout, S);
-- on applique des vecteurs de test

stimulation à l’aide de Cin <= '0' after 0 ns, '1' after 40 ns;
trois énoncés Y <= '0' after 0 ns, '1' after 20 ns, '0' after 40 ns, '1' after 60 ns;
X <= '0' after 0 ns, '1' after 10 ns, '0' after 20 ns, '1' after 30 ns,
concurrents utilisant '0' after 40 ns, '1' after 50 ns, '0' after 60 ns, '1' after 70 ns;
la clause after end arch1;

Banc d’essai de base en VHDL

Clause after dans l’assignation d’un signal

• La génération des vecteurs de test peut être faite à l’aide de la clause after
associée à des assignations concurrentes.
• La clause after permet de spécifier le moment auquel les signaux doivent
prendre différentes valeurs.
• Elle comporte une expression de temps, composée d’une quantité et d’une
unité.
• L’unité « ns » signifie nanoseconde.
• La simulation est réputée débuter au temps T = 0 s.

Banc d’essai amélioré

nouveau type: tableau de port (Cin, X, Y : in std_logic; Cout, S : out std_logic);
end component;
std_logic_vector de 3 éléments
signal Cin, X, Y : std_logic;
-- signaux pour les réponses
signal Cout, S : std_logic;
déclaration d’une constante
contenant les vecteurs de test type tableauSLV3 is array (natural range <>) of std_logic_vector(2 downto 0);
constant vecteurs : tableauSLV3 :=
("000", "001", "010", "011", "100", "101", "110", "111");
begin
application de tous
-- instanciation du module à vérifier
les vecteurs UUT : add3bits port map (Cin, X, Y, Cout, S);
process -- application des vecteurs de test emmagasinés dans le tableau

assignation combinée begin
for k in vecteurs'low to vecteurs'high loop
par concaténation (Cin, Y, X) <= vecteurs(k);
wait for 10 ns;
end loop;
end process;
la clause wait suspend end arch2;
l’éxécution, force les signaux à
se propager dans l’UUT,
permet d’observer la réponse Il faut vérifier manuellement si la
spécification est rencontrée.
Parenthèse: définition de nouveaux types en VHDL

• On peut définir de nouveaux types avec le mot clé type, et des sous-types avec
le mot clé subtype.
• On peut entre autres définir des types composés dont les éléments:
– sont tous du même type et sont numérotés (vecteurs ou matrices, array)
– être de types différents et qui sont nommés (structures, record).
nombre d’éléments spécifié
type entiers_sous_20 is range 0 to 19;
nombre d’éléments pas spécifié
type matrice_reelle_1_par_10 is array (1 to 10) of real;
type tableauSLV3 is array (natural range <>) of std_logic_vector(2 downto 0);

constant vecteurs : tableauSLV3 :=
("000", "001", "010", "011", "100", "101", "110", "111");
le nombre d’éléments de cette type nom_de_mois is (janvier, février, mars, avril, mai, juin, juillet, aout,
septembre, octobre, novembre, décembre);
constante est déterminé par sa
définition type date is record
jour : integer range 1 to 31;
mois : nom_de_mois;
année : positive range 1 to 3000;
end record;
constant confederation : date := (1, juillet, 1867);

Vérification exhaustive
• Pour un circuit combinatoire, il est parfois possible de faire une vérification
exhaustive. Au lieu d’un tableau, on peut utiliser une boucle.
library ieee; Package ieee.numeric_std.all pour:
use ieee.numeric_std.all;
• type unsigned
• fonction to_unsigned()
port (Cin, X, Y : in std_logic; Cout, S : out std_logic);
end component;

signal Cin, X, Y : std_logic;
signal Cout, S : std_logic;
Un peu de magie …
begin

UUT : add3bits port map (Cin, X, Y, Cout, S); 1. Conversion de type d’entier à unsigned
(k est implicitement entier parce que c’est un
process -- application exhaustive des vecteurs de test
begin compteur de boucle).
for k in 0 to 7 loop
(Cin, Y, X) <= to_unsigned(k, 3);
wait for 10 ns; 2. Objet composite (Cin, Y, X) est un tableau de
end loop;
end process; std_logic.
end arch3;
3. Le type unsigned est défini comme un
tableau de std_logic alors l’assignation est
Il faut vérifier manuellement si la permise.
spécification est rencontrée.
Vérification pseudo-aléatoire
• Un test pseudo-aléatoire peut venir compléter un test plus dirigé.
library ieee;
use ieee.numeric_std.all; Package ieee.math_real.all pour les procédures
use ieee.math_real.all;
• uniform()
architecture arch4 of add3bitstb is • floor()
… -- comme précédemment
begin
-- instanciation du module à vérifier uniform() est une procédure: elle modifie les
UUT : add3bits port map (Cin, X, Y, Cout, S);
paramètres qui lui sont passés.
process -- génération aléatoire de vecteurs de test
variable seed1 : positive := 1; L’appel d’une procédure est un énoncé concurrent.
variable seed2 : positive := 2;
variable aleatoire : real;
variable t : integer := -1;
begin
floor() est une fonction: elle ne modifie pas
uniform(seed1, seed2, aleatoire); -- 0.0 < aleatoire < 1.0 les paramètres qui lui sont passés.
aleatoire := floor(aleatoire * 8.0); -- 0.0 <= aleatoire <= 7.0
t := integer(aleatoire); -- 0 <= t <= 7 L’appel d’une fonction est une expression.
(Cin, Y, X) <= to_unsigned(t, 3);
wait for 10 ns;
end process; Quelques manipulations algébriques suivies de

end arch4;
deux conversions de type: de real à
integer, puis de integer à unsigned.
Il faut vérifier manuellement si la spécification est rencontrée.

Parenthèse: Extrait du package ieee.math_real
• Texte complet disponible:
http://www.ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=556551
procedure UNIFORM(variable SEED1,SEED2:inout POSITIVE; variable X:out REAL);
-- Purpose:
-- Returns, in X, a pseudo-random number with uniform
-- distribution in the open interval (0.0, 1.0).
-- Special values:
-- None
-- Domain:
-- 1 <= SEED1 <= 2147483562; 1 <= SEED2 <= 2147483398
-- Error conditions:
-- Error if SEED1 or SEED2 outside of valid domain
-- Range:
-- 0.0 < X < 1.0
-- Notes:
-- a) The semantics for this function are described by the
-- algorithm published by Pierre L’Ecuyer in "Communications
-- of the ACM," vol. 31, no. 6, June 1988, pp. 742-774.
-- The algorithm is based on the combination of two
-- multiplicative linear congruential generators for 32-bit
-- platforms.
--
-- b) Before the first call to UNIFORM, the seed values
-- (SEED1, SEED2) have to be initialized to values in the range
-- [1, 2147483562] and [1, 2147483398] respectively. The
-- seed values are modified after each call to UNIFORM.
--
-- c) This random number generator is portable for 32-bit
-- computers, and it has a period of ~2.30584*(10**18) for each
-- set of seed values.
--
-- d) For information on spectral tests for the algorithm, refer
-- to the
INF3500 : Conception L’Ecuyer article.
et implémentation de systèmes numériques 25
Parenthèse: Fonctions et procédures en VHDL

• Deux types de sous-programmes en VHDL, les fonctions et les procédures.
• Une fonction …
– est un sous-programme qui retourne un résultat unique;
– retourne une valeur qui peut être d’un type scalaire ou composé;
– peut accepter des paramètres en entrée, ces paramètres ne peuvent pas être
modifiés par la fonction;
– est appelée dans une expression.
• Une procédure …
– est un sous-programme avec une liste de paramètres qui peuvent avoir les modes in,
out et inout, permettant ainsi à la procédure d’accepter des valeurs en entrée, de
retourner des résultats, et de modifier des paramètres qui lui sont passés;
– est appelée comme un énoncé concurrent.

Parenthèse: Fonctions et procédures en VHDL

• Les fonctions et les procédures peuvent être surchargées, c'est-à-dire que deux
d’entre elles peuvent avoir le même identificateur mais une liste de paramètres
différents. On peut aussi surcharger les opérateurs de VHDL.
• Les fonctions et procédures peuvent être définies dans la partie déclarative
d’une architecture, ou bien dans un package.
• Exemple de définition d’une fonction:
function porteET(V: std_logic_vector) return std_logic is

variable resultat : std_logic := '1';
begin
for k in V'range loop
resultat := resultat and V(k);
end loop;
return resultat;
end;

Parenthèse: Un truc - instanciation directe d’une entité
architecture arch1a of add3bitsTB is

signal Cin : std_logic; Pas besoin de déclaration de composante.
signal X : std_logic;
signal Y : std_logic;
signal Cout : std_logic; Mot clé entity
signal S : std_logic; Identificateur de l’entité
begin identificateur de l’architecture entre parenthèses
UUT : entity add3bits(flotdonnees) port map (Cin, X, Y, Cout, S);
-- on applique des vecteurs de test

Cin <= '0' after 0 ns, '1' after 40 ns;
Y <= '0' after 0 ns, '1' after 20 ns, '0' after 40 ns, '1' after 60 ns;
X <= '0' after 0 ns, '1' after 10 ns, '0' after 20 ns, '1' after 30 ns,
'0' after 40 ns, '1' after 50 ns, '0' after 60 ns, '1' after 70 ns;
end arch1a;

Observation et évaluation des réponses : assertions

• L’observation et la comparaison automatisées des réponses du module à vérifier
est une approche très puissante qui économise beaucoup de temps pour tous
les circuits non triviaux.
• Pour toute condition où le circuit ne produit pas les réponses attendues, le banc
d’essai devrait générer un message d’avertissement indiquant
– le moment où l’erreur s’est produite;
– la valeur du vecteur de test; Parce qu’on ne veut pas vérifier manuellement si
– la valeur des réponses observées; et, la spécification est rencontrée!!!
– la valeur des réponses attendues.

• La production de messages à l’utilisateur en VHDL peut se faire à l’aide des
énoncés assert et report.
• Un message est affiché à la console si l’expression logique est fausse. L’énoncé
report peut être utilisé seul, ce qui correspond à le précéder de l’énoncé
assert false.

Exemple: module qui indique si un nombre est premier
library ieee;
use ieee.std_logic_1164.ALL;
entity detecteurPremier is
port (
Spécification:
I : in unsigned(5 downto 0);
F : out std_logic La sortie F doit être ‘1’ si le nombre
);
end detecteurPremier; entier non signé représenté sur 6 bits I
architecture flotdonnees of detecteurPremier is est premier, et ‘0’ sinon.
begin
with to_integer(I) select
F <=
'1' when 2 | 3 | 5 | 7 | 11 | 13 | 17 |
19 | 23 | 29 | 31 | 37 | 41 | 43 |
47 | 53 | 59 | 61 | 63, -- erreur!
'0' when others;
end flotdonnees;

Exemple d’utilisation d’une assertion
pour comparer le module à un modèle de haut niveau
library ieee;
use ieee.std_logic_1164.all;
use ieee.math_real.all;
entity detecteurPremierTB is begin

end detecteurPremierTB;
architecture arch1 of detecteurPremierTB is UUT : detecteurPremier port map (I, F);
component detecteurPremier -- déclaration du module à vérifier process
port (I : in unsigned(5 downto 0); F : out std_logic); constant kmax : integer := 63;
end component; begin
for k in 0 to kmax loop -- application exhaustive des vecteurs de test
signal I : unsigned(5 downto 0); I <= to_unsigned(k, 6);
signal F : std_logic; wait for 10 ns;
assert (estPremier(k) = (F = '1'))
function estPremier(n: integer) return boolean is report "erreur pour l'entrée " & integer'image(k) severity error;
variable reponse : boolean := false; end loop;
begin report "simulation terminée" severity failure;
if (n <= 1) then end process;
-- par définition, le premier nombre premier est 2
reponse := false; end arch1;
elsif (n <= 3) then
reponse := true;
else
reponse := true;
for k in 2 to integer(ceil(sqrt(real(n)))) loop
if (n mod k = 0) then
reponse := false;
exit;
integer’image(k)
end if;
end loop;
retourne une chaîne de caractères représentant l’entier k
end if;
return reponse;
end estPremier;
Modèle de haut niveau décrit dans une fonction.
Cette fonction n’est pas synthétisable, elle n’est utilisée que pour
vérifier la description du circuit qui doit être synthétisé.
La question: cette fonction est elle correcte?

Décortiquer l’énoncé assert (1)
Vrai ou faux Vrai ou faux
Vrai ou faux en même temps?
Nécessaire pour que le circuit (sortie F) ait le même

comportement que la fonction (esPremier).
On suppose que la fonction représente bien la spécification.

Parenthèse:
Quatre niveaux de severity pour une assertion
• Définis dans le package standard, disponible dans le manuel de référence du
langage VHDL, norme 1076-2002 (section 14.2)
http://www.ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=1003477
• type SEVERITY_LEVEL is (NOTE, WARNING, ERROR, FAILURE);
• On peut spécifier au simulateur à quel niveau terminer la simulation.

report "erreur pour l'entrée " & integer'image(k)
severity error;
report "simulation terminée”

severity failure;

Décortiquer l’énoncé assert (2)
report "simulation terminée" severity failure;

assert false report "simulation terminée" severity failure;
Nécessaire pour que la simulation se termine.
En VHDL, les processus sont exécutés de façon continue.
Si cet énoncé n’est pas présent, après la dernière itération de la boucle

l’exécution du processus est automatiquement relancée.

t d
m er , att
H DL e.nu ures
de V s iee océd
c és kage et pr
v an pac ns
a
p ts pes, nctio
nce x ty l, fo
o u a
r
No e.ma nco
e
iee lus
p
et
Circuits combinatoires arithmétiques
• Beaucoup de circuits doivent traiter de l’information numérisée et doivent
effectuer des opérations arithmétiques.
• Les circuits arithmétiques nécessitent:
– Une représentation binaire des nombres;
– Des composantes pour réaliser les opérations arithmétiques.

Exemple: conversion de couleurs de RGB à CMYK
• Les images sont habituellement encodées dans l’espace à trois dimensions RGB.
• Une imprimante utilise plutôt l’espace CMY: cyan (C), magenta (M) et jaune (Y),
les couleurs complémentaires de rouge, vert et bleu.
• Les équations de conversion, pour des valeurs exprimées sur 8 bits, sont:
C = 255 – R; M = 255 – G; Y = 255 – B
A. Stodghill, Tip o’day: ask for a a refill, Green Options, 2007/06/18. Consulté le 4 septembre 2009, tiré
INF3500 : Conception et implémentation de systèmes numériques de http://greenoptions.com/tag/ink-cartridge
37
Exemple: conversion de couleurs de RGB à CMYK
• Bien qu’il soit possible d’imprimer du noir en combinant des quantités
suffisantes d’encres C, M et Y, on utilise plutôt une cartouche spéciale d’encre
noire, d’où le système CMYK (avec K pour noir).
• On économise ainsi l’encre de couleur qui est plus chère, et le noir est plus noir.
• On réduit les valeurs (C, M, Y) de façon à utiliser le plus d’encre noire possible.
• Par exemple, on pourrait remplacer CMY = (250, 200, 200) par (50, 0, 0) + (200,
200, 200), où la dernière quantité correspond à du gris, obtenu de l’encre noire.
• On a donc les équations suivantes pour la conversion de RGB à CMYK:
Ct  255  R Tâche:
Mt  255  G
Yt  255  B Proposez un circuit combinatoires pour effectuer
la conversion de l’espace RGB à CMYK.
K  min(Ct , Mt , Yt )
C  Ct  K Donnez son diagramme, son code VHDL
M  Mt  K synthétisable, et un banc d’essai pour en vérifier le
Y  Yt  K fonctionnement.
Analyse du problème:
conversion de couleurs de RGB à CMYK
• Besoin de représenter des valeurs numériques, quel type choisir?
– real: non! trop précis et pas synthétisable
– integer, natural: peut-être; positive: non (min: 1)
• Bien supportés par les synthétiseurs pour les opérations arithmétiques.
• Permet de faire abstraction de la représentation de quantités par un tableau de bits.
• Important de spécifier la gamme de valeurs possibles de façon à contraindre les ressources
matérielles utilisées pour les représenter.
– signed, unsigned: peut-être
• Définis dans le package normalisé numeric_std, comme des tableaux de std_logic.
• Bien supportés par les outils de synthèse.
• Le package numeric_std redéfinit les opérateurs de VHDL pour ces deux types.
– std_logic_vector: non, trop bas niveau
• Défini dans le package std_logic_1164 comme un tableau de std_logic.
• Des packages populaires incluent des définitions pour les opérations arithmétiques, mais
ils ne sont pas normalisés et leur utilisation n’est pas recommandée.
• Besoin de l’opération de soustraction
• Besoin de l’opération minimum
Parenthèse: Types prédéfinis en VHDL

type source
catégorie valeurs
ou sous-type de la définition
boolean type prédéfini FALSE et TRUE
bit type prédéfini ‘0’ et ‘1’
256 caractères de la norme ISO 8859-
1, avec des abréviations reconnues et
character type prédéfini certaines qui sont propres à VHDL
Les 128 premiers sont les caractères
ASCII.
integer type prédéfini plage minimale de –231 + 1 à 231 – 1
natural sous-type prédéfini 0 à 231 – 1
positive sous-type prédéfini 1 à 231 – 1
real typiquement
type prédéfini
scalaires –1.7014111E±308 à 1.7014111E±308
‘U’ : valeur inconnue, pas initialisée
‘X’ : valeur inconnue forcée
‘0’ : 0 forcé
‘1’ : 1 forcé
Package
std_logic ‘Z’ : haute impédance (pas connecté)
std_logic_1164
‘W’ : inconnu faible
‘L’ : 0 faible
‘H’ : 1 fabile
‘-‘ : peu importe (don’t care)
bit_vector type prédéfini tableau de bit
string type prédéfini tableau de character
Package
std_logic_vector tableau de std_logic
std_logic_1164
composés Package tableau de std_logic, interprété
unsigned
numeric_std comme un nombre binaire non signé
Package tableau de std_logic, interprété
signed comme un nombre binaire signé
numeric_std en complément à deux 40
Conversion de couleurs de RGB à CMYK
Diagramme de blocs

Code VHDL
library ieee;
entity convRGB2CMYK is
port (
rouge, vert, bleu : in unsigned(7 downto 0);
cyan, magenta, jaune, noir : out unsigned(7 downto 0)
);
end convRGB2CMYK;
architecture arch2 of convRGB2CMYK is
begin
process(rouge, vert, bleu)

variable cyant, magentat, jaunet, noirt1, noirt2 : unsigned(7 downto 0);
begin
cyant := 255 - rouge;

magentat := 255 - vert;
jaunet := 255 - bleu;
if cyant < magentat then noirt1 := cyant; else noirt1 := magentat; end if;
if noirt1 < jaunet then noirt2 := noirt1; else noirt2 := jaunet; end if;
cyan <= cyant - noirt2;

magenta <= magentat - noirt2;
jaune <= jaunet - noirt2;
noir <= noirt2;
end process;
end arch2;

Banc d’essai - intro
library ieee;
use ieee.NUMERIC_STD.all;
entity convrgb2cmyk_tb is
end convrgb2cmyk_tb;
architecture TB_ARCHITECTURE of convrgb2cmyk_tb is
signal rouge, vert, bleu, cyan, magenta, jaune, noir : UNSIGNED(7 downto 0);
type pixelRGB_type is record

rouge : integer range 0 to 255;
vert : integer range 0 to 255;
bleu : integer range 0 to 255;
end record;
type tableau_pixelRGB is array (natural range <>) of pixelRGB_type;

constant vecteurs : tableau_pixelRGB := (
(0,0,0),(1,1,1),(2,2,2),(100,100,100),(128,128,128),(200,200,200),(254,254,254),(255,255,255),
(0,255,255),(255,0,255),(255,255,0),(0,0,255),(0,255,0),(255,0,0),
(1,100,254),(1,254,100),(100,1,254),(100,254,1),(254,1,100),(254,100,1)
--(-1,-1,-1),(-1,0,0),(0,-1,0),(0,0,-1),(256,256,256),(256,0,0),(0,256,0),(0,0,256)
);

Banc d’essai – suite et fin
begin
-- Unit Under Test port map

UUT : entity convrgb2cmyk(arch2) port map (rouge, vert, bleu, cyan, magenta, jaune, noir);
process
begin
for k in vecteurs'range loop
rouge <= to_unsigned(vecteurs(k).rouge, 8);

vert <= to_unsigned(vecteurs(k).vert, 8);
bleu <= to_unsigned(vecteurs(k).bleu, 8);
wait for 10 ns;
assert 255 - (to_integer(noir) + to_integer(cyan)) = vecteurs(k).rouge

report "erreur pour l'entrée " & integer'image(k) &
", rouge: " & integer'image(vecteurs(k).rouge) & ", cyan: " & integer'image(to_integer(cyan))
severity error;
assert 255 - (to_integer(noir) + to_integer(magenta)) = vecteurs(k).vert

", vert: " & integer'image(vecteurs(k).vert) & ", magenta: " & integer'image(to_integer(magenta))
severity error;
assert 255 - (to_integer(noir) + to_integer(jaune)) = vecteurs(k).bleu

", bleu: " & integer'image(vecteurs(k).bleu) & ", jaune: " & integer'image(to_integer(jaune))
severity error;
end loop;
assert false report "simulation terminée" severity failure;
end process;
end TB_ARCHITECTURE;
Arithmétique en VHDL: quelques trucs

• Types
– real
• opérations arithmétiques sont très couteuses en matériel
• en général pas supporté par les synthétiseurs, sauf pour valeurs statiques
– integer
• permet de faire abstraction de la représentation sur des bits
• important: spécifier la gamme de valeurs utilisées, pour guider le synthétiseur, sinon 32
bits sont alloués par défaut
– signed (complément à deux) et unsigned (non signé)
• définis dans le package numeric_std
http://www.eda.org/rassp/vhdl/models/standards/numeric_std.vhd
• vecteurs de std_logic
• opérateurs surchargés pour opérations sur ces types et sur certains types mixtes, ex.
unsigned + signed, integer + signed, etc.
signal A : signed(3 downto 0);
signal B : unsigned(3 downto 0);
signal C : std_logic_vector(3 downto 0);
. . .
A <= "1100"; -- -4
B <= "1100"; -- +12
C <= "1100"; -- bits 1100

Rappel: représentation non signée
et signée en complément à deux
valeur
b7 b6 b5 b4 b3 b2 b1 b0 signée en valeur non
comp. à signée
m 1 deux
Vunsigned   bi 2i 0 1 1 1 1 1 1 1 127 127

i 0
0 1 1 1 1 1 1 0 126 126
m2
Vsigned  bm 1 2 m 1   bi 2i 0 0 0 0 0 0 1 0 2 2
0 0 0 0 0 0 0 1 1 1
i 0
0 0 0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 -1 255
1 1 1 1 1 1 1 0 -2 254
1 0 0 0 0 0 0 1 -127 129
1 0 0 0 0 0 0 0 -128 128

Assigner la valeur d’une expression à un objet
• Pour assigner la valeur d’une expression à un objet (signal, variable), il faut:
– que les types soient compatibles
– que les dimensions soient les mêmes
library ieee;
entity democode2 is
port (
A8, B8 : in signed(7 downto 0);
R8 : out signed(7 downto 0);
R9, S9, T9 : out signed(8 downto 0);
R7 : out signed(6 downto 0)
);
end;
architecture arch of democode2 is
begin
R8 <= A8 + B8; -- ok, mais risque de débordement
S8 <= A8 + 100; -- ok, mais risque de débordement
R9 <= (A8(A8'left) & A8) + (B8(B8'left) & B8); -- ok
S9 <= resize(A8, S9'length) + resize(B8, S9'length); -- ok
--T9 <= A8 + B8; -- non, largeurs incompatibles!
R7 <= A8(6 downto 0) + B8(6 downto 0); -- ok, mais ...
end arch;

Conversions de types: exemples

• Conversion explicite de type: avec le nom du type et la valeur entre parenthèses
– passer entre real et integer
– passer entre unsigned, signed et std_logic_vector
• Conversions de valeurs:
– to_signed(), to_unsigned, to_integer(), définies dans numeric_std
– pour passer entre integer, signed et unsigned
– to_signed() et to_unsigned: paramètres de valeur et de largeur
variable vreal : real := 3.14159; -- vers signed

variable vint : integer := -99; vsigned := to_signed(integer(vreal), vsigned'length);
variable vsigned : signed(7 downto 0) := "10011101"; vsigned := to_signed(vint, vsigned'length);
variable vusigned : unsigned(7 downto 0) := "01011001"; vsigned := signed(vusigned);
variable vslv : std_logic_vector(7 downto 0) := "11000011"; vsigned := signed(vslv);
-- vers unsigned
-- vers real vusigned := to_unsigned(integer(vreal), vusigned'length);
vreal := real(vint); vusigned := to_unsigned(vint, vusigned'length);
vreal := real(to_integer(vsigned)); vusigned := unsigned(vsigned);
vreal := real(to_integer(vusigned)); vusigned := unsigned(vslv);
vreal := real(to_integer(signed(vslv)));
-- vers std_logic_vector
-- vers integer vslv := std_logic_vector(to_signed(integer(vreal), vslv'length));
vint := integer(vreal); vslv := std_logic_vector(to_signed(vint, vslv'length));
vint := to_integer(vsigned); vslv := std_logic_vector(vusigned);
vint := to_integer(vusigned); vslv := std_logic_vector(vsigned);
vint := to_integer(signed(vslv));

Conversions de types pour arithmétique en VHDL
Une figure pour résumer

t d
m er , att
H DL e.nu ures
de V s iee océd
c és kage et pr
v an pac ns
a
p ts pes, nctio
nce x ty l, fo
o u a
r
No e.ma nco
e
iee lus
p
et

02 Ccts Comb Avancesv 21

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

02 Ccts Comb Avancesv 21

Transféré par

Droits d'auteur :

Formats disponibles

Cours #2

INF3500 : Conception et implémentation de systèmes numériques

Flot de conception de circuits numériques

Extraction statique des métriques d’implémentation

INF3500 : Conception et implémentation de systèmes numériques 2

INF3500 : Conception et implémentation de systèmes numériques 4

F  A' BCD  AB' CD  ABC ' D  ABCD ' ABCD

library IEEE; -- équation non réduite

INF3500 : Conception et implémentation de systèmes numériques 6

INF3500 : Conception et implémentation de systèmes numériques 7

Parenthèse: Types communément utilisés en VHDL

Parenthèse: Opérateurs en VHDL

and, or, nand, nor, xor,

relation =, /=, <, <=, >, >= scalaire ou tableau boolean

sll (déc. logique gauche),

concaténation & tableau ou type énuméré tableau

INF3500 : Conception et implémentation de systèmes numériques 9

Parenthèse: attributs en VHDL

INF3500 : Conception et implémentation de systèmes numériques 10

INF3500 : Conception et implémentation de systèmes numériques 11

INF3500 : Conception et implémentation de systèmes numériques 12

Retour sur le flot de conception de circuits numériques

Extraction statique des métriques d’implémentation

INF3500 : Conception et implémentation de systèmes numériques 14

Vérification: concepts fondamentaux

INF3500 : Conception et implémentation de systèmes numériques 15

Vérification par banc d’essai

INF3500 : Conception et implémentation de systèmes numériques 16

architecture flotDeDonnees of add3bits is

S <= T1 xor Cin;

INF3500 : Conception et implémentation de systèmes numériques 17

Banc d’essai de base en VHDL

architecture arch1 of add3bitsTB is

component add3bits -- déclaration du module à vérifier

-- signaux pour les vecteurs de tests

-- on applique des vecteurs de test

INF3500 : Conception et implémentation de systèmes numériques 18

Banc d’essai de base en VHDL

INF3500 : Conception et implémentation de systèmes numériques 19

Clause after dans l’assignation d’un signal

INF3500 : Conception et implémentation de systèmes numériques 20

Banc d’essai amélioré

architecture arch2 of add3bitsTB is

component add3bits -- déclaration du module à vérifier

process -- application des vecteurs de test emmagasinés dans le tableau

Parenthèse: définition de nouveaux types en VHDL

type tableauSLV3 is array (natural range <>) of std_logic_vector(2 downto 0);

constant confederation : date := (1, juillet, 1867);

INF3500 : Conception et implémentation de systèmes numériques 22

-- signaux pour les vecteurs de tests

-- instanciation du module à vérifier

end process; Quelques manipulations algébriques suivies de

Il faut vérifier manuellement si la spécification est rencontrée.

INF3500 : Conception et implémentation de systèmes numériques 24

Parenthèse: Fonctions et procédures en VHDL

INF3500 : Conception et implémentation de systèmes numériques 26

Parenthèse: Fonctions et procédures en VHDL

function porteET(V: std_logic_vector) return std_logic is

INF3500 : Conception et implémentation de systèmes numériques 27

Parenthèse: Un truc - instanciation directe d’une entité

architecture arch1a of add3bitsTB is

-- signaux pour les vecteurs de tests

-- on applique des vecteurs de test