Cours en ligne VHDL

Préambule

Objectifs

Plan du chapitre

• Instructions concurrentes et séquentielles
  VHDL utilise aussi bien les 2 types pour coder le comportement d'un circuit. Quelle différence ?
  
  
• Processus et synchronisation
  Comment démarrer un processus ?
  
  
• Variables et signaux
  Comment utiliser ces 2 types d'objets dans un processus ?
  
  
• Stuctures de contrôle
  Là où vhdl rejoint le C.
  
  
• Affectations concurrentes
  Comment écrire une équation sans passer par un processus ?
  
  
• Affectations et délais
  Pour modéliser le temps. Attention, piège.
  
  
• Assertions
  Comment vérifier une propriété et envoyer un message associé en cours de simulation ?
  
  
• Sous-programmes
  Comment créer des fonctions et des procédures ?
  
  
• Fonctions de résolution
  Quelle valeur prend un signal affecté dans plusieurs processus ?
  
  
• Résumé

INSTRUCTIONS CONCURRENTES ET SEQUENTIELLES

Comme tout langage de description de matériel, le VHDL décrit des structures par assemblage d'instructions concurrentes dont l'ordre d'écriture n'a aucune importance, contrairement aux instructions séquentielles qui sont exécutées les unes après les autres, comme c'est la cas du C.

VHDL offre cependant la possibilité d'utiliser des instructions séquentielles, plus naturelles pour l'homme, par le biais de processus process. Les processus peuvent avoir leurs propres variables locales variable . 

