Architectures Numeriques Avancees VHDL - Semestre 7

Annee Universitaire : 2023-2024
Semestre : 7
Credits : 2.5 ECTS
Specialite : Conception Numerique et FPGA

---

PART A - Presentation Generale du Module

Vue d'ensemble

Ce cours enseigne la conception de systemes numeriques complexes avec le langage VHDL (VHSIC Hardware Description Language) et leur implementation sur FPGA. Il couvre la conception d'architectures numeriques avancees : unite arithmetique et logique (ALU), bancs de registres, memoires, et processeurs complets.

Objectifs pedagogiques :

• Maitriser le langage VHDL pour la description materielle
• Concevoir des circuits numeriques synthetisables
• Implementer des systemes sur FPGA (Xilinx)
• Simuler et verifier des designs avec testbenches
• Comprendre les machines a etats finis (FSM)
• Concevoir un processeur simple complet

Position dans le cursus

Ce module s'appuie sur :

• Fondements electronique numerique (S5) : portes logiques, bascules
• Logique sequentielle (S5) : machines a etats, compteurs
• Architecture Informatique materielle (S5) : structure processeur

Il prepare a :

• Systemes embarques : accelerateurs materiels
• Traitement du signal sur FPGA : implementation de filtres numeriques
• Conception ASIC : circuits integres specialises
• Systemes temps reel : logique cablee haute performance

---

PART B - Experience Personnelle et Contexte d'Apprentissage

Organisation et ressources

Le module etait organise en cours magistraux et bureau d'etudes pratique :

Cours magistraux (16h) :

• Syntaxe et structure VHDL
• Types de donnees et operateurs
• Logique combinatoire et sequentielle
• Machines a etats finis (FSM)
• Architectures de processeurs

Bureau d'etudes (20h) :

Projets de conception progressive avec Xilinx Vivado :

• Projet ALU : unite arithmetique et logique
• Projet registre : banc de registres
• Projet buffer : memoire tampon
• Projet memoire instruction : ROM pour code programme
• Projet memoire donnee : RAM pour donnees
• Projet processeur : integration complete

Devoirs maison :

• DM1 : ALU et testbench
• DM2 : Circuit numerique complexe

Outils utilises :

• Xilinx Vivado Design Suite (synthese, simulation, implementation)
• FPGA cible : probablement Artix-7 ou Zynq
• Testbenches VHDL pour simulation
• Waveform viewer (fichiers .wcfg)

Structure des projets

Chaque projet Vivado contenait :

• Sources : fichiers VHDL (sources_1/new/)
• Simulations : testbenches (sim_1/)
• Contraintes : fichiers .xdc pour mapping des pins (constrs_1/)
• Waveforms : fichiers .wcfg pour visualisation des signaux
• Synthese et implementation : runs/synth_1/, runs/impl_1/

Progression pedagogique :

1. Buffer : Circuit simple (FIFO ou registre a decalage)
2. ALU : Operations arithmetiques et logiques
3. Registre : Banc de registres avec lecture/ecriture
4. Memoire instruction : ROM pour stocker le programme
5. Memoire donnee : RAM pour stocker les donnees
6. Processeur : Assemblage final (chemin de donnees + unite de controle)

Methode de travail

Phase 1 : Specification :

Definir l'interface (ports d'entree/sortie) et le comportement attendu du circuit.

Phase 2 : Code VHDL :

Ecrire le code dans Vivado, respecter les regles de synthetisabilite.

Phase 3 : Testbench :

Creer un testbench pour verifier fonctionnellement le circuit par simulation.

Phase 4 : Simulation :

Lancer la simulation comportementale, observer les chronogrammes (waveforms), corriger les erreurs.

Phase 5 : Synthese :

Verifier que le code se synthetise sans erreurs, analyser l'utilisation des ressources (LUT, FF, BRAM).

Phase 6 : Implementation (optionnel) :

Placer et router le design, verifier le timing, programmer le FPGA.

Difficultes rencontrees

Pensee parallele :

VHDL decrit du materiel ou tout s'execute en parallele, contrairement a la programmation sequentielle. Comprendre que les process s'executent simultanement demande un changement de paradigme.

Syntaxe stricte :

