Construction d'un processus déclenché par horloge en VHDL : Guide pratique

La majorité des designs VHDL emploient de la logique horlogée - communément appelée logique synchrone ou séquentielle. Un processus horlogé s'active uniquement sur le front de l'horloge maître, indépendamment des changements dans les autres signaux d'entrée.

L'élément fondamental de la logique horlogée est le bascule (flip-flop). Dans ce tutoriel, nous nous concentrons sur le bascule à déclenchement par front montant avec reset négatif. Voir le schéma ci-dessous :

En tant que dispositif d'échantillonnage et de maintien, le bascule capture la valeur d'entrée sur le front montant de l'horloge et retient cette valeur jusqu'au prochain front montant ou jusqu'à ce que le signal de reset soit activé.

Note : Cet article fait partie de la série Tutoriels VHDL de Base.

Tous les processus horlogés se déclenchent à l'unisson et échantillonnent leurs entrées simultanément. L'horloge établit des pas de temps discrets, permettant aux concepteurs de partitionner la logique complexe en événements clairs, cycle par cycle.

Les bascules, ou tableaux de celles-ci, sont aussi appelées registres.

La liste de sensibilité d'un processus horlogé contient généralement seulement le signal d'horloge, car le processus s'éveille exclusivement sur un front d'horloge. Les entrées additionnelles sont ignorées pour des fins de déclenchement.

Ci-dessous se trouve un modèle réutilisable pour un processus horlogé avec reset synchrone :

process(Clk) is
begin
  if rising_edge(Clk) then
    if nRst = '0' then
      <reset all output signals here>
    else
      <main logic here>
    end if;
  end if;
end process;

Exercice

Dans le tutoriel vidéo accompagnant, nous parcourons la création d'un processus horlogé en VHDL.

Code du testbench

Le testbench final pour le bascule :

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity T17_ClockedProcessTb is
end entity;

architecture sim of T17_ClockedProcessTb is
  constant ClockFrequency : integer := 100e6; -- 100 MHz
  constant ClockPeriod : time := 1000 ms / ClockFrequency;
  signal Clk : std_logic := '1';
  signal nRst : std_logic := '0';
  signal Input : std_logic := '0';
  signal Output : std_logic;
begin
  -- Le Device Under Test (DUT)
  i_FlipFlop : entity work.T17_FlipFlop(rtl)
    port map(
      Clk => Clk,
      nRst => nRst,
      Input => Input,
      Output => Output
    );
    
  -- Génération d'horloge
  Clk <= not Clk after ClockPeriod / 2;
  
  -- Séquence de testbench
  process is
  begin
    -- Relâcher le DUT du reset
    nRst <= '1';
    wait for 20 ns;
    Input <= '1';
    wait for 22 ns;
    Input <= '0';
    wait for 6 ns;
    Input <= '1';
    wait for 20 ns;
    -- Appliquer le reset
    nRst <= '0';
    wait;
  end process;
end architecture;

Module Bascule

Implémentation du bascule à front montant avec reset négatif :

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity T17_FlipFlop is
  port(
    Clk : in std_logic;
    nRst : in std_logic; -- Reset négatif
    Input : in std_logic;
    Output : out std_logic
  );
end entity;

architecture rtl of T17_FlipFlop is
begin
  -- Bascule avec reset synchronisé
  process(Clk) is
  begin
    if rising_edge(Clk) then
      if nRst = '0' then
        Output <= '0';
      else
        Output <= Input;
      end if;
    end if;
  end process;
end architecture;

Observation de la forme d'onde

Après l'exécution de la simulation dans ModelSim et le zoom dans la timeline, la forme d'onde montre clairement la sortie se mettant à jour uniquement sur les fronts montants d'horloge :

Analyse

La sortie change exclusivement aux fronts montants d'horloge. Toute transition d'entrée qui se produit entre deux fronts montants - comme la baisse négative commençant vers 45 ns - n'est pas capturée, car le bascule échantillonne seulement au front.

Ci-dessous se trouve une animation qui visualise la relation entre l'entrée, l'horloge et la sortie :

Observations clés :

• L'impulsion d'entrée d'une période d'horloge à 20 ns est synchrone à l'horloge et produit une réponse retardée dans la sortie.
• Pendant la simulation, les événements se produisent en étapes de temps zéro (cycles delta). Parce que le bascule lit l'entrée et met à jour la sortie dans le même cycle delta, il capture la valeur d'entrée pré-front.

En pratique, un bascule nécessite une entrée stable pendant une brève période avant et après le front d'horloge - connu sous le nom de setup et hold times. Ces contraintes sont automatiquement gérées par les outils de synthèse lors de la conversion du VHDL en netlist.

Pour une plongée plus profonde dans les pas de temps de simulation, voir Cycles delta expliqués.

À retenir

• Les processus horlogés avec reset synchrone incluent seulement l'horloge dans la liste de sensibilité.
• L'utilisation de if rising_edge(Clk) garantit l'activation strictement sur le front montant de l'horloge.
• Dans un design synchrone, tous les changements d'état se produisent au front d'horloge actif.

Prêt à tester vos connaissances ? Passez le Quiz VHDL de Base - partie 3 ou continuez au tutoriel suivant.