Les objets manipulés par les instructions concurrentes sont les signaux signal qui disposent chacun d'un échéancier de façon à effectuer une simulation d'instructions concurrentes sur une machine séquentielle (l'ordinateur).

Il existe 3 principales instructions concurrentes :

1. Les processus, qui offrent la possibilité d'utiliser des instructions séquentielles.
2. Les instanciations de composants (étudiées aux chapitre précédent à propos du VHDL structurel)
3. les affectations concurrentes de signaux, qui peuvent être conditionnelles

Processus et synchronisation

 Les différentes tâches d'un programme vhdl s'exécutent en parallèle les unes des autres. Ces tâches sont appelées processus. Toutes les instructions concurrentes sont en fait des processus mais la déclaration explicite de processus par le mot clé process permet de construire sa propre instruction par le biais d'instruction séquentielles internes au processus. Un processus peut avoir des variables locales. Le fonctionnement du processus est régi par les règles suivantes :

1. Un processus est une boucle infinie , lorsqu'il arrive à la fin du code, il reprend automatiquement au début 
2. Un processus doit être sensible des points d'arrêt de façon à le synchroniser.  La synchronisation est donc indiquée par un point d'arrêt qui est  évènement particulier. Il existe 2 types de points d'arrêts :
• Le processus est associé à une "liste de sensibilité" qui contient une liste de signaux qui réveillent le processus lors d'un changement d'un des signaux. Sa syntaxe est process(liste de signaux)
• Le processus a des instructions d'arrêt wait dans sa description interne. Le wait est sensible soit à un signal soit à un temps physique
3. Les variables sont internes au processus et sont affectées immédiatement, contrairement aux signaux qui eux ne sont pas affectés directement mais par le biais de leur échéancier qui est mis à jour en fin de processus avec la nouvelle valeur et le temps d'affectation qui correspond à un delta-cycle après le signal ayant réveillé le processus.
   

Synchronisation des processus par WAIT

trame : process -- le processus peut avoir une étiquette, ici "trame"
  -- il n'y a pas de liste de sensibilité donc il faut des "wait"
	pulse <= '0'; -- pulse est à 0 en début de trame
for i in 0 to 9 loop -- on génère 10 impulsions larges de 2 périodes d'horloge
	wait until clk'event and clk='1';
	pulse <= '1';
  wait until clk'event and clk='1'
	pulse <= '0';
end loop;
	wait for 100 us; -- après 100 us on reprend le process donc pulse va repasser à 0
end process;

Exercice :

Ecrivez un processus permettant de générer un train d'impulsions toutes les microsecondes : pas d'impulsion, puis une impulsions de100 ns puis une impulsions de 200ns, jusqu'à 1 microseconde comme le montre la figure ci-dessous.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
--
entity test1 is
end entity;
--
architecture toto of test1 is
--
signal pulse : std_logic;
constant n  : positive := 10;  -- durée de base
begin
--
--
  boucle : process
--  variable pulse : std_logic;
  begin
  loop1: for i in 0 to n loop
      pulse <= '1';
      wait for i*100 ns;
      pulse <= '0';
      wait for (n-i)*100 ns;
  end loop;
--  puls <= pulse;
  end process;
--
end toto;

Synchronisation des processus par liste de sensibilité

process(x,y)
begin
if x='1' then
	z<=y;
else
	z<='0';
end if;
end process;
--

•  la liste de sensibilité contient TOUTES les entrées, sinon la fonctionnalité n'est pas respectée car l'entrée omise  ne réveille pas le processus
•  Il faut traiter TOUS les cas dans le chemin de contrôle, sinon il y a implicitement mémorisation de la sortie pour les cas non traités

Si ces règles ne sont pas respectées, le processus est séquentiel.

• Que se passe t'il si y est omis de la liste de sensibilité ? Afficher la réponse

Réponse :

Le processus n'est exécuté que si x change. Si c'est un front montant la sortie prend la valeur de y et si c'est un front descendant la sortie passe à 0. Cela correspond à une bascule un peu spéciale qui n'a pas beaucoup d'utilité.


• Que se passe t'il si la ligne else z <='0' est omise ? Afficher la réponse

Réponse :

Si x='0' , la sortie est gelée, alors que si x='1' la sortie prend la valeur de y. Ce comportement correspond à une bascule sur état ou "latche".


• Codez la fonction multiplexeur à 2 entrées :
• avec les opérateurs logiques Afficher la réponse

Réponse :

s <= (a and sel) or (b and not(sel));



• avec un processus combinatoire Afficher la réponse

Réponse :

if (sel = '1') then
	s <= a;
else
	s <= b;
end if;
--

Pour fiabiliser le processus séquentiel , nous avons vu qu'il était fortement recommandé de fonctionner en mode synchrone, c'est à dire avec l'utiliation d'un horloge qui échantillonne le calcul. Autrement dit un processus séquentiel synchrone a une liste de sensibilité qui se réduit simplement à l'horloge. Les signaux codés dans ce processus seront donc des sorties de bascule D.
S'il est impératif d'initialiser les bascules (cas des machines à états), le reset asynchrone peut être employé. Dans ce cas il faut le rajouter dans la liste de sensibilité car il est prioritaire sur l'horloge quand il est actif. La syntaxe générique d'un bloc de logique séquentiel est donc la suivante:

process(clk, n_reset)
--
begin
if n_reset='0' then
	sortie <= (others=>'0'); -- tous les bits de sortie sont initialisés à 0 par le reset
elsif clk'event and clk='1' then
	liste d'instructions codant "sortie"
end if;
end process;
--

Exercice : 

• Donnez une description d'une bascule D possédant un reset synchrone (qui remet la bascule à zéro s'il est à l'état bas lors d'un front montant de l'horloge)
  [Afficher la réponse]

Réponse :

process(clk)
begin
if clk'event and clk='1' then
	if n_reset='0' then
		sortie <= (others => '0');	-- sortie est un vecteur de bits initialisés à '0'
	else
		liste d'instructions codant "sortie"
end if;
end process;

SIGNAUX vs variables

Les signaux sont équivalents à des variables globales assurant les communications entre processus. Ils sont équivalents à des équipotentielles si le code est synthétisable. Les signaux ne sont pas mis à jour tout de suite mais à la fin du processus avec un delta-cycle de retard par rapport au signal ayant déclenché le processus. Les signaux sont affectés avec l'instruction <= qui se dit aussi "reçoit"  plutôt que "égal" car le signal va recevoir cette valeur en fin de processus avec un delta-cycle de retard.   

Les variables sont locales à chaque processus et sont mises à jour immédiatement.  Elles sont très utiles pour effectuer un codage séquentiel classique comme avec le langage C. Les variables sont déclarées juste avant le corps du processus et sont affectées avec l'instruction d'affectation immédiate := de façon à bien ne pas confondre avec l'instruction <= "reçoit" pour les signaux. Les variables gardent leur valeur quand le processus est terminé.

Dans l'exemple suivant, a,b,c sont des signaux et x une variable. Enfin de processus, a et b vont prendre la valeur a+1 après un delta-cycle alors que c prendre la valeur a après un delta-cycle.

process (a)
variable x : std_logic;
begin
	x := a+1;
	a <= a+1;
	b <= x;
	c <= a;
end if;
end process;
--

process(a,b)
variable t : std_logic;
begin
	t := a*b;
	if (t > c) then
			s <= c;
	else
			s <= t;
end process;

Structures de contrôle

Dans les processus, il est possible d'utiliser des structures de contrôle similaires à celles du C :

• les instructions de test (if, case)
• les boucles (loop, for loop, while loop)

Instruction IF  

L' instructions IF reposent sur le test d'une  condition qui génère un booléen. Si celui ci est "TRUE"  l'instruction qui suit est exécutée

Syntaxe du IF:

if condition1 then instruction;
[elsif condition2 then instruction;]
...
[else instruction;]
end if;

Pour coder un processus combinatoire, l'utilisation du ELSE est obligatoire de façon à traiter toutes les combinaisons (sinon il y a mémorisation donc c'est da la logqiue séquentielle)