VHDL est verbeux et type fortement. Les erreurs de syntaxe ou de typage sont frequentes au debut.

Timing et synchronisation :

Gerer correctement les horloges, resets, et eviter les hazards (glitches) necessite de la rigueur.

Debugging :

Sans printf ni debogueur, le debugging se fait via les chronogrammes. Savoir quels signaux observer est crucial.

---

PART C - Aspects Techniques Detailles

1. Introduction au VHDL

VHDL = VHSIC Hardware Description Language

VHSIC = Very High Speed Integrated Circuit

Langage de description materielle :

• Decrit la structure et le comportement de circuits numeriques
• Utilise pour simulation et synthese (generation de circuits reels)
• Standard IEEE (IEEE 1076)

Difference programmation logicielle :

Aspect	Logiciel	Materiel (VHDL)
Execution	Sequentielle	Parallele
Variables	Modifiees en sequence	Signaux qui evoluent dans le temps
Boucles	Iterations	Replication de materiel
Ressources	Abstraites (memoire virtuelle)	Physiques limitees (LUT, FF)

2. Structure d'un fichier VHDL

Entity (entite) :

Decrit l'interface du composant (ports d'entree/sortie).

Exemple :

entity compteur is
  port (
    clk    : in  std_logic;
    reset  : in  std_logic;
    enable : in  std_logic;
    count  : out std_logic_vector(7 downto 0)
  );
end entity compteur;

Architecture :

Decrit le comportement ou la structure interne du composant.

Exemple :

architecture behavioral of compteur is
  signal count_internal : unsigned(7 downto 0);
begin
  process(clk, reset)
  begin
    if reset = '1' then
      count_internal <= (others => '0');
    elsif rising_edge(clk) then
      if enable = '1' then
        count_internal <= count_internal + 1;
      end if;
    end if;
  end process;

  count <= std_logic_vector(count_internal);
end architecture behavioral;

Types d'architectures :

Type	Description	Usage
Behavioral	Description algorithmique du comportement	Haut niveau, synthese automatique
Dataflow	Affectations concurrentes, equations	Logique combinatoire
Structural	Instanciation de composants	Hierarchie, connexion de blocs

3. Types de donnees VHDL

Types standards :

Type	Description	Exemple
std_logic	Bit logique (9 valeurs)	'0', '1', 'Z', 'X', etc.
std_logic_vector	Vecteur de bits	"10110101"
integer	Entier	-2147483648 a 2147483647
unsigned	Entier non signe	utilise pour calculs arithmetiques
signed	Entier signe	complement a 2

Valeurs std_logic :

• '0' : niveau bas
• '1' : niveau haut
• 'Z' : haute impedance (trois etats)
• 'X' : inconnu (non initialise)
• '-' : don't care (synthese)

Bibliotheques necessaires :

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;      -- std_logic, std_logic_vector
use IEEE.NUMERIC_STD.ALL;         -- unsigned, signed, conversion
use IEEE.STD_LOGIC_UNSIGNED.ALL;  -- operations sur std_logic_vector (ancien)

4. Logique combinatoire

Affectation concurrente :

Les affectations en dehors des process s'executent en parallele.

Exemples :

-- Porte AND
y <= a and b;

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

-- Multiplexeur 4 vers 1
with sel select
  y <= a when "00",
       b when "01",
       c when "10",
       d when others;

Process combinatoire :

Pour decrire de la logique combinatoire dans un process :

process(a, b, c)  -- Liste de sensibilite : tous les signaux lus
begin
  if a = '1' then
    y <= b;
  else
    y <= c;
  end if;
end process;

Attention : Si un signal lu n'est pas dans la liste de sensibilite, le process ne se met pas a jour - difference simulation/synthese.

5. Logique sequentielle

Bascule D (D Flip-Flop) :

Element de base de la logique sequentielle. Memorise une valeur sur un front d'horloge.

process(clk)
begin
  if rising_edge(clk) then  -- Front montant
    q <= d;
  end if;
end process;

Avec reset asynchrone :

process(clk, reset)
begin
  if reset = '1' then       -- Reset prioritaire
    q <= '0';
  elsif rising_edge(clk) then
    q <= d;
  end if;
end process;

Avec reset synchrone :

