VHDL avancé

Transtypage et sous-type

Le transtypage

Il réalise la conversion d'un type vers un autre type.

Exemple :
On veut utliser un type de la taille d'un octet (0 à 255). Pour cela on va déclarer ce nouveau type octet
type octet is range 0 to 255;
signal cpt : integer;
signal valeur : octet;
Le passage de l'entier à l'octet peut utiliser la transtypage :
octet <= octet(cpt);

Le sous-type

Le sous-type permet de déclarer un type qui est inclus dans un autre type, qui le rend compatible avec le type dans lequel il est inclus.

Exemple avec l'octet de 0 à 255
subtype octet is integer range 0 to 255;
signal cpt : octet;

Les fonctions et transtypages

Ces fonctions sont groupées dans le paquetage ieee.numeric_std

Les fonctions

• to_integer(u) conversion non signé vers entier avec u de type unsigned
• to_integer(s) conversion signé vers entier avec u de type signed
• to_unsigned(natural,taille) : conversion d'un entier positif vers un non signé avec taille qui représente le nobre de bits
• to_signed(entier,taille) : conversion d'un entier vers un signé avec taille qui représente le nobre de bits

Les transtypages

• std_logic_vector(u) : type non signé vers vecteur avec u de type unsigned
• std_logic_vector(s) : type signé vers vecteur avec s de type signed
• unsigned(v) : type vecteur vers non signé avec v de type std_logic_vector
• signed(v) : type vecteur vers signé avec v de type std_logic_vector

Structures logicielles

Les variables

Elles permettent de stocker des résultats intermédiaires ou encore être utilisées dans des boucles qui permettent de construire un circuit en répétant une structure élémentaire de ce circuit.

Les variables n'ont pas de réprésentation physique et ont un comportement uniquement séquentiel et non concurrent.

• Déclaration
  • process
  • procédures et fonctions
• Le symbole d'affectation est :=
• Elles utilisent tous les types de données

Elle sont déclarées avec le mot clé variable

Procédures

C'est un sous-programme qui ne possède pas de valeur de retour. Une procédure est déclarée dans une architecture ou une autre procédure ou une autre fonction. Les procédures n'ont pas de réprésentations physiques.

Syntaxe :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- contient les fonctions de conversion de type
use IEEE.NUMERIC_STD.ALL;
entity compteur is
Port ( clk : in STD_LOGIC;
         reset : in STD_LOGIC;
         en : in STD_LOGIC;
         tc : out STD_LOGIC;
         Q : out STD_LOGIC_VECTOR(3 downto 0));

end compteur;

architecture arch_compteur of compteur is
-- sous type quartet sur 4 bits
subtype quartet is natural range 0 to 15;
-- procédure qui ajoute 1 au signal de type quartet
procedure incrementer(signal c : inout quartet) is
begin
   c <= c + 1;
end procedure;
-- signal qui utilise le sous-type défini
signal cpt : quartet;
constant Nmax : natural := 9 ;
begin
-- conversion du quartet en vecteur
   Q <= std_logic_vector(to_unsigned(cpt,4));
   tc <= '1' when cpt = Nmax else '0';
   comptage: process(clk,reset)
   begin
      if reset='0' then
         cpt <= 0; -- cpt dérive d'entier
      elsif rising_edge(clk) and en ='1' then
         if cpt < Nmax then
            incrementer(cpt);
         else   
            cpt <= 0; -- cpt dérive d'entier
         end if;           
      end if;
   end process comptage;
end arch_compteur;

natural est un entier positif

La procédure ajoute 1 au paramètre qui est un paramètre utilisé en entrée et sortie, ce qui fait que la modification réalisée dans la procédure sera transmise au processus.

cpt n'est plus un vecteur mais un entier, ceci explique l'utilisation de la valeur 0 au lieu du vecteur de 0.

La sortie Q est un vecteur, il faut convertir l'entier cpt en vecteur. Il n'existe pas de fonction de conversion directe, il faut donc utiliser deux conversions, la premier vers un non signé et la deuxième vers un vecteur.

Fonctions

C'est un sous-programme qui possède une valeur de retour. Une fonction est déclarée dans une architecture ou une autre procédure ou une autre fonction. Les fonctions n'ont pas de réprésentations physiques.

Syntaxe :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- contient les fonctions de conversion de type
use IEEE.NUMERIC_STD.ALL;
entity compteur is
Port ( clk : in STD_LOGIC;
         reset : in STD_LOGIC;
         en : in STD_LOGIC;
         tc : out STD_LOGIC;
         Q : out STD_LOGIC_VECTOR(3 downto 0));

end compteur;

architecture arch_compteur of compteur is
-- sous type quartet sur 4 bits
subtype quartet is natural range 0 to 15;
-- procédure qui ajoute 1 au signal de type quartet
function incrementer(signal c : in quartet) return quartet is
variable valeur : quartet;
begin
   valeur := c + 1;
   return valeur;
