Cahier des charges

Implémentez une bascule D avec enable et reset asynchrone actif haut. La bascule mémorise i_d sur le front montant uniquement si i_en est actif.

Implémentez un registre à décalage série 4 bits (SISO) avec reset asynchrone. Les bits se décalent vers la droite à chaque front montant.

Implémentez une machine à états Mealy qui détecte la séquence binaire «101» sur une entrée série, avec gestion du chevauchement.

Implémentez une ALU combinatoire réalisant 4 opérations sur deux opérandes 8 bits : addition, soustraction, ET logique et OU logique, avec drapeau de retenue.

Implémentez un latch transparent pour comprendre ce piège classique du FPGA. Quand enable est haut, la sortie suit l'entrée ; quand enable est bas, la sortie conserve sa valeur.

Implémentez un registre à décalage chargeable 8 bits combinant chargement parallèle et décalage à gauche, avec priorité au chargement.

Implémentez un étireur d'impulsion qui prolonge un signal d'un cycle en une sortie active pendant G_CYCLES cycles d'horloge.

Implémentez un timer watchdog de sécurité : un compteur décrémente en continu et déclenche un timeout si aucun signal i_kick n'est reçu à temps.

Implémentez un contrôleur FSM à 3 états (OFF, BLINK, ON) qui pilote une LED avec clignotement. Chaque appui sur le bouton avance la séquence.

Implémentez un générateur PWM avec un compteur séquentiel et une sortie combinatoire contrôlée par le rapport cyclique.

Implémentez un registre à décalage à rétroaction linéaire (LFSR) 8 bits avec chargement de graine et sortie combinatoire de feedback.

Implémentez un filtre moyenneur glissant sur 4 echantillons avec un registre a décalage séquentiel et un calcul combinatoire de la moyenne.

Implémentez un registre parallele N bits avec enable et détection combinatoire de mise a jour.

Implémentez un synchroniseur CDC a deux bascules avec détection combinatoire de fronts montants et descendants.

Implémentez un calculateur CRC-16 synchrone, bit par bit, avec le polynome CCITT et une sortie combinatoire du registre CRC.

Implémentez les deux premieres phases d'un maitre I2C : condition START et envoi de l'adresse 7 bits + bit R/W via une FSM a 5 états.

Implémentez un décodeur 7 segments qui convertit un chiffre BCD (0-9) en 7 signaux pour allumer les bons segments d'un afficheur, avec enable.

Implémentez un top level qui instancie un compteur BCD et un décodeur 7 segments, en câblant correctement les signaux internes et les ports externes.

Concevez un additionneur 1 bit complet (full adder) avec retenue entrante et sortante. Ce bloc est la brique de base de toute unite arithmetique.

Concevez un multiplexeur 4 vers 1 purement combinatoire. Le selecteur de 2 bits choisit laquelle des 4 entrées est transmise en sortie.

Concevez un décodeur binaire 2 vers 4 avec signal d'activation (enable). La sortie est un code one-hot correspondant a la valeur du selecteur lorsque le décodeur est actif.

Concevez un vérificateur de parité sur 8 bits. La sortie indique si le nombre de bits a 1 dans l'entrée est impair (parité = 1) ou pair (parité = 0).

Concevez un comparateur combinatoire 4 bits qui compare deux nombres non signes et indique si le premier est superieur, egal ou inferieur au second.

Concevez un multiplieur combinatoire 4 bits qui calcule le produit de deux nombres non signes sur 8 bits de sortie.

Concevez un convertisseur combinatoire qui transforme un nombre BCD (Binary-Coded Decimal) sur 8 bits en sa valeur binaire sur 7 bits.

Concevez une porte logique AND a deux entrées. C'est la brique de base de toute logique combinatoire.

Concevez une porte logique OR a deux entrées. La sortie est active des qu'au moins une entrée est a '1'.

Concevez un inverseur logique. La sortie est le complément de l'entrée.

Concevez une porte logique NAND a deux entrées. C'est la porte universelle : toute fonction logique peut etre construite avec des portes NAND.