process(clk)
begin
  if rising_edge(clk) then
    if reset = '1' then
      q <= '0';
    else
      q <= d;
    end if;
  end if;
end process;

Regle d'or :

• Reset asynchrone : dans la sensibilite du process et teste en premier
• Reset synchrone : a l'interieur du test de rising_edge

6. Machines a etats finis (FSM)

Definition :

Une FSM (Finite State Machine) est un circuit sequentiel avec un nombre fini d'etats. Elle change d'etat selon les entrees et l'etat courant.

Types :

• Moore : sorties dependent seulement de l'etat
• Mealy : sorties dependent de l'etat et des entrees

Structure a 2 process :

Process 1 : Registre d'etat (sequentiel)

process(clk, reset)
begin
  if reset = '1' then
    etat_courant <= IDLE;
  elsif rising_edge(clk) then
    etat_courant <= etat_suivant;
  end if;
end process;

Process 2 : Logique de transition (combinatoire)

process(etat_courant, entree)
begin
  case etat_courant is
    when IDLE =>
      if entree = '1' then
        etat_suivant <= TRAITEMENT;
      else
        etat_suivant <= IDLE;
      end if;
      sortie <= '0';

    when TRAITEMENT =>
      if compteur_fini = '1' then
        etat_suivant <= FIN;
      else
        etat_suivant <= TRAITEMENT;
      end if;
      sortie <= '1';

    when FIN =>
      etat_suivant <= IDLE;
      sortie <= '0';

    when others =>
      etat_suivant <= IDLE;
      sortie <= '0';
  end case;
end process;

Declaration des etats :

type etat_type is (IDLE, TRAITEMENT, FIN);
signal etat_courant, etat_suivant : etat_type;

7. Unite Arithmetique et Logique (ALU)

Principe :

L'ALU effectue les operations arithmetiques (addition, soustraction) et logiques (AND, OR, XOR) d'un processeur.

Interface typique :

entity ALU is
  port (
    A      : in  std_logic_vector(31 downto 0);  -- Operande A
    B      : in  std_logic_vector(31 downto 0);  -- Operande B
    OP     : in  std_logic_vector(3 downto 0);   -- Code operation
    Result : out std_logic_vector(31 downto 0);  -- Resultat
    Zero   : out std_logic;                      -- Flag zero
    Carry  : out std_logic                       -- Flag retenue
  );
end entity ALU;

Operations courantes :

Code OP	Operation	Description
0000	AND	ET logique bit a bit
0001	OR	OU logique bit a bit
0010	ADD	Addition
0110	SUB	Soustraction (A - B)
0111	SLT	Set if Less Than (A < B)
1100	NOR	NON-OU logique

Implementation :

process(A, B, OP)
  variable temp : unsigned(32 downto 0);  -- 33 bits pour la retenue
begin
  case OP is
    when "0000" =>  -- AND
      Result <= A and B;
      Carry <= '0';

    when "0001" =>  -- OR
      Result <= A or B;
      Carry <= '0';

    when "0010" =>  -- ADD
      temp := ('0' & unsigned(A)) + ('0' & unsigned(B));
      Result <= std_logic_vector(temp(31 downto 0));
      Carry <= temp(32);

    when "0110" =>  -- SUB
      temp := ('0' & unsigned(A)) - ('0' & unsigned(B));
      Result <= std_logic_vector(temp(31 downto 0));
      Carry <= temp(32);

    when others =>
      Result <= (others => '0');
      Carry <= '0';
  end case;

  -- Flag Zero
  if Result = x"00000000" then
    Zero <= '1';
  else
    Zero <= '0';
  end if;
end process;

8. Banc de registres

Principe :

Ensemble de registres (16 ou 32 typiquement) pour stocker temporairement des donnees dans un processeur.

Interface :

entity RegisterFile is
  port (
    clk       : in  std_logic;
    reset     : in  std_logic;
    -- Lecture
    ReadAddr1 : in  std_logic_vector(4 downto 0);   -- Adresse registre 1
    ReadAddr2 : in  std_logic_vector(4 downto 0);   -- Adresse registre 2
    ReadData1 : out std_logic_vector(31 downto 0);  -- Donnee registre 1
    ReadData2 : out std_logic_vector(31 downto 0);  -- Donnee registre 2
    -- Ecriture
    WriteEn   : in  std_logic;                      -- Autorisation ecriture
    WriteAddr : in  std_logic_vector(4 downto 0);   -- Adresse ecriture
    WriteData : in  std_logic_vector(31 downto 0)   -- Donnee a ecrire
  );