end function;
-- signal qui utilise le sous-type défini
signal cpt : quartet;
constant Nmax : natural := 9 ;
begin
-- conversion du quartet en vecteur
   Q <= std_logic_vector(to_unsigned(cpt,4));
   tc <= '1' when cpt = Nmax else '0';
   comptage: process(clk,reset)
   begin
      if reset='0' then
         cpt <= 0; -- cpt dérive d'entier
      elsif rising_edge(clk) and en ='1' then
         if cpt < Nmax then
            cpt <= incrementer(cpt);
         else   
            cpt <= 0; -- cpt dérive d'entier
         end if;           
      end if;
   end process comptage;
end arch_compteur;

Les paquetages

Un paquetage permet de déclarer un ou plusieurs type de données avec les procédures et fonctions de traitement de ces nouveaux types ainsi que les fonctions de conversions

Un paquetage est composé de deux blocs qui sont l'entête qui contient les déclarations et le corps qui contient les codes des procedures et fonctions

Entête

package nom is
−− declarations
end nom;

Corps

package body nom is
−− codage des procédures et fonctions
end nom;

On propose d'écrire un paquetage qui contient la définition du type quartet ainsi que la procédure d'incrémentation et la fonction de conversion d'un quartet en vecteur de bits.

On ajoutera à ce paquetage la surcharge de l'opérateur + pour le quartet. La surcharge de l'opérateur + est simplement une fonction de nom "+" qu'il faut déclarer dans l'entête du paquetage et définir dans le corps du paquetage.

La duplication de circuit ou répétition spatiale

Cette structure de contrôle permet de créer un circuit en répétant une structure. Elle s'applique en dehors du processus.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- package qui permet d'écrire e = i
use IEEE.STD_LOGIC_UNSIGNED.ALL;
-- decodeur 3 vers 8
entity decodeur is
port ( e : in STD_LOGIC_VECTOR(2 downto 0);
      S : out STD_LOGIC_VECTOR(0 to 7));
end decodeur;

architecture architecture_decodeur of decodeur is
begin
-- i varie entre 0 et 7
   circuit: for i in 0 to 7 generate
   begin
-- le bit i de la sortie est affecté à 1
-- si l'entrée e est égal à la valeur i
      S(i) <= '1' when e = i else '0' ;
   end generate;
end architecture_decodeur;

Les autres structures de contoles

Celles-ci s'appliquent à l'intérieur des processus.

Les structures de contrôle dans les boucles

• Retour en début de boucle : next etiquette when expression booléenne VRAIE;
• Sortie de boucle : exit etiquette when expression booléenne VRAIE;

La généricité

Un composant générique est un composant qui est paramétrable, comme par exemple un décodeur de n vers 2ⁿ, ou encore un diviseur de fréquence par N

L'entité comprend, en plus, une instruction generic, la syntaxe de l'entité d'un composant générique est :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
-- package qui permet d'écrire e = i
use IEEE.STD_LOGIC_UNSIGNED.ALL;
-- decodeur 3 vers 8
entity decodeur is
generic ( n : integer := 3);
port ( e : in STD_LOGIC_VECTOR(n-1 downto 0);
      S : out STD_LOGIC_VECTOR(0 to 2**n-1));
end decodeur;

architecture architecture_decodeur of decodeur is
begin
-- i varie entre 0 et 2^n-1
   circuit: for i in s'range generate
   begin
-- le bit i de la sortie est affecté à 1
-- si l'entrée e est égal à la valeur i
      S(i) <= '1' when e = i else '0' ;
   end generate;
end architecture_decodeur;

Les valeurs obtenues en simulation confirment que le système fonctionne toujours.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use ieee.std_logic_unsigned.all;
-- fonctions mathématiques
use ieee.math_real.all;
-- diviseur par clkdiv
-- frequence tc = frequence clk / clkdiv
entity diviseur is
   Generic(clkdiv : integer := 2);
   Port ( clk : in STD_LOGIC;
         reset : in STD_LOGIC;
         tc : out STD_LOGIC);
end diviseur;

architecture architecture_diviseur of diviseur is
-- calcul du nombre de bits en fonction de la valeur maximale
   constant Nbits : natural := integer(ceil(log2(real(clkdiv+1))));
   signal cptdiv : std_logic_vector(Nbits downto 0);

begin
-- processus de compptage de 0 à clkdiv-1
-- pou diviser par clkdiv
   comptage: process(clk)
   begin
      if reset = '0' then
         cptdiv <= (others => '0');
      elsif rising_edge(clk) then
         if cptdiv < clkdiv-1 then
            cptdiv <= cptdiv + 1;
         else   
            cptdiv <= (others => '0');
         end if;
      end if;
   end process comptage;

   retenue: process(cptdiv)
   begin
      if cptdiv=clkdiv-1 then
         tc <= '1';
      else
         tc <= '0';
      end if;      
   end process retenue;

end architecture_diviseur;

On doit réaliser un diviseur de fréquence par clkdiv, cette valeur doit être représentée sur n bits avec la relation : clkdiv ≤ 2ⁿ-1. Mathématiquement, il s'agit de prendre le n ≥ log₂(clkdiv+1). Cela se calcule en utilisant les fonctions mathématiques su paquetage math_real avec la relation :
$Nbits=\lceil {\log }_2\left(clkdiv+1\right)\rceil$

