Guide Quartus - VHDL pour FPGA

📚 Introduction

Intel Quartus Prime est l'environnement de développement intégré (IDE) pour la conception de circuits numériques sur FPGA (Field-Programmable Gate Array) Intel. Ce guide vous accompagne dans l'installation, la création de projets VHDL et la programmation d'un FPGA avec un exemple pratique de compteur.

🎯 Objectifs de ce guide :

Installer Quartus Prime Lite (gratuit)
Créer et configurer un projet VHDL
Concevoir un compteur 4 bits en VHDL
Compiler et simuler le design
Programmer le FPGA

💾 Installation de Quartus Prime Lite

Étape 1 : Téléchargement

Accéder au site Intel
Rendez-vous sur : https://www.intel.com/content/www/us/en/software/programmable/quartus-prime/download.html

Choisir la version
Sélectionnez Quartus Prime Lite Edition (gratuite) pour votre système d'exploitation (Windows/Linux)

Sélectionner les composants
Téléchargez les fichiers suivants :

Quartus Prime Lite (fichier principal)
ModelSim-Intel FPGA Starter Edition (simulateur)
Device support files pour votre famille de FPGA (Cyclone V, MAX 10, etc.)

⚠️ Attention : Le téléchargement peut être volumineux (plusieurs Go). Assurez-vous d'avoir suffisamment d'espace disque (au moins 20 Go libres) et une bonne connexion Internet.

Étape 2 : Installation

Lancer l'installateur
Exécutez le fichier d'installation téléchargé (QuartusLiteSetup-xx.x.x.exe pour Windows)

Accepter la licence
Lisez et acceptez les termes de la licence Intel

Choisir le répertoire d'installation
Chemin par défaut : C:\intelFPGA_lite\xx.x (Windows)

Sélectionner les composants
Cochez :

✅ Quartus Prime
✅ ModelSim - Intel FPGA Starter Edition
✅ Devices (sélectionnez votre famille de FPGA)

Installer
Cliquez sur "Next" et attendez la fin de l'installation (peut prendre 30-60 minutes)

✅ Installation réussie ! Vous pouvez maintenant lancer Quartus Prime depuis le menu Démarrer.

📁 Création d'un Projet VHDL

Démarrer un nouveau projet

Lancer Quartus Prime
Ouvrez l'application depuis le menu Démarrer ou le bureau

New Project Wizard
Allez dans : File → New Project Wizard

Introduction
Cliquez sur "Next" dans la page d'introduction

Directory, Name, Top-Level Entity

Working directory : Choisissez un dossier pour votre projet (ex: C:\FPGA_Projects\Compteur)
Project name : compteur_4bits
Top-level entity : compteur_4bits (même nom que le projet)

Cliquez sur "Next"

Project Type
Sélectionnez "Empty project" → "Next"

Add Files
Laissez vide pour l'instant (nous créerons les fichiers après) → "Next"

Family, Device & Board Settings
Sélectionnez votre FPGA cible :

Family : Cyclone V (exemple) ou selon votre carte
Device : Choisissez le modèle exact (ex: 5CSEMA5F31C6)

💡 Astuce : Le numéro exact du FPGA est généralement écrit sur la puce ou dans la documentation de votre carte de développement.

EDA Tool Settings
Pour la simulation, sélectionnez :

Simulation : ModelSim-Altera
Format : VHDL

"Next"

Summary
Vérifiez les paramètres et cliquez sur "Finish"

🎉 Projet créé avec succès ! Vous êtes maintenant prêt à ajouter votre code VHDL.

🔢 Exemple : Compteur 4 Bits en VHDL

Spécifications du compteur

📋 Fonctionnalités :

Compteur binaire 4 bits (compte de 0 à 15)
Signal d'horloge (CLK)
Signal de reset asynchrone (RESET)
Signal d'activation (ENABLE)
Sortie sur 4 bits (COUNT)