end entity RegisterFile;

Implementation :

architecture behavioral of RegisterFile is
  type reg_array is array (0 to 31) of std_logic_vector(31 downto 0);
  signal registers : reg_array;
begin
  -- Ecriture synchrone
  process(clk, reset)
  begin
    if reset = '1' then
      registers <= (others => (others => '0'));
    elsif rising_edge(clk) then
      if WriteEn = '1' and WriteAddr /= "00000" then  -- R0 toujours a 0
        registers(to_integer(unsigned(WriteAddr))) <= WriteData;
      end if;
    end if;
  end process;

  -- Lecture asynchrone
  ReadData1 <= registers(to_integer(unsigned(ReadAddr1)));
  ReadData2 <= registers(to_integer(unsigned(ReadAddr2)));
end architecture behavioral;

Particularite :

Le registre R0 est souvent cable a zero (convention MIPS/RISC-V).

9. Memoires

ROM (Read-Only Memory) :

Utilisee pour stocker le programme (instructions).

architecture behavioral of ROM is
  type rom_array is array (0 to 255) of std_logic_vector(31 downto 0);
  constant rom_data : rom_array := (
    x"00000000",  -- NOP
    x"20010005",  -- ADDI R1, R0, 5
    x"20020003",  -- ADDI R2, R0, 3
    x"00221820",  -- ADD R3, R1, R2
    -- ... autres instructions
    others => x"00000000"
  );
begin
  process(clk)
  begin
    if rising_edge(clk) then
      data_out <= rom_data(to_integer(unsigned(address)));
    end if;
  end process;
end architecture behavioral;

RAM (Random Access Memory) :

Utilisee pour stocker les donnees.

architecture behavioral of RAM is
  type ram_array is array (0 to 1023) of std_logic_vector(31 downto 0);
  signal ram_data : ram_array := (others => (others => '0'));
begin
  process(clk)
  begin
    if rising_edge(clk) then
      if write_enable = '1' then
        ram_data(to_integer(unsigned(address))) <= data_in;
      end if;
      data_out <= ram_data(to_integer(unsigned(address)));
    end if;
  end process;
end architecture behavioral;

Utilisation des BRAM (Block RAM) sur FPGA :

Les FPGA possedent des blocs memoire dedies (BRAM). Vivado infere automatiquement des BRAM si le code suit certains modeles (comme ci-dessus).

10. Processeur simple

Architecture :

Un processeur minimal contient :

• Chemin de donnees (Datapath) : ALU, registres, memoires, multiplexeurs
• Unite de controle : FSM qui genere les signaux de controle

Cycle d'execution :

1. Fetch : Lire l'instruction en memoire (PC → Mem_Instr → IR)
2. Decode : Decoder l'instruction (champs opcode, registres, immediat)
3. Execute : Executer l'operation (ALU)
4. Memory : Acces memoire donnees si necessaire (LOAD/STORE)
5. Write Back : Ecrire le resultat dans le registre destination

Signaux de controle :

L'unite de controle genere des signaux pour piloter le datapath :

• RegWrite : autoriser ecriture dans le banc de registres
• ALUOp : selection operation ALU
• MemRead, MemWrite : lecture/ecriture memoire donnees
• MemToReg : selection source donnee a ecrire dans registre
• Branch : autoriser branchement conditionnel

Exemple simplifie :

Type d'instruction R (registre-registre) :

• Opcode determine que c'est une instruction R
• Lire deux registres sources (rs, rt)
• ALU effectue l'operation (funct determine laquelle)
• Ecrire le resultat dans registre destination (rd)

11. Testbench et simulation

Testbench :

Fichier VHDL sans ports (entity vide) qui instancie le circuit a tester (UUT - Unit Under Test) et genere des stimuli.

Structure :

entity testbench is
  -- Pas de ports
end entity testbench;

