Chargement…
Opérateurs logiques, relationnels, arithmétiques et de décalage en VHDL.
Une expression VHDL se lit avec les types des opérandes et la priorité des opérateurs. Les parenthèses rendent le regroupement explicite et évitent les interprétations erronées.
| Priorité | Catégorie | Opérateurs |
|---|---|---|
| 1, la plus faible | Logiques | and, |
nandnorxorxnor| 2 | Relationnels | =, /=, <, <=, >, >= |
| 3 | Décalage et rotation | sll, srl, sla, sra, rol, ror |
| 4 | Additifs | +, -, & |
| 5 | Signe unaire | +, - |
| 6 | Multiplicatifs | *, /, mod, rem |
| 7, la plus forte | Divers | **, abs, not |
Les opérations logiques existent notamment sur std_logic, std_logic_vector, bit et boolean. Sur un vecteur, elles travaillent bit à bit :
-- Sur std_logic (1 bit)
w_y <= i_a AND i_b;
w_y <= i_a OR i_b;
w_y <= i_a XOR i_b;
w_y <= NOT i_a;
w_y <= i_a NAND i_b;
w_y <= i_a NOR i_b;
w_y <= i_a XNOR i_b;
-- Sur std_logic_vector (bit à bit)
w_mask <= w_data AND "11110000"; -- masquage des 4 bits de poids faible
w_set <= w_data OR "00001111"; -- forçage des 4 bits de poids faibleLes opérateurs logiques partagent une même priorité. Le langage impose des restrictions sur leur mélange ; utilise des parenthèses pour préciser les groupes :
-- INCORRECT : ambiguïté de priorité
w_y <= i_a AND i_b OR i_c; -- erreur de compilation !
-- CORRECT : parenthèses obligatoires si mélange
w_y <= (i_a AND i_b) OR i_c;
w_y <= i_a AND (i_b OR i_c);Une comparaison retourne un boolean utilisable dans une condition :
if i_a = i_b then -- égalité
if i_a /= i_b then -- différent
if r_counter < 100 then -- strictement inférieur
if r_counter >= c_MAX then -- supérieur ou égalAvec numeric_std, unsigned et signed se comparent comme des nombres. La comparaison d'un std_logic_vector est lexicographique ; convertis-le vers le type numérique voulu avant une comparaison arithmétique.
numeric_std définit l'arithmétique sur les vecteurs numériques. Élargis les opérandes avant l'addition lorsque tu veux conserver la retenue. La largeur d'un produit est la somme des largeurs des deux opérandes :
library IEEE;
use IEEE.NUMERIC_STD.ALL;
signal r_a, r_b : unsigned(7 downto 0);
signal r_sum : unsigned(8 downto 0); -- +1 bit pour éviter overflow
-- Addition et soustraction
r_sum <= ('0' & r_a) + ('0' & r_b); -- extension par zéro
r_a <= r_a + 1; -- incrément
r_a <= r_a - r_b;
-- Multiplication (attention : double la largeur)
signal r_prod : unsigned(15 downto 0);
r_prod <= r_a * r_b; -- 8 * 8 = 16 bitsUne division ou un modulo par une valeur variable peut demander beaucoup de logique. Pour un compteur à modulo fixe, une comparaison explicite rend souvent le circuit plus simple :
if r_count = 9 then
r_count <= 0;
else
r_count <= r_count + 1;
end if;mod et rem donnent le même résultat avec des entiers positifs :
7 mod 4 = 3
7 rem 4 = 3Pour un résultat non nul, A mod B prend le signe de B, tandis que A rem B prend celui de A :
(-7) mod 4 = 1
(-7) rem 4 = -3Cette différence compte si le calcul accepte des valeurs négatives.
Les fonctions shift_left, shift_right, rotate_left et rotate_right de numeric_std rendent le type et la direction du déplacement visibles :
signal w_data : std_logic_vector(7 downto 0);
signal w_uns : unsigned(7 downto 0);
signal w_sig : signed(7 downto 0);
-- Décalage logique (remplissage par '0')
w_uns <= shift_left(w_uns, 2); -- décalage gauche de 2 (×4)
w_uns <= shift_right(w_uns, 1); -- décalage droit de 1 (÷2)
-- Décalage arithmétique sur signed : shift_right propage le bit de signe
w_sig <= shift_right(w_sig, 1);
-- Rotation
w_uns <= rotate_left(w_uns, 3);
w_uns <= rotate_right(w_uns, 3);shift_right ajoute des zéros à gauche d'un unsigned et répète le bit de signe d'un signed. Les opérateurs sll, srl, sla, sra, rol et ror existent aussi, avec leurs règles et surcharges propres.
& assemble les éléments ou les vecteurs :
signal w_byte : std_logic_vector(7 downto 0);
signal w_hi : std_logic_vector(3 downto 0) := x"A";
signal w_lo : std_logic_vector(3 downto 0) := x"5";
signal w_bit : std_logic := '1';
w_byte <= w_hi & w_lo; -- "10100101" = 0xA5
w_byte <= w_bit & "0110011"; -- insertion d'un bit
w_byte <= "0000" & w_lo; -- extension zéroCes opérations servent aussi au masquage, à l'extension et à la lecture de flags :
-- Tester un bit
if w_flags(3) = '1' then ...
-- Masquer des bits
w_result <= w_data AND x"0F"; -- garder les 4 bits de poids faible
-- Tronquer / étendre
w_16bit <= x"00" & w_8bit; -- zero-extend 8→16 bits
w_16bit <= (15 downto 8 => w_8bit(7)) & w_8bit; -- sign-extend 8→16 bits
-- Inverser tous les bits
w_inv <= NOT w_data;
-- Compter avec débordement
r_counter <= r_counter + 1; -- déborde naturellement à 0 (type unsigned)Vérifie la largeur conservée après chaque opération : une extension par zéro et une extension de signe ne portent pas la même intention.
📝 Tester mes connaissances - Quiz du chapitre