ECOLE NATIONALE POLYTECHNIQUE

Département d’Electronique
Modélisation et Synthèse des Circuits Logiques

1° Année Registres et Compteurs

Série d’Exercices
Les Registres
Exercice 1
1. Donner une description structurelle d’un 4-bit register with asynchronous reset
registre de mémorisation (Buffer) 4 bits à base de LIBRARY ieee ; USE ieee.std_logic_1164.all ;
ENTITY reg4 IS
flip flops D à reset asynchrone. PORT (
D : IN STD_LOGIC_VECTOR(3 DOWNTO 0) ;
Resetn, Clock : IN STD_LOGIC ;
Q : OUT STD_LOGIC_VECTOR(3 DOWNTO 0) ) ;
END reg4 ;
ARCHITECTURE behavioral OF reg8 IS BEGIN
PROCESS ( Resetn, Clock )
BEGIN
IF Resetn = '0' THEN Q <= "0000" ;
ELSIF rising_edge(Clock) THEN Q <= D ;
END IF ;
END PROCESS ;
END behavioral ;`
N-bit register with asynchronous reset
LIBRARY ieee ; USE ieee.std_logic_1164.all ;
ENTITY regn IS GENERIC ( N : INTEGER := 16 ) ;
- Déduire le code VHDL (structurel) d’un PORT (
registre de mémorisation générique de talle N. D :IN STD_LOGIC_VECTOR(N-1 DOWNTO 0) ;
2.écrire le code VHDL de version Resetn, Clock : IN STD_LOGIC ;
comportementale de ce registre (4bits). Q :OUT STD_LOGIC_VECTOR(N-1 DOWNTO 0) ) ;
END regn ;
- Déduire le code VHDL comportemental d’un ARCHITECTURE behavioral OF regn IS BEGIN
registre générique (N bits) PROCESS ( Resetn, Clock ) BEGIN
IF Resetn = '0' THEN Q <= (OTHERS => '0') ;
ELSIF rising_edge(Clock) THEN Q <= D ;
END IF ; END PROCESS ; END behavioral ;
Exercice 2 Registre A Décalage
1.Donner le code Vhdl d’ un registre à décalage
simple sur 6 bits, avec une entrée série.
2. Le pré chargement est maintenant en parallèle et
réalisé à l’aide de 6 interrupteurs. modifier le code
source précédent. L’ordre de pré chargement sera
donné par un interrupteur indépendant.
3. Modifier le code source pour obtenir un registre à
recirculation. IF Resetn = '0' THEN qt <= "000000" ;
Solution question 1 ELSIF rising_edge(Clock) THEN
-- 6-bit Shift_register with asynchronous reset
LIBRARY ieee ; USE ieee.std_logic_1164.all ;
ENTITY Shift_reg6 IS
PORT (
SerIN : IN STD_LOGIC;
Resetn, Clock : IN STD_LOGIC ;
SerQ : OUT STD_LOGIC ) ;
END 6-bit Shift_register ;
ARCHITECTURE behavioral OF Shift_reg is 6 END IF ;
Signal qt : std_logic_vector(5 downto 0); IS END PROCESS ;
BEGIN SerQ <= qt(6);
PROCESS ( Resetn, Clock ) END behavioral ;`
BEGIN
;

ENP/ ELN/ 1 Année Modélisation et Synthèse des Circuits Logiques MSCL

Taghi Serie de TD N°4 Page 1
Solution question 2 --6-bit shift register with parallel load
LIBRARY ieee ; ARCHITECTURE behavioral OF shift4 IS
USE ieee.std_logic_1164.all ; SIGNAL Qt : STD_LOGIC_VECTOR(5 DOWNTO 0);
ENTITY Shift_reg6 IS BEGIN PROCESS (Clock)
PORT ( D : IN std_logic_vector(3 downto 0) ; BEGIN IF rising_edge(Clock) THEN
Enable : IN STD_LOGIC ; IF Load = '1' THEN
Load : IN STD_LOGIC ; Qt <= D ; ELSIF Enable = ‘1’ THEN
Sin : IN STD_LOGIC ; Qt <= Sin & Qt(3 downto 1);
Clock : IN STD_LOGIC ; END IF ; END IF ;
Q : OUT STD_LOGIC_VECTOR(5 DOWNTO 0) ) ; END PROCESS ;
END Shift_reg6 ; Q <= Qt; END behavioural