architecture test of testbench is
  -- Declaration des signaux de test
  signal clk : std_logic := '0';
  signal reset : std_logic := '1';
  signal input : std_logic_vector(7 downto 0);
  signal output : std_logic_vector(7 downto 0);

  constant CLK_PERIOD : time := 10 ns;
begin
  -- Instanciation du composant a tester
  UUT: entity work.mon_circuit
    port map (
      clk => clk,
      reset => reset,
      input => input,
      output => output
    );

  -- Generation de l'horloge
  clk_process: process
  begin
    clk <= '0';
    wait for CLK_PERIOD/2;
    clk <= '1';
    wait for CLK_PERIOD/2;
  end process;

  -- Generation des stimuli
  stim_process: process
  begin
    reset <= '1';
    input <= x"00";
    wait for 50 ns;

    reset <= '0';
    wait for 10 ns;

    input <= x"12";
    wait for 20 ns;

    input <= x"34";
    wait for 20 ns;

    wait;  -- Arret de la simulation
  end process;
end architecture test;

Verifications :

Utiliser des assertions pour verifier automatiquement :

assert (output = x"46") report "Erreur : resultat incorrect" severity error;

Waveform (chronogramme) :

Fichiers .wcfg dans Vivado permettent de configurer quels signaux afficher et comment. Essentiels pour le debugging visuel.

12. Synthese et implementation sur FPGA

Etapes :

1. Synthese (Synthesis) :

• Conversion du code VHDL en netlist (portes logiques)
• Optimisation logique
• Verification que le code est synthetisable

2. Implementation :

• Placement : affecter les ressources logiques aux elements du FPGA (LUT, FF)
• Routage : connecter les elements via les interconnexions
• Verification timing : s'assurer que les contraintes temporelles sont respectees

3. Generation du bitstream :

• Fichier .bit a programmer dans le FPGA

Ressources FPGA :

Ressource	Description
LUT (Look-Up Table)	Implemente logique combinatoire (fonction quelconque de N entrees)
FF (Flip-Flop)	Bascule D pour logique sequentielle
BRAM (Block RAM)	Blocs memoire dedies (18 Kb ou 36 Kb)
DSP	Blocs multiplicateurs/accumulateurs materiels
IO	Broches d'entree/sortie configurables

Contraintes :

Fichier .xdc (Xilinx Design Constraints) :

• Affectation des pins physiques
• Definition des horloges (periode, frequence)
• Contraintes de timing

Exemple :

# Horloge 100 MHz
create_clock -period 10.000 -name clk [get_ports clk]

# Pins
set_property PACKAGE_PIN W5 [get_ports clk]
set_property IOSTANDARD LVCMOS33 [get_ports clk]

set_property PACKAGE_PIN U16 [get_ports led[0]]
set_property IOSTANDARD LVCMOS33 [get_ports led[0]]

---

PART D - Analyse Reflexive et Perspectives

Competences acquises

Conception materielle :

Maitrise du VHDL pour decrire des circuits numeriques synthetisables. Capacite a penser en termes de parallelisme materiel plutot que sequence logicielle.

Architecture de processeur :

Comprehension profonde du fonctionnement interne d'un processeur : ALU, registres, memoires, unite de controle, chemin de donnees.

Outils professionnels :

Utilisation de Xilinx Vivado, outil standard de l'industrie pour FPGA. Simulation, synthese, implementation, analyse de timing.

Points cles a retenir

1. VHDL = description materielle, pas programmation :

Le code VHDL decrit du materiel qui existe physiquement. Tout s'execute en parallele. Changement de paradigme fondamental.

2. Synthetisabilite :

Tout le code VHDL ne peut pas etre synthetise en materiel. Eviter wait for (sauf dans testbenches), boucles infinies, division par variables, etc.

3. Horloge et synchronisme :

Les circuits synchrones (cadences par horloge) sont plus robustes et previsibles. Toujours utiliser rising_edge(clk) pour detecter les fronts.

4. Testbench = essentiel :

La simulation avec testbench permet de valider le fonctionnement avant synthese. Debug beaucoup plus facile qu'apres implementation.

5. Ressources limitees :

Les FPGA ont un nombre fini de LUT, FF, BRAM. Importance de l'optimisation et du partage de ressources.

