Comprendre les fondements de la syntaxe Vhdl et la structure des débutants

Mots clés et identifiants réservés

VHDL définit un ensemble de mots-clés réservés qui ne peuvent pas être utilisés comme identifiants d'utilisateur (p. ex., ) entité, architecture, signal, port, commencement, fin, processus, fonction, variable, constante, si, alors, dans le cas contraire, pour, pendant . Les identifiants doivent commencer par une lettre et peuvent contenir des lettres, des chiffres et des soulignements. Ils ne peuvent se terminer par un soulignement ou avoir deux soulignements consécutifs. Exemple d'identificateurs valides : , , .

Commentaires

Les commentaires dans VHDL sont désignés par deux tirets consécutifs . Tout après sur la même ligne est ignoré par le compilateur. Les commentaires multi-lignes ne sont pas officiellement pris en charge, mais vous pouvez les simuler en plaçant au début de chaque ligne. Les commentaires sont critiques pour documenter l'objet des signaux, des ports et des processus.

Déclarations et semi-colons

Chaque énoncé de la VHDL se termine par un point-virgule (). Cela comprend les déclarations d'entité, les organismes d'architecture, les attributions de signaux, les déclarations de processus et les attributions de signaux simultanées. L'émission d'un point-virgule est l'une des erreurs les plus courantes chez les débutants. De plus, la VHDL utilise des tirets doubles[ pour les commentaires et des guillemets simples[ pour les caractères littéraux (par exemple, , ) par rapport aux guillemets doubles pour les chaînes (par exemple, .

Composantes de base de la VHDL : Entité, architecture, signaux et processus

