Parcours d'apprentissage

Le parcours repose sur de petites réalisations concrètes. N'attendez pas de connaître tout le langage : chaque étape n'introduit que la syntaxe nécessaire au circuit suivant.

Étape 0 — Comprendre la cible

Objectif : distinguer exécution logicielle et description matérielle.

À comprendre :

• Les affectations concurrentes représentent du matériel fonctionnant en parallèle.
• Un processus cadencé représente des registres et la logique qui les alimente.
• Le temps de simulation n'est pas le temps réel de la carte.
• Le VHDL synthétisable est un sous-ensemble utile du langage.
• L'horloge Basys 3 vaut 100 MHz, donc sa période vaut 10 ns.

Réalisation : un interrupteur commande directement une LED.

Vérification : le banc de test modifie l'interrupteur puis vérifie automatiquement la LED.

Validation :

• Je peux expliquer ce qu'est un pilote de signal.
• Je distingue analyse, élaboration, simulation, synthèse, implémentation et programmation.

Étape 1 — Logique combinatoire

Objectif : décrire un circuit dont les sorties ne dépendent que des entrées présentes.

À apprendre :

• std_logic, std_logic_vector, unsigned et signed.
• Opérateurs booléens et comparaisons.
• Affectations conditionnelles et sélectionnées.
• Processus combinatoires complets avec process(all).
• Valeurs par défaut et raison pour laquelle une branche manquante infère un latch.

Réalisations :

1. Portes logiques.
2. Multiplexeurs 2-vers-1 et 4-vers-1.
3. Additionneur 4 bits avec retenue.
4. Décodeur hexadécimal pour afficheur sept segments.

Vérification :

• Tester exhaustivement les petits espaces d'entrée.
• Employer une fonction de référence pure pour les circuits plus grands.

Étape 2 — Logique séquentielle

Objectif : mémoriser un état de manière prévisible.

À apprendre :

• Registres sur front montant.
• Reset synchrone et validation d'horloge.
• Compteurs, registres à décalage et détecteurs de front.
• Sémantique des signaux : leur nouvelle valeur apparaît après la suspension du processus.
• Pourquoi on conserve généralement une horloge réelle et on génère des validations.

Réalisations :

1. Compteur affiché sur LED avec validation.
2. Impulsion d'un cycle sur un front de bouton.
3. Pilote multiplexé des quatre afficheurs.

Vérification :

• Centraliser horloge et reset.
• Vérifier les résultats par rapport aux fronts.
• Ajouter une limite de temps pour qu'un test bloqué ne tourne jamais indéfiniment.

Étape 3 — Structure et RTL réutilisable

Objectif : diviser la conception en blocs compréhensibles.

À apprendre :

• Instanciation directe d'entités.
• Génériques de largeur et de timing.
• Paquetages, sous-types, enregistrements, fonctions et procédures.
• Frontières nettes entre contrôle et chemin de données.
• Organisation des fichiers et conventions de nommage.

Réalisation : minuterie paramétrable composée d'un générateur de tick, d'un compteur et d'un afficheur.

Vérification : réutiliser des procédures d'horloge/reset et tester plusieurs valeurs de génériques.

Étape 4 — Machines à états et interfaces

Objectif : concevoir la logique de contrôle méthodiquement.

À apprendre :

• Diagrammes d'états et tables de transition.
• Sorties de Moore et de Mealy.
• Machines à un ou deux processus.
• Valeurs par défaut sûres et récupération après état illégal.
• Protocoles valid/ready et request/acknowledge.

Réalisation : contrôleur de feux ou petit émetteur UART.

Vérification :

• Contrôler les séquences de transitions légales.
• Parcourir chaque état et chaque transition.
• Séparer pilote, moniteur, scoreboard et DUT.

Étape 5 — Ingénierie FPGA réelle

Objectif : rendre les résultats de simulation fiables sur le matériel.

À apprendre :

• Propriétés de broches XDC et create_clock.
• Setup/hold, incertitude d'horloge, WNS et TNS.
• Métastabilité, synchroniseurs à deux bascules et traversées de domaines.
• Anti-rebond des boutons.
• Inférence des ressources, DSP, BRAM et fanout.
• Rapports DRC, utilisation, puissance et timing.

Réalisation : interface robuste utilisant boutons, interrupteurs, afficheur et UART.

Étape 6 — Vérification avancée

Objectif : produire des preuves reproductibles plutôt que de beaux chronogrammes.

À apprendre :

• Assertions auto-vérifiantes et modèles de référence.
• Vecteurs créés par Python ou un autre modèle.
• Stimulation aléatoire reproductible.
• Couverture fonctionnelle et scoreboards.
• Régressions et résultats lisibles par une machine.
• VUnit ou OSVVM lorsque la taille du projet le justifie.

Réalisation : une suite qui lance tous les tests en une commande et renvoie une erreur si une exigence est violée.

Proposition sur huit semaines

Semaine	Étude	Réalisation
1	Syntaxe et combinatoire	Portes, mux, décodeur
2	Types numériques et arithmétique	Additionneur/ALU paramétrable
3	Logique cadencée	Compteur et générateur de validation
4	Hiérarchie et paquetages	Sous-système d'affichage
5	Machines à états	Contrôleur avec anti-rebond
6	Automatisation des tests	Régression auto-vérifiante
7	XDC et timing	Conception implémentée sans échec
8	CDC et interfaces	UART ou petit projet multi-horloge

Méthode d'étude

Conservez quatre artefacts pour chaque circuit :

1. Spécification : interface, timing, reset et cas limites.
2. RTL : uniquement le circuit répondant à la spécification.
3. Banc de test : forme exécutable du comportement attendu.
4. Preuves : régression réussie et rapports de synthèse/timing.

Si une conception ne fonctionne qu'après inspection manuelle des chronogrammes avec des instants d'entrée choisis soigneusement, son test est incomplet. Transformez chaque bogue découvert en assertion ou en cas de régression.