Applications pratiques

Traitement du signal :

Implementation de filtres numeriques haute performance (FIR, IIR), FFT, traitement d'image temps reel.

Accelerateurs materiels :

Acceleration de calculs intensifs (cryptographie, compression, IA) en dechargeant le processeur.

Systemes embarques critiques :

Aeronautique, automobile, spatial necessitent des circuits deterministes et fiables (logique cablee sur FPGA ou ASIC).

Prototypage ASIC :

Les FPGA servent a valider des designs avant fabrication d'ASIC (cout eleve, non modifiable).

Retour d'experience

Courbe d'apprentissage :

VHDL est plus difficile que la programmation classique au debut. Necessite de comprendre le materiel sous-jacent.

Projets progressifs :

La progression Buffer → ALU → Registres → Memoires → Processeur est pedagogiquement excellente. Chaque etape ajoute de la complexite.

Vivado puissant mais complexe :

L'outil est complet mais l'interface peut etre intimidante. Temps de synthese/implementation parfois long.

Debugging visuel :

Les waveforms (chronogrammes) sont indispensables. Savoir identifier les signaux critiques a observer facilite grandement le debugging.

Limites et ouvertures

Limites du module :

• Pas d'implementation physique sur carte FPGA (simulation seulement)
• Processeur tres simplifie (pas de pipeline, cache, etc.)
• Aspects timing et optimisation peu approfondis

Ouvertures vers :

• Processeurs avances : pipeline, prediction de branchement, cache
• Systemes sur puce (SoC) : processeur + peripheriques integres
• High-Level Synthesis (HLS) : generer VHDL depuis C/C++
• Verification formelle : assertions, model checking
• ASIC design : conception de circuits integres application specifique

Evolution technologique

Tendances actuelles :

HLS (High-Level Synthesis) :

Outils comme Vivado HLS ou Vitis HLS permettent d'ecrire en C/C++ et generent automatiquement du VHDL/Verilog. Accelere le developpement.

FPGA + IA :

Les FPGA modernes (Versal, Zynq UltraScale+) integrent des accelerateurs IA (DPU). Utilises pour inference de reseaux de neurones temps reel.

FPGA adaptatives (Versal) :

Architecture hybride : FPGA + CPU + DSP + IA. Reconfiguration dynamique.

Cloud FPGA :

AWS, Azure, Alibaba proposent des instances avec FPGA pour acceleration dans le cloud.

Conseils pour reussir

1. Penser materiel :

Visualiser mentalement les portes, bascules, multiplexeurs generes par votre code VHDL.

2. Simuler tot et souvent :

Ne pas attendre d'avoir ecrit tout le code. Tester chaque module independamment.

3. Bien commenter :

VHDL est verbeux. Des commentaires clairs aident a relire le code plus tard.

4. Respecter les conventions :

Noms de signaux explicites (clk, reset, enable), indentation coherente.

5. Utiliser les types appropries :

unsigned/signed pour arithmetique, std_logic_vector pour bus de donnees generiques.

Conclusion

Ce module fournit une excellente introduction a la conception numerique avec VHDL et FPGA. La realisation d'un processeur complet, meme simple, permet de comprendre en profondeur l'architecture des ordinateurs.

Competences transferables :

• Pensee parallele et conception materielle
• Rigueur dans la specification et la verification
• Maitrise d'outils professionnels (Vivado)
• Comprehension de l'architecture des processeurs

Pertinence professionnelle :

Les FPGA sont utilises dans de nombreux domaines (telecommunications, defense, medical, automobile, finance). La demande en ingenieurs FPGA reste forte.

Message principal :

VHDL et les FPGA offrent un controle total sur le materiel, permettant des performances et une efficacite energetique inatteignables avec du logiciel seul. La maitrise de ces outils ouvre des opportunites dans les systemes haute performance.

Recommandations :

• Pratiquer sur des cartes FPGA reelles (Basys, Arty, DE10-Nano)
• Explorer des projets plus complexes (controleurs, interfaces, DSP)
• Apprendre Verilog en complement (langage concurrent)
• Se former au HLS pour accelerer le developpement
• Etudier l'architecture de processeurs reels (RISC-V open-source)

