Td tp n3 langage description vhdl registre décalage corrigé
Télécharger PDFExercice N°1 : Registre à décalage
Cet exercice présente un registre à décalage à droite simple. Un registre à décalage est un type de registre numérique capable de décaler les bits d'un mot binaire dans un sens ou dans l'autre, un bit à la fois, à chaque impulsion d'horloge. Il est couramment utilisé pour la conversion série-parallèle ou parallèle-série, ou pour des opérations arithmétiques.
Voici la description VHDL du registre à décalage à droite :
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.std_arith.all;
entity DECAL_D is
port (H,R,IN_SERIE :in std_logic;
OUT_SERIE :out std_logic);
end DECAL_D;
architecture ARCH_DECAL_D of DECAL_D is
signal Q :std_logic_vector(3 downto 0);
begin
process(H,R)
begin
if R='1' then
Q <= "0000";
elsif (H'event and H='1') then
Q <= Q(2 downto 0) & IN_SERIE;
end if;
end process;
OUT_SERIE <= Q(3);
end ARCH_DECAL_D;
Dans ce code VHDL, H est l'entrée d'horloge et R est une entrée de réinitialisation asynchrone qui met le registre à zéro. IN_SERIE est l'entrée série des données, et OUT_SERIE est la sortie série du bit le plus significatif. L'instruction Q <= Q(2 downto 0) & IN_SERIE; réalise le décalage à droite en déplaçant les bits de Q vers la droite et en insérant IN_SERIE à la position du bit le plus significatif (gauche).
Note : L'utilisation de work.std_arith.all; est souvent rencontrée dans d'anciens projets. Pour les opérations arithmétiques modernes, il est généralement recommandé d'utiliser ieee.numeric_std.all; qui offre des types et fonctions plus robustes pour la manipulation de nombres.
Exercice N°2 : Registre à décalage à droite à autorisation d'horloge
Ce registre à décalage à droite intègre un signal d'autorisation d'horloge (EN) qui permet de contrôler le moment où le décalage se produit. Lorsque EN est actif, le décalage s'effectue ; sinon, le registre maintient son état actuel.
On remarque que le signal d'autorisation d'horloge EN agit sur des multiplexeurs qui placent sur les entrées D, soit la sortie de la bascule de gauche (décalage), soit la sortie de la même bascule (inactivité apparente de l'horloge qui remémorise l'état antérieur).
Voici la description VHDL du registre :
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.std_arith.all;
entity DECAL_DE is
port (H,R,EN,IN_SERIE :in std_logic;
OUT_SERIE :out std_logic);
end DECAL_DE;
architecture ARCH_DECAL_DE of DECAL_DE is
signal Q :std_logic_vector(3 downto 0);
begin
process(H,R)
begin
if R='1' then
Q <= "0000";
elsif (H'event and H='1') then
if EN = '1' then
Q <= Q(2 downto 0) & IN_SERIE;
else
Q <= Q;
end if;
end if;
end process;
OUT_SERIE <= Q(3);
end ARCH_DECAL_DE;
Lorsque le signal EN est à '1', le registre fonctionne comme le registre à décalage précédent. En revanche, si EN est à '0', l'instruction Q <= Q; est exécutée, ce qui signifie que le contenu du registre Q reste inchangé lors du front d'horloge montant, simulant une désactivation de l'horloge pour le décalage.
Exercice N°3 : Registre à décalage à chargement parallèle synchrone
Ce type de registre à décalage est plus polyvalent car il peut non seulement décaler des données en série, mais aussi charger des données en parallèle simultanément. Le chargement parallèle est synchrone, c'est-à-dire qu'il se produit sur le front d'horloge montant, tout comme l'opération de décalage.
Voici la description VHDL du registre :
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.std_arith.all;
entity DECAL_P is
port (H,R,IN_SERIE,LOAD :in std_logic;
D :in std_logic_vector(3 downto 0);
OUT_SERIE :out std_logic);
end DECAL_P;
architecture ARCH_DECAL_P of DECAL_P is
signal Q :std_logic_vector(3 downto 0);
begin
process(H,R)
begin
if R='1' then
Q <= "0000";
elsif (H'event and H='1') then
if LOAD = '1' then
Q <= D;
else
Q <= Q(2 downto 0) & IN_SERIE;
end if;
end if;
end process;
OUT_SERIE <= Q(3);
end ARCH_DECAL_P;
L'entrée LOAD est un signal de contrôle. Si LOAD est à '1' sur un front d'horloge montant (et si le reset n'est pas actif), le registre est chargé avec la valeur de l'entrée parallèle D. Si LOAD est à '0', le registre effectue une opération de décalage à droite avec l'entrée série IN_SERIE. Cette fonctionnalité est essentielle pour les applications nécessitant à la fois le transfert série et le chargement rapide de données.
Exercice N°4 : Compteur en anneau : génération de séquence
Un compteur en anneau est un type de registre à décalage dont la sortie du dernier étage est bouclée vers l'entrée du premier étage, créant ainsi une séquence cyclique. C'est un générateur de séquences simple et déterministe.
Sur un chronogramme, on peut voir que si l'on raccorde les sorties aux entrées d'un sommateur analogique, on obtient une tension en escalier triangulaire, voire une pseudo-sinusoïde en pondérant correctement le sommateur.
Voici la description VHDL du compteur en anneau :
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.std_arith.all;
entity DEC_SEQ is
port (H,R :in std_logic;
Q :out std_logic_vector(3 downto 0));
end DEC_SEQ;
architecture ARCH_DEC_SEQ of DEC_SEQ is
signal X :std_logic_vector(3 downto 0);
begin
process(H,R)
begin
if R='1' then
X <= "0000";
elsif (H'event and H='1') then
X <= X(2 downto 0) & not X(3);
end if;
end process;
Q <= X;
end ARCH_DEC_SEQ;
Dans cet exemple, le bit le plus significatif X(3) est inversé (not X(3)) avant d'être bouclé à l'entrée série. Le registre est initialisé à "0000" par le reset. La séquence générée dépend de l'état initial et de la logique de rétroaction. Un compteur en anneau simple sans inversion créerait une séquence répétitive des mêmes bits, tandis que cette version avec inversion génère une séquence pseudo-aléatoire plus complexe.
Exercice N°5 : Compteur en anneau : génération de séquence pseudo-aléatoire
Cet exercice présente un générateur de séquences pseudo-aléatoires, souvent implémenté à l'aide d'un registre à décalage à rétroaction linéaire (LFSR). La séquence n'est pas réellement aléatoire, mais elle est très longue et ne se répète qu'après un nombre élevé d'états, ce qui la rend utile pour des applications comme le chiffrement, les tests ou la génération de bruits.
Voici la description VHDL du générateur :
LIBRARY ieee;
USE ieee.std_logic_1164.all;
USE work.std_arith.all;
entity DEC_ALEA is
port (H,R :in std_logic;
Q :out std_logic_vector(4 downto 0));
end DEC_ALEA;
architecture ARCH_DEC_ALEA of DEC_ALEA is
signal X :std_logic_vector(4 downto 0);
signal Y :std_logic;
begin
process(H,R)
begin
if R='1' then
X <= "00000";
elsif (H'event and H='1') then
X <= X(3 downto 0) & Y;
end if;
end process;
Y <= not (X(4) xor X(1));
Q <= X;
end ARCH_DEC_ALEA;
Dans ce LFSR, la rétroaction Y est générée par l'opération XOR (ou exclusif) entre les bits X(4) et X(1), puis inversée. Cette sortie Y est ensuite utilisée comme entrée série pour le décalage. Le choix des "taps" (positions des bits utilisés pour la rétroaction) est crucial pour obtenir une séquence de longueur maximale sans répétition prématurée. Un LFSR de N bits peut générer une séquence de longueur maximale de 2N-1 états.
FAQ
Qu'est-ce qu'un registre à décalage en VHDL et quelles sont ses applications courantes ?
Un registre à décalage est un circuit numérique séquentiel capable de stocker et de décaler des données binaires bit par bit. En VHDL, il est généralement modélisé à l'aide d'un processus sensible à l'horloge et à un signal de reset. Ses applications incluent la conversion de données série-parallèle ou parallèle-série, les générateurs de séquences, les compteurs, les retards de données et certaines opérations arithmétiques.
Comment gérer les resets (asynchrones/synchrones) et les activations d'horloge en VHDL ?
Un reset asynchrone (comme R='1' dans les exemples) agit immédiatement, indépendamment du front d'horloge, pour réinitialiser le système. Un reset synchrone, en revanche, ne s'active qu'au prochain front d'horloge actif. L'activation d'horloge (ou "clock enable", comme le signal EN) est un signal de contrôle synchrone qui permet de geler ou de valider les transitions d'état d'un circuit sur un front d'horloge, sans arrêter l'horloge elle-même.
Quelle est la différence entre un compteur en anneau simple et un LFSR (registre à décalage à rétroaction linéaire) ?
Un compteur en anneau simple (ou anneau de Johnson si l'entrée est inversée) est un registre à décalage dont la sortie du dernier étage est directement bouclée à l'entrée du premier étage (ou inversée). Il génère une séquence répétitive et déterministe. Un LFSR, quant à lui, utilise une fonction de rétroaction linéaire (généralement une combinaison XOR des bits du registre) pour générer l'entrée du premier étage. Les LFSR sont utilisés pour produire des séquences pseudo-aléatoires, qui semblent aléatoires sur une longue période mais sont en réalité déterministes et répétitives après un cycle très long.