Schéma Fonctionnel du Compteur

                    ┌─────────────────────────────────┐
                    │                                 │
           CLK ────┤►                                │
                    │                                 │
         RESET ────┤►    COMPTEUR 4 BITS             │
                    │                                 │
        ENABLE ────┤►                                │
                    │                                 ├────► COUNT[3:0]
                    │    (0 → 1 → 2 → ... → 15 → 0)  │
                    │                                 │
                    └─────────────────────────────────┘

Création du fichier VHDL

Créer un nouveau fichier
File → New → VHDL File

Sauvegarder le fichier
File → Save As → Nommez-le : compteur_4bits.vhd

Copier le code suivant

📄 compteur_4bits.vhd

---------------------------------------------------------------
-- Compteur 4 bits avec RESET et ENABLE
-- Fichier: compteur_4bits.vhd
-- Auteur: BTS Électronique
-- Description: Compteur binaire synchrone 4 bits
---------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

-- Déclaration de l'entité
entity compteur_4bits is
    Port (
        CLK    : in  STD_LOGIC;              -- Signal d'horloge
        RESET  : in  STD_LOGIC;              -- Reset asynchrone (actif haut)
        ENABLE : in  STD_LOGIC;              -- Signal d'activation
        COUNT  : out STD_LOGIC_VECTOR(3 downto 0)  -- Sortie 4 bits
    );
end compteur_4bits;

-- Architecture du compteur
architecture Behavioral of compteur_4bits is
    signal count_internal : UNSIGNED(3 downto 0) := "0000";
begin

    -- Processus synchrone
    process(CLK, RESET)
    begin
        if RESET = '1' then
            -- Reset asynchrone : remise à zéro
            count_internal <= "0000";
            
        elsif rising_edge(CLK) then
            -- Sur front montant de l'horloge
            if ENABLE = '1' then
                -- Incrémentation du compteur
                count_internal <= count_internal + 1;
            end if;
        end if;
    end process;
    
    -- Affectation de la sortie
    COUNT <= STD_LOGIC_VECTOR(count_internal);
    
end Behavioral;
                

Explication du code

Section	Description
Libraries	IEEE.STD_LOGIC_1164 : types de données standard IEEE.NUMERIC_STD : opérations arithmétiques sur UNSIGNED
Entity	Définit les entrées/sorties du composant CLK, RESET, ENABLE (entrées) et COUNT (sortie)
Architecture	count_internal : signal interne de type UNSIGNED pour faciliter l'incrémentation
Process	Sensible à CLK et RESET RESET asynchrone (prioritaire) Incrémentation sur front montant de CLK si ENABLE='1'
Conversion	UNSIGNED → STD_LOGIC_VECTOR pour la sortie

🧪 Testbench (Fichier de Simulation)

Un testbench permet de simuler le comportement du compteur sans matériel physique.

Créer un nouveau fichier
File → New → VHDL File

Sauvegarder
Nommez-le : compteur_4bits_tb.vhd

📄 compteur_4bits_tb.vhd

---------------------------------------------------------------
-- Testbench pour le compteur 4 bits
-- Fichier: compteur_4bits_tb.vhd
---------------------------------------------------------------

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

entity compteur_4bits_tb is
end compteur_4bits_tb;

architecture Behavioral of compteur_4bits_tb is

    -- Déclaration du composant à tester
    component compteur_4bits
        Port (
            CLK    : in  STD_LOGIC;
            RESET  : in  STD_LOGIC;
            ENABLE : in  STD_LOGIC;
            COUNT  : out STD_LOGIC_VECTOR(3 downto 0)
        );
    end component;

    -- Signaux de test
    signal CLK_tb    : STD_LOGIC := '0';
    signal RESET_tb  : STD_LOGIC := '0';
    signal ENABLE_tb : STD_LOGIC := '0';
    signal COUNT_tb  : STD_LOGIC_VECTOR(3 downto 0);

    -- Période de l'horloge
    constant CLK_PERIOD : time := 10 ns;