Liens avec les autres cours :

• Architecture Informatique materielle - S5 : structure processeur
• Fondements electronique numerique - S5 : portes logiques
• Embedded IA for IoT - S9 : acceleration materielle

---

Illustrations du Projet BE Pipeline

---

Rapports et Projets

---

Documents de CoursCourse Documents

---

Cours suivi en 2023-2024 a l'INSA Toulouse, Departement Genie Electrique et Informatique.

entity compteur is
  port (
    clk    : in  std_logic;
    reset  : in  std_logic;
    enable : in  std_logic;
    count  : out std_logic_vector(7 downto 0)
  );
end entity compteur;

architecture behavioral of compteur is
  signal count_internal : unsigned(7 downto 0);
begin
  process(clk, reset)
  begin
    if reset = '1' then
      count_internal <= (others => '0');
    elsif rising_edge(clk) then
      if enable = '1' then
        count_internal <= count_internal + 1;
      end if;
    end if;
  end process;

  count <= std_logic_vector(count_internal);
end architecture behavioral;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;      -- std_logic, std_logic_vector
use IEEE.NUMERIC_STD.ALL;         -- unsigned, signed, conversion
use IEEE.STD_LOGIC_UNSIGNED.ALL;  -- operations on std_logic_vector (legacy)

-- AND gate
y <= a and b;

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

-- 4-to-1 multiplexer
with sel select
  y <= a when "00",
       b when "01",
       c when "10",
       d when others;

process(a, b, c)  -- Sensitivity list: all signals read
begin
  if a = '1' then
    y <= b;
  else
    y <= c;
  end if;
end process;

process(clk)
begin
  if rising_edge(clk) then  -- Rising edge
    q <= d;
  end if;
end process;

process(clk, reset)
begin
  if reset = '1' then       -- Reset has priority
    q <= '0';
  elsif rising_edge(clk) then
    q <= d;
  end if;
end process;

process(clk)
begin
  if rising_edge(clk) then
    if reset = '1' then
      q <= '0';
    else
      q <= d;
    end if;
  end if;
end process;

process(clk, reset)
begin
  if reset = '1' then
    etat_courant <= IDLE;
  elsif rising_edge(clk) then
    etat_courant <= etat_suivant;
  end if;
end process;

process(etat_courant, entree)
begin
  case etat_courant is
    when IDLE =>
      if entree = '1' then
        etat_suivant <= TRAITEMENT;
      else
        etat_suivant <= IDLE;
      end if;
      sortie <= '0';

    when TRAITEMENT =>
      if compteur_fini = '1' then
        etat_suivant <= FIN;
      else
        etat_suivant <= TRAITEMENT;
      end if;
      sortie <= '1';

    when FIN =>
      etat_suivant <= IDLE;
      sortie <= '0';

    when others =>
      etat_suivant <= IDLE;
      sortie <= '0';
  end case;
end process;

type etat_type is (IDLE, TRAITEMENT, FIN);
signal etat_courant, etat_suivant : etat_type;

entity ALU is
  port (
    A      : in  std_logic_vector(31 downto 0);  -- Operand A
    B      : in  std_logic_vector(31 downto 0);  -- Operand B
    OP     : in  std_logic_vector(3 downto 0);   -- Operation code
    Result : out std_logic_vector(31 downto 0);  -- Result
    Zero   : out std_logic;                      -- Zero flag
    Carry  : out std_logic                       -- Carry flag
  );
end entity ALU;

process(A, B, OP)
  variable temp : unsigned(32 downto 0);  -- 33 bits for carry
begin
  case OP is
    when "0000" =>  -- AND
      Result <= A and B;
      Carry <= '0';

    when "0001" =>  -- OR
      Result <= A or B;
      Carry <= '0';

    when "0010" =>  -- ADD
      temp := ('0' & unsigned(A)) + ('0' & unsigned(B));
      Result <= std_logic_vector(temp(31 downto 0));
      Carry <= temp(32);

    when "0110" =>  -- SUB
      temp := ('0' & unsigned(A)) - ('0' & unsigned(B));
      Result <= std_logic_vector(temp(31 downto 0));
      Carry <= temp(32);

    when others =>
      Result <= (others => '0');
      Carry <= '0';
  end case;

  -- Zero Flag
  if Result = x"00000000" then
    Zero <= '1';
  else
    Zero <= '0';
  end if;
