Exercices VHDL Intermédiaire - Cahier des charges

Maître AXI4 - canaux de lecture

Implémentez un maître AXI4 simple gérant les deux canaux de lecture : Read Address (AR) et Read Data (R).

IndustrieIA / ML

Esclave AXI-Lite - carte de registres

Implémentez un esclave AXI-Lite avec trois registres 32 bits accessibles en lecture/écriture, gérés par deux machines à états indépendantes.

IndustrieIA / ML

FSM - Feu piéton

Implémentez une machine à états à 3 process pour un feu piéton avec timer intégré et gestion des durées par état.

AutomobileIndustrie

Contrôleur LEDs - Machine à états Moore

Implémentez une machine à états Moore à 3 process qui fait défiler 4 LEDs en séquence sur commande.

IndustrieAutomobile

Additionneur N bits - Ripple Carry

VHDL

Implémentez un additionneur N bits a propagation de retenue (ripple carry) en utilisant uniquement des operateurs logiques, sans bibliotheque arithmetique.

Terminer Contrôleur LEDs - Machine à états Moore

Compteur bidirectionnel avec chargement parallele

VHDL

Implémentez un compteur bidirectionnel générique avec chargement parallele, enable et reset asynchrone.

Terminer Additionneur N bits - Ripple Carry

Anti-rebond configurable

VHDL

Implémentez un circuit anti-rebond (debouncer) avec un temps de stabilisation configurable via des génériques.

Terminer Compteur bidirectionnel avec chargement parallele

Encodeur de priorité 8 vers 3

VHDL

Implémentez un encodeur de priorité combinatoire 8 vers 3 qui encode la position du bit actif de plus haute priorité.

Terminer Anti-rebond configurable

Compteur Johnson 4 bits

VHDL

Implémentez un compteur Johnson 4 bits avec reset synchrone. Le compteur parcourt une séquence de 8 états avant de revenir a son état initial.

Terminer Encodeur de priorité 8 vers 3

Barrel Shifter 8 bits

VHDL

Implémentez un barrel shifter 8 bits effectuant un décalage logique a gauche en 3 etages combinatoires (shift-by-4, shift-by-2, shift-by-1).

Terminer Compteur Johnson 4 bits

Registre W1C (Write-1-to-Clear)

VHDL

Implémentez un registre W1C : les bits se positionnent via i_set_en et s'effacent en écrivant 1 via i_clr_en.

Terminer Barrel Shifter 8 bits

Générateur de tick 1µs

VHDL

Générez une impulsion périodique de 1µs à partir d'une horloge système de période connue.

Terminer Registre W1C (Write-1-to-Clear)

Compteur N bits avec sortie de débordement

VHDL

Implémentez un compteur générique N bits synchrone avec enable, reset asynchrone et indication de débordement.

Terminer Générateur de tick 1µs

Comparateur 8 bits

VHDL

Implémentez un comparateur combinatoire 8 bits qui compare deux nombres non signes et indique la relation entre eux.

Terminer Compteur N bits avec sortie de débordement

Additionneur-soustracteur 4 bits

VHDL

Implémentez un bloc combinatoire 4 bits selectionnable en addition ou soustraction via un signal de contrôle.

Terminer Comparateur 8 bits

Comparateur cascadable N bits

VHDL

Implémentez un comparateur générique cascadable avec entrées de cascade pour connecter plusieurs etages.

Terminer Additionneur-soustracteur 4 bits

Registre 8 bits avec chargement

VHDL

Implémentez un registre 8 bits avec chargement parallele et reset asynchrone.

Terminer Comparateur cascadable N bits

Registre a décalage bidirectionnel 4 bits

VHDL

Implémentez un registre a décalage 4 bits pouvant décaler a gauche, a droite, charger en parallele ou conserver sa valeur.

Terminer Registre 8 bits avec chargement

ROM 8x4

VHDL

Implémentez une mémoire morte (ROM) de 8 mots de 4 bits, purement combinatoire.

Terminer Registre a décalage bidirectionnel 4 bits

ROM 16x4 avec tableau constant

VHDL

Implémentez une ROM 16 mots de 4 bits en utilisant un tableau constant VHDL.

Terminer ROM 8x4

RAM synchrone 8x4

VHDL

Implémentez une mémoire RAM de 8 mots de 4 bits avec écriture synchrone et lecture asynchrone.

Terminer ROM 16x4 avec tableau constant

RAM synchrone 16x4

VHDL

Implémentez une mémoire RAM de 16 mots de 4 bits avec écriture synchrone et lecture asynchrone.

Terminer RAM synchrone 8x4

Pile LIFO 8 niveaux, 8 bits

VHDL