begin

    -- Instanciation du composant
    UUT: compteur_4bits
        port map (
            CLK    => CLK_tb,
            RESET  => RESET_tb,
            ENABLE => ENABLE_tb,
            COUNT  => COUNT_tb
        );

    -- Génération de l'horloge
    CLK_process: process
    begin
        CLK_tb <= '0';
        wait for CLK_PERIOD/2;
        CLK_tb <= '1';
        wait for CLK_PERIOD/2;
    end process;

    -- Processus de stimulation
    stim_process: process
    begin
        -- Test 1: Reset
        RESET_tb <= '1';
        ENABLE_tb <= '0';
        wait for 20 ns;
        RESET_tb <= '0';
        
        -- Test 2: Comptage avec ENABLE
        wait for 10 ns;
        ENABLE_tb <= '1';
        wait for 200 ns;  -- Compte pendant 20 cycles
        
        -- Test 3: Pause avec ENABLE = 0
        ENABLE_tb <= '0';
        wait for 50 ns;
        
        -- Test 4: Reprise du comptage
        ENABLE_tb <= '1';
        wait for 100 ns;
        
        -- Test 5: Reset pendant le comptage
        RESET_tb <= '1';
        wait for 20 ns;
        RESET_tb <= '0';
        
        -- Fin de la simulation
        wait for 100 ns;
        wait;
    end process;

end Behavioral;
                

⚙️ Compilation et Analyse

Étape 1 : Ajouter les fichiers au projet

Project Navigator
Dans la fenêtre "Project Navigator" (gauche), cliquez sur "Files"

Vérifier les fichiers
Vous devriez voir :

📄 compteur_4bits.vhd
📄 compteur_4bits_tb.vhd

Étape 2 : Définir le Top-Level Entity

Clic droit sur compteur_4bits.vhd
Sélectionnez : Set as Top-Level Entity

Étape 3 : Analyse et Synthèse

Analysis & Synthesis
Double-cliquez sur "Analysis & Synthesis" dans "Tasks" ou appuyez sur Ctrl+K

Vérifier les résultats
La compilation doit réussir sans erreurs. Vérifiez la fenêtre "Messages" en bas

✅ Analyse réussie ! Si vous voyez des warnings (avertissements), c'est normal. Les erreurs doivent être corrigées.

Étape 4 : Afficher le RTL Viewer

Visualiser le schéma
Tools → Netlist Viewers → RTL Viewer

💡 RTL Viewer : Affiche la représentation graphique de votre circuit. Vous verrez les bascules D, les portes logiques et les connexions.

Étape 5 : Compilation complète

Full Compilation
Cliquez sur l'icône ▶ Start Compilation ou appuyez sur Ctrl+L

Attendre la fin
La compilation peut prendre quelques minutes. Les étapes sont :

✓ Analysis & Synthesis
✓ Fitter (Place & Route)
✓ Assembler (Generate programming file)
✓ Timing Analyzer

🎉 Compilation réussie ! Le fichier .sof (SRAM Object File) est maintenant prêt pour la programmation.

📌 Attribution des Pins (Pin Assignment)

Avant de programmer le FPGA, vous devez associer les signaux VHDL aux broches physiques du FPGA.

Méthode 1 : Pin Planner (Interface graphique)

Ouvrir le Pin Planner
Assignments → Pin Planner

Assigner les pins
Dans la fenêtre du bas, vous verrez vos signaux. Exemple d'attribution :

Signal VHDL	Pin FPGA	Description
CLK	PIN_AF14	Clock 50 MHz
RESET	PIN_AA14	Bouton poussoir KEY0
ENABLE	PIN_AA15	Bouton poussoir KEY1
COUNT[0]	PIN_V16	LED 0
COUNT[1]	PIN_W16	LED 1
COUNT[2]	PIN_V17	LED 2
COUNT[3]	PIN_V18	LED 3