end process;

entity RegisterFile is
  port (
    clk       : in  std_logic;
    reset     : in  std_logic;
    -- Read
    ReadAddr1 : in  std_logic_vector(4 downto 0);   -- Register 1 address
    ReadAddr2 : in  std_logic_vector(4 downto 0);   -- Register 2 address
    ReadData1 : out std_logic_vector(31 downto 0);  -- Register 1 data
    ReadData2 : out std_logic_vector(31 downto 0);  -- Register 2 data
    -- Write
    WriteEn   : in  std_logic;                      -- Write enable
    WriteAddr : in  std_logic_vector(4 downto 0);   -- Write address
    WriteData : in  std_logic_vector(31 downto 0)   -- Data to write
  );
end entity RegisterFile;

architecture behavioral of RegisterFile is
  type reg_array is array (0 to 31) of std_logic_vector(31 downto 0);
  signal registers : reg_array;
begin
  -- Synchronous write
  process(clk, reset)
  begin
    if reset = '1' then
      registers <= (others => (others => '0'));
    elsif rising_edge(clk) then
      if WriteEn = '1' and WriteAddr /= "00000" then  -- R0 always 0
        registers(to_integer(unsigned(WriteAddr))) <= WriteData;
      end if;
    end if;
  end process;

  -- Asynchronous read
  ReadData1 <= registers(to_integer(unsigned(ReadAddr1)));
  ReadData2 <= registers(to_integer(unsigned(ReadAddr2)));
end architecture behavioral;

architecture behavioral of ROM is
  type rom_array is array (0 to 255) of std_logic_vector(31 downto 0);
  constant rom_data : rom_array := (
    x"00000000",  -- NOP
    x"20010005",  -- ADDI R1, R0, 5
    x"20020003",  -- ADDI R2, R0, 3
    x"00221820",  -- ADD R3, R1, R2
    -- ... other instructions
    others => x"00000000"
  );
begin
  process(clk)
  begin
    if rising_edge(clk) then
      data_out <= rom_data(to_integer(unsigned(address)));
    end if;
  end process;
end architecture behavioral;

architecture behavioral of RAM is
  type ram_array is array (0 to 1023) of std_logic_vector(31 downto 0);
  signal ram_data : ram_array := (others => (others => '0'));
begin
  process(clk)
  begin
    if rising_edge(clk) then
      if write_enable = '1' then
        ram_data(to_integer(unsigned(address))) <= data_in;
      end if;
      data_out <= ram_data(to_integer(unsigned(address)));
    end if;
  end process;
end architecture behavioral;

entity testbench is
  -- No ports
end entity testbench;

architecture test of testbench is
  -- Test signal declarations
  signal clk : std_logic := '0';
  signal reset : std_logic := '1';
  signal input : std_logic_vector(7 downto 0);
  signal output : std_logic_vector(7 downto 0);

  constant CLK_PERIOD : time := 10 ns;
begin
  -- Instantiation of the component under test
  UUT: entity work.mon_circuit
    port map (
      clk => clk,
      reset => reset,
      input => input,
      output => output
    );

  -- Clock generation
  clk_process: process
  begin
    clk <= '0';
    wait for CLK_PERIOD/2;
    clk <= '1';
    wait for CLK_PERIOD/2;
  end process;

  -- Stimulus generation
  stim_process: process
  begin
    reset <= '1';
    input <= x"00";
    wait for 50 ns;

    reset <= '0';
    wait for 10 ns;

    input <= x"12";
    wait for 20 ns;

    input <= x"34";
    wait for 20 ns;

    wait;  -- Stop simulation
  end process;
end architecture test;

assert (output = x"46") report "Error: incorrect result" severity error;

# 100 MHz clock
create_clock -period 10.000 -name clk [get_ports clk]

# Pins
set_property PACKAGE_PIN W5 [get_ports clk]
set_property IOSTANDARD LVCMOS33 [get_ports clk]

set_property PACKAGE_PIN U16 [get_ports led[0]]
set_property IOSTANDARD LVCMOS33 [get_ports led[0]]