Exercice 3
Donner le schéma d'un registre 3 bits Utiliser des bascules D synchrones à front
programmable, à écriture et lecture en série par montant. Écrire le programme VHDL
décalage à droite ou à gauche, circulaire ou non. correspondant.
Prévoir deux entrées de programmation P1 et P2,
et donner le code de programmation choisi.
Exercice 4- Registere à décalage universel
Solution incomplète
1- Etablir le code vhdl d’un registre univesel Library ieee;
decrit ci-après use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
use ieee.numeric_bit.all;
entity univ_shiftreg1 is port(
clk, il, ir : in bit; s: in bit_vector(1 downto 0);
i : in bit_vector(3 downto 0);
q : out bit_vector(3 downto 0));
end univ_shiftreg1;
architecture beh1 of univ_shiftreg1 is
signal qtmp : bit_vector(3 downto 0);
begin
process(clk)
begin if (clk = '1' and clk'event) then
case s is
when "00" => qtmp <= qtmp;
initialisation (INIT) when "01" => qtmp <= i;
lecture série ou parallèle (SSD, SSG, ou Qi) when "10" => qtmp<=qtmp(2 downto 0) & ir;
décalage à droite et à gauche (SENS) when "11" => qtmp<=il & qtmp(3 downto 1);
chargement série ou parallèle (MODE, ESD, when others => null;
ESG, Ei) end case;
2- En déduire le schéma logique. end if;
3- Donner une description structurelle à end process;
base de D Flip Flop q <= qtmp;
END beh1;

Exercice 5 – Réalisation d’une mémoire – un jeu de 4 registres synchrones de 8 bits

Réaliser en langage VHDL une mémoire
composée de 4 registres synchrones de 8 bits,
sensible sur le front montant du signal
d’horloge clk. Ecriture dans la mémoire est
autorisée avec le niveau zéro du signal n_wr.
1. Quelle est l’utilisation pratique de la
mémoire ?

ENP/ ELN/ 1 Année Modélisation et Synthèse des Circuits Logiques MSCL

Taghi Serie de TD N°4 Page 2
Exercice 6
Un compteur Johnson est particulier parce que library IEEE; use
tous les ‘1’ du compte sont toujours placés en un IEEE.STD_LOGIC_1164.all; use
seul groupe qui se déplace. Par exemple, pour un ieee.numeric_std.all; entity
compteurJohnson is generic ( W
compteur Johnson à quatre bits, la séquence : positive := 5 ); port (
serait : 00000001, 0011, 0111, 1111, 1110, 1100, reset, clk: in std_logic;
1000, 0000, 0001, 0011, etc. On observe que le compte : out std_logic_vector(W -
bit inséré en position la moins significative est 1 downto 0) ); end
égal à l’inverse du bit le plus significatif. compteurJohnson;
Donnez une architecture générique synthétisable
pour la déclaration d’entité suivante en VHDL de
façon à modéliser un compteur Johnson.

Exercice7 Linear Feedback Shift Register (LFSR)

The Linear Feedback Shift Register (LFSR) is a Compléter le schéma équivalent de ce LFSR qui sépare
circuit commonly used in communications l'état présent de l'état futur. En déduire les 16 équations
applications. Its primary purpose is to generate a de récurrences correspondantes
pseudo-random sequence of bits that also cover the
complete set of combinations of n-bits (except for
zero).

3) Réaliser ce LFSR en utilisant deux process : un qui

calcule de manière combinatoire l'état futur en fonction
The image above shows the structural idea of the
de l'état présent et un qui sur front d'horloge mettra à
LFSR. Each bit position shifts one spot to the right
jour l'état présent.
within the register on each clock period. The left-most
Indications :
bit (denoted as “1” in the figure) is calculated by architecture aLFSR of LFSR is
taking XORs of various selected bits within the signal etatpresent, etatfutur : std_logic_vector(16 downto 1);
register. The bits selected as tap points within the signal s_xor1, s_xor2, s_xor3 : std_logic;
LFSR dictate what kind of pattern the register will go begin -- Calcul intermediaire des ou exclusifs
through. If you select the tap points carefully, the s_xor1 <= etatpresent(15) xor etatpresent(1);
LFSR will hit every possible state of n bits, except for s_xor2 <= etatpresent(14) xor etatpresent(1);
0, and then start the pattern over again with the initial s_xor3 <= etatpresent(12) xor etatpresent(1);
value. -- Calcul de l'état futur en fonction de l'état présent et des
ou exclusifs
1) What are the recurrence equations of the register
process(etatpresent) begin
presented above ( the Fibonacci's LFSR)? etatfutur(16) <= etatpresent(1);
- Write a Vhdl description of this register -- A compléter
2) Nous allons gérer un générateur de Galois (1811- end process;
1832) de 16 bits dont voici le schéma process(clk,reset) begin
-- A compléter : gestion du "reset" et du "en"
end process; end aLFSR;
Il faut gérer un "reset" qui initialise à une autre valeur
que 0 !!! "0000000000000001" est une bonne valeur. Il
vous faut aussi gérer une entrée "en" pour enable (en
Le schéma ci-dessus représente essentiellement des français autoriser) "l'incrémentation".
décalages vers la droite. Si vous ne voulez pas les
écrire bit à bit vous utiliserez l'opérateur '&' VHDL
qui définit une concaténation (voir indications plus
loin).