⚠️ Important : Les numéros de pins ci-dessus sont des exemples pour la carte DE1-SoC. Consultez le manuel de VOTRE carte de développement pour les pins exacts !

Méthode 2 : Fichier .qsf (Assignment File)

Vous pouvez aussi éditer directement le fichier compteur_4bits.qsf et ajouter :

# Pin Assignments
set_location_assignment PIN_AF14 -to CLK
set_location_assignment PIN_AA14 -to RESET
set_location_assignment PIN_AA15 -to ENABLE
set_location_assignment PIN_V16 -to COUNT[0]
set_location_assignment PIN_W16 -to COUNT[1]
set_location_assignment PIN_V17 -to COUNT[2]
set_location_assignment PIN_V18 -to COUNT[3]

# I/O Standards
set_instance_assignment -name IO_STANDARD "3.3-V LVTTL" -to CLK
set_instance_assignment -name IO_STANDARD "3.3-V LVTTL" -to RESET
set_instance_assignment -name IO_STANDARD "3.3-V LVTTL" -to ENABLE
set_instance_assignment -name IO_STANDARD "3.3-V LVTTL" -to COUNT[*]
                

Recompiler
Après avoir assigné les pins, relancez la compilation complète (Ctrl+L)

🔬 Simulation avec ModelSim

Configuration de la simulation

Ouvrir les paramètres
Assignments → Settings → Simulation

Configurer

Tool name : ModelSim-Altera
Format : VHDL
Cochez "Compile test bench"

Ajouter le testbench
Cliquez sur "Test Benches" → "New" → Ajoutez compteur_4bits_tb.vhd

Lancer la simulation

RTL Simulation
Tools → Run Simulation Tool → RTL Simulation

ModelSim s'ouvre
La simulation démarre automatiquement

Ajouter les signaux
Dans ModelSim, faites glisser CLK, RESET, ENABLE et COUNT vers la fenêtre "Wave"

Lancer la simulation
Tapez dans la console : run 500 ns

Observer les chronogrammes
Vous verrez le compteur s'incrémenter : 0, 1, 2, 3, ..., 15, 0, 1, ...

📊 Simulation validée ! Si les chronogrammes correspondent aux attentes, votre design est correct.

🚀 Programmer le FPGA

Préparation

⚠️ Avant de commencer :

Connectez votre carte FPGA au PC via USB-Blaster
Allumez la carte de développement
Installez les drivers USB-Blaster si nécessaire

Étapes de programmation

Ouvrir le Programmer
Tools → Programmer

Hardware Setup
Cliquez sur "Hardware Setup" → Sélectionnez votre USB-Blaster

Auto Detect
Cliquez sur "Auto Detect" pour détecter le FPGA connecté

Ajouter le fichier
Cliquez sur "Add File" → Sélectionnez output_files/compteur_4bits.sof

Configurer le mode
Cochez la case "Program/Configure" pour votre fichier .sof

Programmer
Cliquez sur "Start" pour télécharger le design dans le FPGA

🎉 Programmation réussie ! Le message "100% (Successful)" doit apparaître.

Test du compteur

🧪 Tester votre compteur :

Appuyez sur le bouton RESET → Les LEDs doivent s'éteindre (COUNT = 0000)
Maintenez le bouton ENABLE → Les LEDs doivent compter en binaire
Relâchez ENABLE → Le compteur se fige
Observez : LED0 clignote rapidement, LED1 2x plus lent, LED2 4x plus lent, LED3 8x plus lent

Séquence binaire sur les LEDs

    LED3  LED2  LED1  LED0     Valeur décimale
     0     0     0     0    =       0
     0     0     0     1    =       1
     0     0     1     0    =       2
     0     0     1     1    =       3
     0     1     0     0    =       4
     ...
     1     1     1     1    =      15
     0     0     0     0    =       0  (retour)