Implémentez une pile LIFO (Last In, First Out) de 8 niveaux sur 8 bits avec push, pop, et indicateurs empty/full.

Terminer RAM synchrone 16x4

RAM double port 8x8

VHDL

Implémentez une RAM double port de 8 mots de 8 bits : un port d'écriture et un port de lecture indépendants.

Terminer Pile LIFO 8 niveaux, 8 bits

Banc de registres 4x8

VHDL

Implémentez un banc de 4 registres de 8 bits avec 1 port d'écriture et 2 ports de lecture.

Terminer RAM double port 8x8

Additionneur CLA 4 bits

VHDL

Implémentez un additionneur 4 bits a anticipation de retenue (Carry Lookahead Adder).

Terminer Banc de registres 4x8

Additionneur CLA 8 bits (2 blocs cascades)

VHDL

Implémentez un additionneur CLA 8 bits en cascadant deux blocs CLA 4 bits.

Terminer Additionneur CLA 4 bits

Barrel Shifter 4 bits

VHDL

Implémentez un barrel shifter 4 bits a 2 étages pouvant décaler logiquement a gauche de 0 a 3 positions.

Terminer Additionneur CLA 8 bits (2 blocs cascades)

Additionneur flottant simplifié 8 bits

VHDL

Implémentez un additionneur pour un format flottant simplifié : 1 bit signe, 3 bits exposant (biais 3), 4 bits mantisse (implicite 1.xxxx).

Terminer Barrel Shifter 4 bits

Multiplieur flottant simplifié 8 bits

VHDL

Implémentez un multiplieur pour le meme format flottant simplifié : 1 bit signe, 3 bits exposant (biais 3), 4 bits mantisse (1 implicite).

Terminer Additionneur flottant simplifié 8 bits

Générateur de parité 7 bits

VHDL

Implémentez un générateur de parité paire : genere un bit de parité pour 7 bits de données, et vérifié un mot de 8 bits (7 data + 1 parité).

Terminer Multiplieur flottant simplifié 8 bits

Compteur de population 8 bits (popcount)

VHDL

Implémentez un compteur de population : compte le nombre de bits a '1' dans un vecteur de 8 bits.

Terminer Générateur de parité 7 bits

Multiplexeur a priorité 4 canaux

VHDL

Implémentez un multiplexeur à priorité : 4 canaux de données 4 bits avec bits de requête. Le canal de plus haute priorité active est sélectionné.

Terminer Compteur de population 8 bits (popcount)

Synchroniseur Handshake CDC

VHDL

Implémentez un synchroniseur a poignée de main (4 phases) pour transférer un bus de données entre deux domaines d'horloge indépendants.

Terminer Multiplexeur a priorité 4 canaux

Filtre FIR passe-bas 5 taps

VHDL

Implémentez un filtre FIR passe-bas 5 taps en forme directe avec ligne à retard et coefficients fixes.

Terminer Synchroniseur Handshake CDC

Multiplicateur 5x5 pipeliné 4 étages

VHDL

Transformez un multiplicateur combinatoire 5x5 en architecture pipelinée à 4 étages.

Terminer Filtre FIR passe-bas 5 taps

Correcteur Hamming (7,4)

VHDL

Décodez un mot Hamming (7,4), calculez le syndrome et corrigez une erreur simple.

Terminer Multiplicateur 5x5 pipeliné 4 étages

Registre PISO 4 bits

VHDL

Implémentez un registre Parallel-In Serial-Out avec chargement parallèle et décalage contrôlé.

Terminer Correcteur Hamming (7,4)

Compteur synchrone modulo 6

VHDL

Concevez un compteur synchrone qui parcourt les états 0 à 5 avec enable et impulsion de fin de cycle.

Terminer Registre PISO 4 bits

Horloge time_of_day avec record

VHDL

Créez un package `time_of_day_pkg`, un type `record` et un compteur horaire réutilisable.

Terminer Compteur synchrone modulo 6

Arbitre de priorité

VHDL

Implémentez un arbitre combinatoire qui accorde le bus au demandeur ayant la priorité numérique la plus faible.

Terminer Horloge time_of_day avec record

Comparateur signé-magnitude

VHDL

Comparez deux nombres encodés en signé-magnitude, sans les traiter comme du complément à deux.

Terminer Arbitre de priorité

Bit reverser non contraint

VHDL

Codez un inverseur d'ordre de bits compatible avec des vecteurs de tailles et directions différentes.

Terminer Comparateur signé-magnitude

Convertisseur binaire vers BCD

VHDL

Convertissez un mot binaire 8 bits en trois chiffres BCD.

Terminer Bit reverser non contraint

Compteur Gray

VHDL

Implémentez un compteur 4 bits qui expose sa valeur en code Gray.

Terminer Convertisseur binaire vers BCD