Concevez une porte logique NOR a deux entrées. Comme la NAND, c'est une porte universelle.

Concevez une porte logique XOR (OU exclusif) a deux entrées. Utilisee dans les additionneurs, la détection de parité et le chiffrement.

Concevez une porte logique XNOR (equivalence) a deux entrées. La sortie est active lorsque les deux entrées sont identiques.

Concevez un multiplexeur 2 vers 1 purement combinatoire. Le selecteur choisit laquelle des 2 entrées est transmise en sortie.

Concevez un multiplexeur 8 vers 1 purement combinatoire. Le selecteur de 3 bits choisit laquelle des 8 entrées est transmise en sortie.

Concevez un demultiplexeur 1 vers 2. L'entrée est acheminee vers l'une des deux sorties selon le selecteur.

Concevez un demultiplexeur 1 vers 4. L'entrée est acheminee vers l'une des quatre sorties selon le selecteur de 2 bits.

Concevez un décodeur binaire 3 vers 8 avec signal d'activation. La sortie est un code one-hot correspondant a la valeur du selecteur.

Concevez un convertisseur 4 bits de code binaire vers code Gray. Le code Gray est utilise dans les communications car un seul bit change entre deux valeurs consecutives.

Concevez un convertisseur 4 bits de code Gray vers code binaire. Opération inverse du convertisseur binaire vers Gray.

Concevez un demi-additionneur (half adder) qui additionne deux bits sans retenue entrante.

Concevez un soustracteur combinatoire 4 bits qui calcule la difference de deux nombres non signes avec indication d'emprunt.

Implémentez une bascule JK avec reset asynchrone actif haut. La bascule JK est la plus polyvalente : elle peut maintenir, mettre a '1', mettre a '0' ou basculer sa sortie.

Implémentez une bascule T (Toggle) avec reset asynchrone actif haut. Quand T='1', la sortie bascule a chaque front montant.

Implémentez une bascule SR synchrone avec reset asynchrone actif haut. S met la sortie a '1', R la remet a '0'.

Implémentez un registre 4 bits avec enable et reset asynchrone actif haut.

Implémentez un registre a décalage a gauche 4 bits avec entrée série et reset asynchrone.

Implémentez un registre a décalage série vers parallele (SIPO) 4 bits avec reset asynchrone. Les bits entrent en série et sont disponibles en parallele.

Implémentez un compteur synchrone 4 bits croissant avec enable et reset asynchrone.

Implémentez un compteur synchrone 4 bits decroissant avec enable et reset asynchrone. Le reset initialise a la valeur maximale (15).

Implémentez un compteur en anneau (ring counter) 4 bits avec reset asynchrone. Un seul bit a '1' circule dans le registre.

Concevez un encodeur combinatoire qui transforme un chiffre BCD valide en code Excess-3.

Encodez 4 bits de données avec trois bits de parité paire pour former un mot Hamming (7,4).

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

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

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

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

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.

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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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é).

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

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é.

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.

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

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

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

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

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

Implémentez un générateur d'interruptions : chaque vecteur d'IT est maintenu actif pendant g_MIN_WIDTH_PULSE cycles puis reporté dans le statut.

Implémentez un maître AXI4-Lite générique capable d'effectuer des accès en lecture et écriture sur un bus AXI4-Lite.

Implémentez un esclave AXI4-Lite générique avec interface registre simplifiée.

Implémentez un maître AXI4 simple gérant les trois canaux d'écriture : Write Address (AW), Write Data (W) et Write Response (B).

Implementez un mini-processeur 16 bits de type accumulateur : UAL, registres PC/IR/ACC/R, sequenceur FSM et assemblage top-level. 14 instructions couvertes.

Implémentez un cœur SHA-256 matériel sur un bloc de 512 bits : fonctions logiques, registre à décalage message, compression et FSM top-level.

Implémentez une FSMD de conversion par approximations successives pour piloter un DAC interne et lire un comparateur.