🎯 Améliorations Possibles

1. Diviseur d'horloge

L'horloge du FPGA est souvent à 50 MHz, ce qui rend le comptage trop rapide pour être visible. Ajoutez un diviseur d'horloge :

signal clk_div : UNSIGNED(24 downto 0) := (others => '0');
signal clk_1hz : STD_LOGIC;

-- Diviseur d'horloge (50 MHz → 1 Hz)
process(CLK, RESET)
begin
    if RESET = '1' then
        clk_div <= (others => '0');
    elsif rising_edge(CLK) then
        clk_div <= clk_div + 1;
    end if;
end process;

clk_1hz <= clk_div(24);  -- ~1.5 Hz
                

2. Compteur/Décompteur

Ajoutez un signal UP_DOWN pour choisir le sens de comptage :

UP_DOWN : in  STD_LOGIC;  -- 1=up, 0=down

if UP_DOWN = '1' then
    count_internal <= count_internal + 1;
else
    count_internal <= count_internal - 1;
end if;
                

3. Affichage 7 segments

Convertissez COUNT en affichage hexadécimal sur un afficheur 7 segments

4. Compteur modulo N

Limitez le comptage à une valeur maximale :

constant MAX_COUNT : INTEGER := 9;  -- Compte de 0 à 9

if count_internal >= MAX_COUNT then
    count_internal <= "0000";
else
    count_internal <= count_internal + 1;
end if;
                

📚 Ressources Complémentaires

Documentation Intel

Quartus Prime User Guide : Manuel complet de Quartus
VHDL Style Guide : Bonnes pratiques VHDL
Device Handbook : Documentation spécifique de votre FPGA

Tutoriels en ligne

Intel FPGA Academy : https://fpgacademy.org
Terasic Support : Exemples pour cartes DE (DE0, DE1, DE2, etc.)
VHDL Tutorial : https://www.nandland.com

Communautés

Intel FPGA Forum : Forum officiel Intel
Reddit r/FPGA : Communauté active
Stack Overflow : Questions/réponses VHDL et FPGA

🔧 Dépannage (Troubleshooting)

Problèmes courants

Problème	Solution
Erreur : "Can't elaborate top-level user hierarchy"	Vérifiez que le nom de l'entité correspond au nom du fichier et au top-level entity défini
USB-Blaster non détecté	Installez les drivers depuis `C:\intelFPGA_lite\xx.x\quartus\drivers`
Erreur de compilation "Timing requirements not met"	Ajoutez des contraintes de timing ou réduisez la fréquence d'horloge
Les LEDs ne s'allument pas	Vérifiez l'attribution des pins et le standard I/O (3.3V ou 2.5V selon la carte)
Simulation ne démarre pas	Vérifiez que ModelSim est bien installé et configuré dans les paramètres
Erreur "No valid assignment"	Assurez-vous d'avoir sélectionné le bon device FPGA dans les paramètres du projet

💡 Astuce : Consultez toujours la fenêtre "Messages" en bas de Quartus pour des informations détaillées sur les erreurs.

✅ Conclusion

Félicitations ! Vous avez maintenant parcouru toutes les étapes pour créer un projet VHDL dans Quartus, depuis l'installation jusqu'à la programmation du FPGA.

🎓 Vous savez maintenant :

✅ Installer et configurer Quartus Prime
✅ Créer un projet VHDL structuré
✅ Écrire du code VHDL pour un compteur
✅ Compiler et synthétiser un design
✅ Simuler avec ModelSim
✅ Assigner les pins physiques
✅ Programmer le FPGA
✅ Tester sur matériel réel

🚀 Prochaines étapes :

Maintenant que vous maîtrisez les bases, explorez des projets plus complexes :

Machines à états (FSM)
Communication série (UART)
Contrôleur VGA
Traitement de signal numérique (DSP)
Interface SPI/I2C
Processeur soft-core (Nios II)