ENP/ ELN/ 1 Année Modélisation et Synthèse des Circuits Logiques MSCL

Taghi Serie de TD N°4 Page 3
Exercice 7 (décalage, générique)
Etablir le code VHDL d’un décaleur générique vers la
droite modélisant une ligne à retard de taille
générique recevant à l’entrée un entier de taille
quelconque.
Solution
use ieee.std_logic_1164.all;
entity decalage is process(nrst,clk)
generic(profondeur : positive :=3;largeur : positive); Begin
port( if nrst='0' then
clk : in std_logic; boucle_rst : for i in 1 to profondeur loop
nrst : in std_logic; s_decaleur(i)<=(others=>'0');
input_vect : in std_logic_vector(largeur-1 downto 0); end loop boucle_rst;
output_vect : out std_logic_vector(largeur-1 downto 0)); elsif rising_edge(clk) then
end decalage; boucle_trf : for i in 1 to profondeur loop
architecture RTL of decalage is if i=1 then
type def_decalage is array (1 to profondeur) of s_decaleur(i)<=input_vect;
std_logic_vector(largeur-1 downto 0); else s_decaleur(i)<=s_decaleur(i-1);
signal s_decaleur : def_decalage; end if;
Begin end loop boucle_trf;
output_vect<=s_decaleur(profondeur);
end if;end process;end decalage

