Cahier des charges

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 XNOR (equivalence) a deux entrées. La sortie est active lorsque les deux entrées sont identiques.

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

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.

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

Implémentez un esclave SPI générique en mode 1 (CPOL=0, CPHA=1) qui reçoit une trame de 32 bits.

Implémentez un maître SPI (mode 0 : CPOL=0, CPHA=0) capable d'émettre et de recevoir un octet sur un bus SPI.

Implémentez un maître SPI en mode 0 (CPOL=0, CPHA=0) capable de transférer 8 bits en série.

Implémentez un compteur BCD synchrone qui compte de 0 à 9 puis reboucle à 0, avec reset asynchrone actif bas et entrée d'activation.

Implémentez un diviseur d'horloge générique qui divise la fréquence d'entrée par 2 × G_HALF, avec reset asynchrone.

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

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

Corrigez un process combinatoire incomplet qui mémorise une ancienne valeur quand `i_sel = "11"`.

Réalisez un compteur synchrone qui parcourt uniquement les valeurs impaires sur 4 bits.

Implémentez un compteur décrémental qui se recharge seul quand il atteint zéro.

Convertissez un code thermomètre 8 bits en nombre binaire.

Concevez un générateur séquentiel de la suite de Fibonacci sur 8 bits.

Inversez l’ordre de quatre nibbles contenus dans un mot 16 bits.

Additionnez un flux d’échantillons non signés dans un accumulateur 12 bits.

Détectez si quatre valeurs 4 bits contiennent au moins un doublon.

Calculez la différence signée entre deux échantillons 8 bits.

Accumulez un paquet d’échantillons et signalez la somme au dernier mot.

Calculez les sommes cumulées de quatre valeurs 4 bits.

Comptez les bits différents entre deux mots 8 bits.

Comptez les zéros consécutifs à partir du bit de poids faible.

Acceptez une trame si sa destination MAC est locale ou broadcast.

Vérifiez qu’une longueur de paquet est comprise dans une fenêtre autorisée.

Détectez les TPID VLAN courants et extrayez le champ TCI.

Implémentez une activation ReLU signée 8 bits.

Calculez le maximum d’une fenêtre 2x2 de pixels 8 bits.

Retournez la valeur maximale et son indice parmi quatre entrées.

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.

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

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

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

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

Convertissez un mot binaire 8 bits en trois chiffres BCD.

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

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

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

Interpolez linéairement entre quatre points fixes de table.

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

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

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

Accumulez des valeurs signées dans quatre cases scratchpad.

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

Sortez le maximum des quatre derniers échantillons valides.

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

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

Trouvez si une paire parmi quatre valeurs atteint une cible.

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

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

Recherchez une cible dans quatre valeurs triées croissantes.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Implémentez un multiplicateur IEEE-754 simple précision simplifié avec séparation mantisse/exposant.

Construisez une ROM de simulation à partir de lignes au format Intel HEX fournies par le projet.

Développez un modèle fonctionnel de compression µ-law pour un signal réel normalisé.

Modélisez une sortie DDR simple à partir de deux registres de fronts opposés.

Réalisez un chronomètre décimal secondes/dixièmes piloté par un tick externe.

Implémentez une petite FIFO 8 bits entre deux domaines d’horloge.

Implémentez une cellule IIR biquad entière à coefficients fixes.

Moyennez quatre échantillons puis sortez un échantillon décimé.

Arbitrez deux maîtres vers un port mémoire simple.

Triez quatre valeurs 4 bits avec un réseau de comparateurs inspiré du tri à bulles.

Fusionnez deux paires déjà triées en quatre sorties triées.

Calculez la médiane de cinq valeurs 4 bits.

Implémentez une convolution 1D 3 taps à coefficients fixes `1,2,1`.

Transposez une matrice 2x2 d’octets empaquetée sur 32 bits.

Mesurez la plus longue suite `+1` dans quatre valeurs déjà triées.

Calculez un neurone avec une seule unité de multiplication-accumulation réutilisée sur plusieurs cycles.

Calculez en parallèle deux neurones entièrement connectés à quatre entrées signées.

Implémentez une multiplication signée en recodant les transitions du multiplieur.

Calculez une somme ou une différence réduite dans l'intervalle de zéro à m moins un.

Calculez x fois y modulo m sur huit cycles sans multiplicateur combinatoire.

Calculez un produit modulaire dans le domaine de Montgomery avec huit itérations binaires.

Divisez deux entiers non signés avec huit étapes qui alternent soustraction et addition.