4.2.1 L'alternative simple
Dans les blocs « always », on peut
inclure des conditions sous la forme de if. La syntaxe est
la suivante :
if (condition)
// TraitementVrai ;
else
// TraitementFaux ;
La seconde partie est
optionnelle (à partir de else).
L'ensemble du traitement « if ... else ... » est considéré
comme une seule instruction.
Pour tout traitement
dépassant une instruction, on place les mots-clés
begin et end qui jouent le rôle des accolades en langage
C. L'ensemble des instructions encadrées
est traité dans la condition.
Le traitement est séquentiel (les instructions
comprises entre les termes begin et end sont traitées
les unes après les autres).
Le positionnement du
résultat dépend de l'opérateur d'affectation
choisi (voir fin de ce chapitre).
Remarque : dans la littérature
ou d'autres cours, vous pouvez rencontrer des itérations
(while, forever, ...). Elles ne doivent pas être utilisées
pour un traitement comme on pourrait le faire en programmation
séquentielle classique. C'est pourquoi, elle sont
volontairement exclues du cadre de ce
cours.
4.2.2 Les opérateurs permettant
d'exprimer une condition
La condition est une grandeur
booléenne. Pour cela on dispose d’un certain
nombre d’opérateurs :
- la supériorité
(>),
- l’infériorité
(<),
- l’égalité
(==) se fait sans tenir compte des états
z et x,
- l'égalité littérale (===)
se fait y compris en tenant compte des état
z et x,
- la différence (!=),
- la différence littérale
(!==),
- la supériorité ou l'égalité (>=),
- l’infériorité
ou l'égalité (<=),
- le complément booléen
ou NON (!).
La condition à exprimer
peut mettre en jeu plusieurs éléments booléen :
- Le ET (&&),
- Le OU (||) [AltGr-6].
Conseil : il
sera parfois judicieux de placer des parenthèses pour fixer
explicitement l’ordre d’évaluation de la condition.
Conseil : il peut être intéressant
d’utiliser l’inverse de
la condition en la faisant précéder par
l’opérateur NON ( ! ).
Les « if »
peuvent être imbriqués ou non.
Certains étudiants
utilisent le symbole simple (ex : & = ET bit à
bit ) et non le symbole double (ex : && = ET
de booléen). Ceci fonctionne
dans la plupart des cas, c'est une utilisation
impropre du symbole.
Tout traitement supérieur
à une instruction doit être encadré
par « begin » et « end ».
Remarque : lorsque
la grandeur dans la condition est booléenne,
elle peut être laissée telle quelle :
- (a) est équivalent à
(a == 1),
- ( !a) est équivalent à
(a == 0).
Comme en
langage C, une expression nulle est fausse alors que
tout ce qui n’est pas nul est considéré
comme vrai.
Attention, l'opérateur <=
peut avoir un autre sens : c'est aussi une affectation
dite non bloquante (voir en fin du paragraphe).
4.2.3 Exemple
Une description comportementale du OU
exclusif prend alors la forme suivante :
module OUX2_1(e1, e2, S) ;
input e1, e2 ;
output S ;
reg S ;
always
if ((e1 && !e2) || (e2 &&
!e1))
S = 1 ;
else
S = 0 ;
endmodule
4.2.4 L'opérateur dit « conditionnel »
Il existe
l'équivalent du « if » appelé aussi
opérateur conditionnel qui peut éviter de passer par un
bloc « always ». Il peut s'utiliser en dehors d'un
bloc « always » donc sans déclaration de
mémoire.
La syntaxe est :
(condition)? t1
: t2 ;
et se lit : si la condition est vraie,
alors le résultat vaut t1 sinon il vaut t2.
exemple :
assign S = (a==2) ? 3 : 4 ; // Quand a
est égal à 2, s prend la valeur 3 sinon
c'est 4
Dans le cas d'une sortie 3 états,
la programmation pourra se faire ainsi :
assign S = (en) ? Q :
8'hzz;
4.2.5 Opérateurs
d'affectation
Nous avons jusqu'à
présent, rencontré l'opérateur d'affectation
=, il est dit bloquant. Il existe un autre opérateur
d'affectation <= dit non bloquant.
L'opérateur
d'affectation dit bloquant (=) est évalué
en entrant et affecté instantanément.
L'opérateur
d'affectation dit non bloquant (<=) est évalué
en entrant et affecté en sortant de la structure.
Attention : ne pas confondre
le rôle de <= qui est l'opérateur d'affectation
et le test (inférieur ou égal).
Ainsi pour échanger
2 valeurs a et b, il faut faire :
always
begin
t = b ;
b = a ;
a = t ;
end
ou encore
always
begin
a <= b ;
b <= a ;
end
mais pas :
always
begin
a = b ;
b = a ;
end
qui consiste à mettre
a dans b et c'est tout.