Les compteurs
Exercice 8 Compteur synchrone
1.Réaliser un compteur sur 4 bits par description comportementale.
2.Rajouter une entrée de remise à zéro asynchrone, puis synchrone.
4-bit up-counter with synchronous reset 4-bit up-counter with asynchronous reset
library ieee ; use ieee.std_logic_1164.all ; library ieee ;
use ieee.std_logic_unsigned.all ; use ieee.std_logic_1164.all ;
entity upcount is use ieee.std_logic_unsigned.all ;
port ( clear, clock : in std_logic ; entity upcount_ar is
q : out std_logic_vector(3 downto 0) ) ; port ( clock, resetn, enable : in std_logic ;
end upcount ; q : out std_logic_vector (3 downto 0)) ;
architecture behavioral of upcount is end upcount_ar ;
signal count : std_logic_vector(3 downto 0); architecture behavioral of upcount _ar is
begin signal count : std_logic_vector (3 downto 0) ;
upcount: process ( clock ) begin process ( clock, resetn )
if rising_edge(clock) then begin
if clear = '1' then if resetn = '0' then
count <= "00OO" ; else count <= "0000" ;
count <= count + 1 ; elsif rising_edge(clock) then
end if ; if enable = '1' then
end if; count <= count + 1 ;
end process; end if ; end if ;
q <= count; end process ;
end behavioral; q <= count ;
end behavioral ;
3- Donne une description structurelle de ce compteur à base de bascules D
Schéma de compteur 4 bits COMPONENT calcul
PORT( s,sb : IN bit_vector(3 DOWNTO 0);
compter : IN bit;
d : OUT bit_vector(3 DOWNTO 0);
END COMPONENT;
SIGNAL d, s, sb : bit_vector(3 DOWNTO 0);
BEGIN
B0: bascule PORT MAP (h, d(0), raz, s(0), sb(0));
B1: bascule PORT MAP (h, d(1), raz, s(1), sb(1));
B3: bascule PORT MAP (h, d(3), raz, s(3), sb(3));
B2: bascule PORT MAP (h => h, d =>d(2), raz => raz, s => s(3),
ARCHITECTURE structurelle OF compteur4 IS combi:calcul PORT MAP (s, sb, compter,d, plein);
COMPONENT bascule sb => sb(3));
PORT( h,d,raz : IN bit; END structurelle;
s,sb : OUT bit);
END COMPONENT;  Le composant Calcul doit décrire les équations des
entrées de bascules du compteur

ENP/ ELN/ 1 Année Modélisation et Synthèse des Circuits Logiques MSCL

Taghi Serie de TD N°4 Page 4
Autre description structurelle

Exercice 9– Réalisation d’un diviseur de fréquence par dix

Il s’agit de créer une entité permettant de diviser La sortie de cette bascule clk_div10 sera utilisée
la fréquence d’horloge clk par dix. Le diviseur comme la sortie du module.
doit être basé sur un compteur synchrone : 1. Quel est le rapport cyclique du signal
chaque fois que le compteur passera à cinq, il d’horloge généré ?
sera remis à zéro et il fera basculer la bascule D 2- Dessiner le circuit
commandée par ce compteur. 3- Etablir le code VHDL
Solution

ENP/ ELN/ 1 Année Modélisation et Synthèse des Circuits Logiques MSCL

Taghi Serie de TD N°4 Page 5
Exercice 10– Réalisation d’un compteur bi-directionnel synchrone et préchargeable sur 8 bits
Décrire en VHDL le compteur synchrone de 8 bits Le symbole du compteur est présenté ci-après
qui peut être préchargé (initialisé) par une valeur qui
se trouve à l’entrée init du compteur au moment où
l’entrée load est égale à ‘1’. L’entrée dir permet de
changer la direction du comptage (dir = ‘1’ pour
l’incrémentation et dir = ‘0’ pour la décrémentation).
Le comptage est autorisé par le signal ena (si ena =
‘1’, le compteur compte, sinon il s’arrête et garde la
valeur actuelle à sa sortie). Les entrées load, dir et ena
sont testées seulement pendant le front montant du
signal d’horloge clk (entrées synchrones). - Avant de proposer le code VHDL, définissez la
De plus, le compteur peut être remis à zéro d’une priorité de tous les signaux de contrôle (load, ena, dir,
manière asynchrone par un signal rst actif à zéro. clk et rst).

Exercice 11 Synthèse comportementale de compteurs synchrones

Dans la synthèse comportementale, on ne 2. Décrire un compteur synchrone avec remise à
s’occupe pas de la manière dont une fonction est zéro asynchrone comptant de 0 à 59 (minutes
réalisée, mais on décrit la fonction elle-même. d’une horloge).
C’est le compilateur qui se charge de trouver le 3. Combien de bascules sont nécessaires à la
moyen de la réaliser. réalisation de ces deux compteurs?
1. Décrire un compteur synchrone avec remise à 4. Rajouter une entrée et modifier le code source
zéro asynchrone comptant de 0 à 23 (heures afin de transformer ce compteur en compteur
d’une horloge). /décompteur.
Exercice 12
En faisant la simulation manuelle, reconnaître la fonction réalisée par le circuit décrit ci-après ,
proposer une architecture possible
library IEEE; VARIABLE carry : std_logic ;
use IEEE.std_logic_1164.all; BEGIN
-- description des entités du CD4040 IF reset = '1' THEN
ENTITY CD4040 IS sig_q <= "000000000000" ;
port (clock, reset : in std_logic ; ELSIF clock 'event and clock = '0' THEN
q : out std_logic_vector (11 downto 0) ); carry := '1' ;
END CD4040; FOR i in 0 to 11 LOOP
ARCHITECTURE arch_CD4040 of CD4040 IS var_q (i) := sig_q (i) xor carry ;
SIGNAL sig_q : std_logic_vector (11 downto 0) ; carry := sig_q (i) and carry ;
BEGIN END LOOP;
PROCESS (clock, reset) END IF;
VARIABLE var_q : std_logic_vector (11 downto 0) ; sig_q <= var_q ;
END PROCESS;
q <= sig_q ; END arch_CD4040 ;

ENP/ ELN/ 1 Année Modélisation et Synthèse des Circuits Logiques MSCL

Taghi Serie de TD N°4 Page 6
Exercice 13
Vous disposez d'une horloge rapide et vous voulez en réaliser une plus lente dont la fréquence est
divisée par 32768. Proposez un compteur avec comme entrée h_rapide et comme sortie h_lente (toutes
deux sur un bit). Le compteur intermédiaire sera réalisé par un signal. Décrire le circuit en VHDL
Exercice 14
Diviseurs de fréquence architecture VERS_1 of DIV is
1. Analyser l’architecture ci-contre. signal SIG : unsigned (4 downto 0);
2. Tracer un chronogramme représentatif du begin
fonctionnement du dispositif et de l’évolution des Q <= SIG(4);
process
signaux internes et externes.
begin
3. Indiquer le nombre de bascules nécessaires à wait until rising_edge(E);
sa réalisation. if SIG = to_unsigned(9, 5) then
4. Préciser la période et le rapport cyclique du SIG <= to_unsigned(21,5);
signal Q. else
library IEEE; SIG <= SIG + 1;
use IEEE.STD_LOGIC_1164.ALL; end if;
use IEEE.NUMERIC_STD.ALL; end process;
entity DIV is end architecture VERS_1;
port ( E : IN std_logic;
Q : OUT std_logic);
end entity DIV;

ENP/ ELN/ 1 Année Modélisation et Synthèse des Circuits Logiques MSCL

Taghi Serie de TD N°4 Page 7