Pour concevoir quelque chose dans VHDL, vous devez comprendre quatre éléments de construction fondamentaux : entités[, architectures[, signales[, et process. Chaque conception est essentiellement une boîte noire (entité) avec une description interne détaillée (architecture) qui utilise des signaux pour filer des composants et des processus pour décrire la logique séquentielle ou combinée.

Entité : L'interface de la boîte noire

Une entité déclare l'interface externe d'un composant matériel. Elle spécifie tous les ports [ — les entrées et sorties — ainsi que leur direction (in, out, inout) et leur type de données. L'entité ne décrit aucune logique interne; elle ne dit qu'au monde extérieur comment se connecter au composant.

entity and_gate is
 port (
 a : in std_logic;
 b : in std_logic;
 y : out std_logic
 );
end entity and_gate;

Dans cet exemple, l'entité possède trois ports : deux entrées (, ) et une sortie ([), tous de type . Le type est un système logique standard à neuf valeurs défini dans le paquet . C'est le type le plus couramment utilisé pour les signaux numériques parce qu'il supporte des valeurs comme , , ] (haute impédance), (inconnu), et plus encore.

Les entités peuvent également inclure generics pour rendre le design paramétrable. Par exemple, vous pouvez définir un générique qui contrôle la largeur d'un bus. C'est un sujet plus avancé mais qui mérite d'être noté tôt.

Architecture : La mise en œuvre interne

Une architecture définit le comportement réel de l'entité. Elle peut être écrite en plusieurs styles : comportement (en utilisant des processus et des instructions séquentielles), structurel[ (en installant des composants de niveau inférieur), ou dataflow[ (en utilisant des assignations de signaux concurrentes).Chaque architecture est associée à une entité spécifique, et plusieurs architectures peuvent exister pour la même entité (p. ex., une pour la simulation, une pour la synthèse).

L'architecture commence par le mot clé , suivi du nom de l'architecture, du mot clé , du nom de l'entité et . Puis viennent les sections de déclaration (pour les signaux, les constantes, les composants) et enfin le mot clé , suivi des déclarations concurrentes. L'architecture se termine par ou .

architecture behavioral of and_gate is
begin
 y <= a and b;
end architecture behavioral;

Ici, l'attribution de signal unique simultanée conduit en continu la sortie. VHDL étant intrinsèquement concurrente, cette ligne tourne à jamais, mettant à jour chaque fois que ou change. C'est l'essence de la description matérielle : les instructions s'exécutent en parallèle, pas séquentiellement comme un logiciel.

Signal : les fils qui relient tout

Les signaux représentent les fils physiques, les bus ou les nœuds internes d'un circuit. Ils sont déclarés dans la section de déclaration architecture (ou dans les paquets, les entités ou les blocs). Les signaux doivent être attribués à l'opérateur , qui est l'opérateur d'assignation de signaux (différent de l'assignation de variables ).

signal internal_net : std_logic;
…
internal_net <= a and b; -- concurrent assignment
y <= internal_net;

Les signaux peuvent être de n'importe quel type de données — , , , , etc. L'utilisation de pour les autobus est courante : . L'utilisation de par rapport à ] affecte la commande de bits.

Processus : Description du comportement séquentiel

Un processus[ est un bloc d'instructions séquentielles qui s'exécutent en réponse aux changements de signaux dans sa liste de sensibilité. À l'intérieur d'un processus, vous pouvez utiliser , , , boucles et assignations variables. Cela vous permet de modéliser la logique séquentielle comme les flower-flops, les compteurs et les machines d'état. Chaque processus introduit également un concept de cyclesdelta et déclarations d'attente[ pour le contrôle de la synchronisation.

Une simple tond-flop de type D avec réinitialisation asynchrone peut être écrite comme suit:

process (clk, rst) is
begin
 if rst = '1' then
 q <= '0';
 elsif rising_edge(clk) then
 q <= d;
 end if;
end process;

La liste de sensibilité indique au simulateur de réveiller ce processus chaque fois que ou change. Dans le processus, la nature séquentielle signifie que les énoncés sont évalués dans l'ordre — mais les attributions de signaux utilisent toujours ] et mettent à jour après la suspension du processus, ce qui explique pourquoi la modélisation du processus nécessite des précautions pour éviter les verrouillages involontaires.

Exemple de structure de la VHDL : un design complet

Let , tout est assemblé avec un exemple plus détaillé : un multiplexeur 2-to-1 (MUX) avec une ligne sélectionnée. Cette conception montre comment utiliser des entités, architectures, signaux et processus dans un seul fichier. Le MUX sélectionne entre deux entrées 8-bit basées sur une seule ligne sélectionnée.

-- 8-bit 2-to-1 Multiplexer
library ieee;
use ieee.std_logic_1164.all;

entity mux2to1 is
 port (
 a, b : in std_logic_vector(7 downto 0);
 sel : in std_logic;
 y : out std_logic_vector(7 downto 0)
 );
end entity mux2to1;

architecture behavioral of mux2to1 is
begin
 process (a, b, sel) is
 begin
 if sel = '0' then
 y <= a;
 else
 y <= b;
 end if;
 end process;
end architecture behavioral;

Ce code introduit plusieurs nouveaux concepts:

• Les clauses de bibliothèque et d'utilisation[: et ] sont requises en haut de chaque fichier de conception qui utilise ou . La bibliothèque spécifie une bibliothèque de conception, et la clause d'utilisation porte la portée du paquet.
• Ports de vecteur: Les entrées et sont — un bus de 8 bits. La sortie est de la même largeur.
• Processus avec plusieurs entrées: La liste de sensibilité comprend , et parce que la sortie dépend des trois.
• Si l'instruction dans le processus : Le est une instruction séquentielle qui ne peut apparaître qu'à l'intérieur d'un processus ou d'un sous-programme.

Cet exemple est synthétisé (peut être transformé en matériel réel) car la logique est purement combinée. Le processus décrit un MUX, que chaque outil de synthèse reconnaît.

Règles clés de la syntaxe VHDL Chaque débutant doit savoir

Au-delà des composants de base, VHDL a plusieurs règles syntaxiques qui éloignent les nouveaux venus de la garde. Maîtriser ces tôt permettra d'économiser des heures de débogage.

1. Forte typage

VHDL est fortement tapé[, ce qui signifie que vous ne pouvez pas attribuer directement un signal d'un type à un autre même s'ils semblent similaires (par exemple, à ). Vous devez utiliser des fonctions de conversion de type (, , etc.) ou être explicitement moulé avec . Cette rigueur empêche les erreurs accidentelles et rend les conceptions plus robustes.

2. La différence entre et (concurrent vs séquentiel)

En dehors d'un processus, vous pouvez utiliser un assignation conditionnelle de signal [ avec :

y <= a when sel = '0' else b;

Cela est équivalent au MUX antérieur basé sur le processus, mais n'est pas séquentielle — c'est une seule déclaration concurrente. Les débutants confondent souvent (séquentielle) avec (concurrent). En règle générale: est autorisé uniquement les processus, fonctions et procédures internes; est utilisé pour les affectations simultanées de signaux.

3. Attribution de signaux par rapport à l'attribution de variables

Dans un processus, vous pouvez déclarer variables en utilisant le mot clé . Les variables sont assignées avec et mises à jour immédiatement (dans le même cycle de simulation). Ceci contraste avec les signaux qui utilisent et mise à jour seulement après que le processus suspend. L'utilisation de signaux à l'intérieur d'un processus peut conduire à un comportement non intentionnel si vous lisez un signal après l'avoir assigné dans le même processus — la lecture verra l'ancienne valeur jusqu'au prochain cycle delta.

process (clk) is
 variable temp : std_logic;
begin
 if rising_edge(clk) then
 temp := a and b; -- variable updates immediately
 y <= temp; -- signal updates after process suspension
 end if;
end process;

4. L'idiome de détection des bords de l'horloge

Pour modéliser un registre (flipp-flop), vous devez détecter un bord montant ou tombant d'une horloge. La façon standard est d'utiliser ou du paquet , qui gère correctement les valeurs X et Z. Never use — il peut se comporter différemment dans la simulation par rapport à la synthèse.

5. Déclarations d'attente et listes de sensibilité

Un processus peut avoir soit une liste de sensibilité ou contenir des instructions , mais pas les deux. Pour la synthèse, les listes de sensibilité sont la norme. La liste doit inclure chaque signal lu dans le processus (sauf s'il s'agit d'un processus à horloge, auquel cas il suffit d'activer une réinitialisation/une réinitialisation asynchrone).

6. Carte de port et activation des composants

Lorsque vous construisez des modèles hiérarchiques, vous inoccassez des composants de niveau inférieur en utilisant . La syntaxe relie les signaux internes aux ports entity. Par exemple, inoccasion du MUX précédent:

u_mux : entity work.mux2to1
 port map (
 a => data_a,
 b => data_b,
 sel => select_line,
 y => mux_out
 );

Le est appelé l'opérateur d'association de carte de port.Le côté gauche est le nom du port de l'entité en cours d'instantané, et le côté droit est le signal local. Vous pouvez également utiliser la cartographie positionnelle, mais la cartographie nommée est plus sûre et plus lisible.

Techniques intermédiaires pour les débutants à explorer

Une fois à l'aise avec les bases, vous pouvez commencer à explorer d'autres constructions VHDL qui rendent les conceptions plus puissantes et réutilisables.

Utilisation de génériques pour les conceptions paramétrées

Génériques vous permettent de passer des constantes dans une entité, rendant le design évolutive sans réécrire de code. Par exemple, un MUX générique N-bit:

entity generic_mux is
 generic (
 WIDTH : positive := 8
 );
 port (
 a, b : in std_logic_vector(WIDTH-1 downto 0);
 sel : in std_logic;
 y : out std_logic_vector(WIDTH-1 downto 0)
 );
end entity;

Lorsque vous instanciez, vous pouvez passer outre par la carte générique :

generic map (WIDTH => 16)

Comprendre les énoncés concomitants et séquentiels

La VHDL comporte deux grandes catégories d'énoncés :

• Exécuter en même temps, en parallèle. Ils comprennent des assignations de signaux simples (), des assignations de signaux conditionnelles (), des actuations de composants et des assignations de génération.
• Les énoncés de titres: Exécuter l'un après l'autre, à l'intérieur d'un processus, d'une fonction ou d'une procédure, y compris , , , et l'attribution de variables.

architecture rtl of fsm is
 type state_type is (idle, run, done);
 signal state, next_state : state_type;
begin
 -- Sequential register
 process (clk, rst) is
 begin
 if rst = '1' then
 state <= idle;
 elsif rising_edge(clk) then
 state <= next_state;
 end if;
 end process;

 -- Next-state logic
 process (state, input) is
 begin
 next_state <= state; -- default to prevent latches
 case state is
 when idle =>
 if input = '1' then
 next_state <= run;
 end if;
 when run =>
 if input = '0' then
 next_state <= done;
 end if;
 when done =>
 next_state <= idle;
 end case;
 end process;
end architecture;