Le reste du code est un compteur avec sortie de retenue sans sortie de comptage.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
-- compteur synchrone décimal
-- reset asynchrone
-- validation synchrone
-- sortie de retenue
entity compteur is
Port ( clk : in STD_LOGIC;
       reset : in STD_LOGIC;
       en : in STD_LOGIC;
       tc : out STD_LOGIC;
       Q : out STD_LOGIC_VECTOR(3 downto 0));
end compteur;

architecture arch_compteur of compteur is
-- declaration du composant diviseur
   component diviseur is
      Generic(clkdiv : integer := 2);
      Port ( clk : in STD_LOGIC;
             reset : in STD_LOGIC;
             tc : out STD_LOGIC);
   end component;

   signal endiv : STD_LOGIC ;
   signal cpt : STD_LOGIC_VECTOR (3 downto 0);
   constant Nmax : integer := 9 ;
begin
-- instanciation physique du composant diviseur
   chipdiviseur : diviseur generic map (clkdiv => 4)
                           port map( clk => clk, reset => reset,
                                     tc => endiv );
   Q <= cpt;
   tc <= '1' when cpt = Nmax else '0';
   comptage: process(clk,reset)
   begin
      if reset='0' then
         cpt <= (others => '0');
-- compteur synchronisé sur le diviseur avec endiv
      elsif rising_edge(clk) and en ='1'and endiv = '1' then
         if cpt < Nmax then
            cpt <= cpt + 1;
         else   
            cpt <= (others => '0');
         end if;           
      end if;
   end process comptage;
end arch_compteur;

La division de fréquence est précisée au moment de l'instanciation du composant et non dans la déclaration.

La période du compteur en sortie est bien 4 fois la période de l'horloge clk. On a bien un compteur avec division de fréquence par 4.

La gestion des fichiers

Affichage de messages d'erreur

Les structure assert et report permettent d'afficher des commentaires pendant la simulation

report seul affiche un message pendant la simulation

assert expression booléenne report message severity niveau

• Le message est affiché si l'expression booléenne est fausse
• severity représente le niveau d'affichage, il existe plusieurs niveaux de d'affichage :
  • note : pour information
  • warning : peut décléncher une erreur
  • error : valeur par défaut
  • failure : provoque l'arret du programme

Utiliser des diagrammes des temps pour afficher les résultats de la simulation est bien, mais quelques fois, comme en combinatoire, une table de vérité est suffisante. Pour cela, on va maintenant étudier, l'écriture des résultats dans des fichiers textes.

Entrée (clavier) et sortie standard (écran)

Il faut inclure les paquetages std.textio et ieee.std_logic_textio

Affichage écran

Lecture de données depuis le clavier

Dans le programme présédent, il faut compiler pour chaque nouvelle valeur, on propose, ici, de demander à l'utilisateur de saisir la valeur. On va donc utiliser les fonctions de lecture de données à partir de l'entrée standard qui est le clavier qui se fait également en deux étapes

Accès aux fichers

L'accès au fichier utilise un identificateur de fichier (handle) qui est de type file. Un type fichier est défini avec la syntaxe :
type nom du type is file of type de l'élément
le type de l'élément est un type de donnée connu ou bien défini avec la syntaxe type

Il existe un type de fichier prédéfini de type fichier texte : text

Ensuite on déclare une variable avec de type, le nom de la variable est l'indentificateur de fichier qui sera utilisé à la place de output dans writeline et à la place de input dans readline.

La fonction d'ouverture, open, assigne cet identificateur au fichier représenté par son nom. La fonction de fermeture, close, annule cette assignation en vidant les buffers d'échange de données.

L'accès au contenu d'un fichier commence obligatoirement par l'ouverture, effectue l'échange des données, et se termine obligatoirement par la fermeture.

Ouverture

Elle est réalisé avec la fonction :
file_open(statut,idfichier,nom du fichier,mode accès) avec

• statut qui fournit le résultat de l'ouverture et qui vaut
  OPEN_OK, STATUS_ERROR, MODE_ERROR, NAME_ERROR
• idfichier : identificateur représentée par une variable de type de fichier défini
• nom du fichier : nom du fichier entre guillemets à écrire ou lire sur le disque
• mode d'accès qui vaut :
  READ_MODE, WRITE_MODE, APPEND_MODE

Fermeture

Elle se fait avec la fonction file_close(idfichier)

Ouverture implicite

Elle se fait avec la déclaration des variables avec la syntaxe
file idfichier : nom du type open mode d'accès is nom du fichier;

Fermeture implicite

Elle se fait automatiquement en fin de processus

Exemple

On utilise les fichiers pour enregister les résultats de simulation sous la forme d'une table de vérité dans un fichier texte. On applique ce principe au décodeur.

Si on veut encore plus de codes, comme des codes de mémoire, processeur, interface, ... , on peut consulter le site dédié opencores.

Générateur de valeurs binaires en VHDL

Le code VHDL qui suit est celui d'un générateur de valeurs pseudo-aléatoires en utilisant le corps de Galois comme cela a déjà été présenté dans le chapitre logique séquentielle.