Compteur de zéros de tête

VHDL

Comptez les zéros consécutifs depuis le bit de poids fort.

Terminer Compteur Gray

Différenciateur numérique

VHDL

Calculez la différence entre deux échantillons consécutifs valides.

Terminer Compteur de zéros de tête

Interpolateur par table

VHDL

Interpolez linéairement entre quatre points fixes de table.

Terminer Différenciateur numérique

Gestionnaire de compteurs

VHDL

Pilotez quatre compteurs 4 bits avec sélection, incrément et remise à zéro.

Terminer Interpolateur par table

Calculateur d’histogramme

VHDL

Accumulez quatre bins d’histogramme à partir d’échantillons 2 bits.

Terminer Gestionnaire de compteurs

Contrôleur de copie mémoire

VHDL

Générez une séquence de lectures puis écritures pour copier quatre mots.

Terminer Calculateur d’histogramme

Accumulateur scratchpad

VHDL

Accumulez des valeurs signées dans quatre cases scratchpad.

Terminer Contrôleur de copie mémoire

Testeur de nombre premier

VHDL

Déterminez si une valeur 4 bits est un nombre premier.

Terminer Accumulateur scratchpad

Filtre maximum glissant

VHDL

Sortez le maximum des quatre derniers échantillons valides.

Terminer Testeur de nombre premier

Calculateur factoriel

VHDL

Calculez `n!` pour une entrée 3 bits de 0 à 5.

Terminer Filtre maximum glissant

Vérificateur de palindrome

VHDL

Vérifiez si quatre nibbles forment une séquence palindrome.

Terminer Calculateur factoriel

Détecteur Two Sum

VHDL

Trouvez si une paire parmi quatre valeurs atteint une cible.

Terminer Vérificateur de palindrome

Encodeur Run-Length

VHDL

Compressez un flux 4 bits en émettant symbole et longueur au changement.

Terminer Détecteur Two Sum

Détecteur de pic

VHDL

Détectez un maximum local dans un flux d’échantillons 8 bits.

Terminer Encodeur Run-Length

Recherche binaire

VHDL

Recherchez une cible dans quatre valeurs triées croissantes.

Terminer Détecteur de pic

Produit scalaire

VHDL

Calculez le produit scalaire de deux vecteurs de quatre valeurs 4 bits.

Terminer Recherche binaire

Moteur de tri par insertion

VHDL

Insérez un flux de quatre valeurs dans un tableau trié interne.

Terminer Produit scalaire

Recherche du mode

VHDL

Retournez la valeur la plus fréquente parmi quatre valeurs 4 bits.

Terminer Moteur de tri par insertion

Détecteur de séquence bitonique

VHDL

Détectez une montée suivie d’une descente dans quatre valeurs.

Terminer Recherche du mode

Parseur d’en-tête Ethernet

VHDL

Découpez un en-tête Ethernet II de 14 octets en champs principaux.

Terminer Détecteur de séquence bitonique

Checksum d’en-tête IPv4

VHDL

Calculez le complément à un de dix mots 16 bits d’un en-tête IPv4.

Terminer Parseur d’en-tête Ethernet

Détecteur de requête ARP

VHDL

Détectez une requête ARP IPv4/Ethernet ciblant l’adresse locale.

Terminer Checksum d’en-tête IPv4

Unité MAC

VHDL

Implémentez une accumulation de produits non signés 8x8.

Terminer Détecteur de requête ARP

Diviseur non signé itératif

VHDL

Réalisez une division entière 8 bits en huit étapes, avec quotient, reste et détection d'une division par zéro.

Terminer Unité MAC

Mesureur de période en cycles

VHDL

Mesurez le nombre exact de cycles système entre deux fronts montants d'un signal externe synchronisé.

Terminer Diviseur non signé itératif

Sigmoïde par table de correspondance

VHDL

Approximez une fonction sigmoïde avec une entrée signée Q4.4 et une table de 16 niveaux.

Terminer Mesureur de période en cycles

Additionneur séquentiel à quatre opérandes

VHDL

Additionnez quatre mots non signés avec un seul additionneur réutilisé sur quatre cycles.

Terminer Sigmoïde par table de correspondance

Accumulateur multiopérande carry-save

VHDL

Compressez quatre opérandes sans propager la retenue à chaque cycle, puis faites une addition finale.

Terminer Additionneur séquentiel à quatre opérandes

Multiplieur signé séquentiel

VHDL

Calculez un produit signé 8 x 8 bits avec additions et décalages sur huit cycles.

Terminer Accumulateur multiopérande carry-save

Filtre récursif de pixels avec seuil

VHDL

Lissez les changements importants tout en laissant passer les petites variations d'un flux de pixels.