Instruction CASE

Syntaxe du CASE :

case A is
  when -7 =>     B := 10;
                 C :='0'
  when -3 =>     B :=15;
                 C :='0';
  when others => B :=2;
                 C :='1';
end case;

Pour coder un processus combinatoire, l'utilisation du when others est obligatoire de façon à traiter toutes les combinaisons (sinon il y a mémorisation donc c'est da la logqiue séquentielle)

Instruction de boucle

L1: for i in 0 to 10 loop
    ...
    L2: loop
        ...
        L3 : while non _stop_L3 loop
            ...
            exit L2 when stop_L2;
      next L3 when suite_L3;
            if stop_L1 then
                    exit L1;
            end if;
        end loop L3;
    end loop L2;
end loop  L1;

1. Les indices de boucles (ici i pour L1) ne sont pas à déclarer
2. Les étiquettes de boucles (L1,L2,L3) sont optionnelles
3. L'excution peut être altérée avec les clauses next et exit

 Exemple : la boucle loop de cet exemple permet de compter le nombre de bits à 1 d'un signal.

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
--
entity nb_un is
	port
	(
	a : in unsigned(7 downto 0);
	s : out  unsigned(3 downto 0)
);
end entity;
--
architecture rtl of nb_un is
begin
process(a)
variable x : unsigned (3 downto 0);
begin
x:= (others => '0');
for i in 0 to 7 loop
	x := x + ('0' & a(i));
end loop;
s <= x;
end process;
end rtl;

 Exercice : Ecrivez un processus calculant la parité d'un signal sur n bits.

use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity parity is
    generic
	(
	n : natural := 8
	);
	port
	(
	a : in unsigned(n-1 downto 0);
	p : out std_logic
	);
end entity;
--
architecture rtl of parity is
begin
process(a)
variable x : std_logic;
begin
	x:= '0';
	for i in 0 to n-1 loop
		x := x xor a(i);
	end loop;
	p <= x;
end process;
end rtl;

Affectations CONCURRENTES DE SIGNAUX

architecture arc of adder is
begin
process(A,B,Cin)
begin
   S <= A xor B xor Cin;

architecture arc of adder is
begin
    S <= A xor B xor Cin;
end arc;

Affectation concurrente conditionnelle

architecture arc of adder is
begin
process(A,B,Cin)
  begin
  if A = '0' then
    S <= B xor Cin;
  elsif B = '0' then
    S <= not(Cin);
  else
    S <= Cin;
  end if;
end process;
end arc;

architecture arc of adder is
begin
S <= B xor Cin when A = '0' else
     not Cin when B = '0' else
     Cin;

architecture arc of MUX is
begin
process(SEL)
begin
  case SEL is
    when 0 =>
      sortie <= A;
    when 1 =>
      sortie <= B;
    when 2 =>
      sortie <= C;
    when others =>
      sortie <= D;
  end case;
end process;
end arc;

architecture arc of MUX is
begin
with SEL select
  sortie <= A when 0,
            B when 1,
            C when 2,
            D when others;
end arc;

Affectations et délais

VHDL permet de spécifier des délais dans les affectations. 

Il existe deux types d'affectations avec délai :

• affectation avec délai inertiel :  x <= 3 after 2 ns; ou plus explicitement x <= inertial 3 after 2 ns;
• affectation avec délai de transport : x = transport 3 after 2 ns;

ASSERTIONS

assert NOW < 10 ms -- NOW est une fonction renvoyant le temps physique
    report "Fin de simulation"
    severity failure

SOUS-PROGRAMMES

IL existe 2 types de sous-programmes:

1. Les fonctions
2. Les procédures

Exemples :

Fonction de calcul de minimum et maximum en procédure.

procedure MinMax( a,b : in unigned (7 downto 0);
 min : out unsigned(7 downto 0);
	max : out unsigned(7 downto 0)) is
begin
 if (a < b) then 
	min <= a;
	max <= b;
else
	min <= b;
	max <= a;

end if;
end procedure MinMax;
 

MinMax(x, y, z, t);

Il faut 2 fonctions min et max pour avoir léquivalent en fonction. Voici l'exemple de min :

Exercices :

function min (a,b : unsigned(7 downto 0)
 return unsigned(7 downto 0) is 
 varaiable min : unsigned(7 downto0);
 begin
if (a < b) then 
	min := a;
else
	min := b;
end if;
return min;
endfunction

...

z := min(x, y);

Trouvez le code de la fonction comptant le nombre de bits à 1 dans un nombre de 8 bits.