Conception logique numérique

Ceci est le troisième cours d'ingénierie électrique universitaire : logique numérique conception — comment les bits sont représentés, combinés, stockés et synchronisés à l'intérieur de chaque ordinateur. Il ne nécessite aucune connaissance préalable en électronique : les primitives sont deux niveaux de tension et une poignée de portes logiques.

• L'unité 3.1 construit les systèmes numériques : binaire, hexadécimal, complément à deux.
• Les unités 3.2–3.3 combinent la logique : algèbre de Boole, cartes de Karnaugh, blocs combinatoires blocs.
• Les unités 3.4–3.5 ajoutent le temps : verrous, bascules et machines à états horodatées.
• L'unité 3.6 enregistre les motifs : compteurs, registres à décalage, mémoire.
• L'unité 3.7 les décrit en HDL et les vérifie avec des bancs de test.

Chaque unité commence par une histoire, présente une image avant l'idée formelle, définit les termes précisément, traite deux exemples progressifs dont l'arithmétique est vérifiée par ordinateur, nomme les erreurs classiques, et se termine par un résumé de trois lignes. L'habitude de vérification de ce cours : chaque réponse booléenne est validée par résumé. L'habitude de vérification de ce cours : chaque réponse booléenne est vérifiée par évaluation exhaustive — une fonction à 3 entrées possède uniquement 8 lignes, donc vérifier toutes ces lignes, soit manuellement sur une table de vérité, soit via une boucle dans la boîte de sable.

Un thermostat affiche 22.5 °C, mais le microcontrôleur derrière lui ne possède que des bits. Comment 22.5 devient-il un motif binaire qu'une machine peut additionner, comparer et stocker ? Unité 3.1 est cette traduction, dans les deux sens.

Les ordinateurs stockent les nombres en binaire (base 2). La conversion est systématique : diviser par 2 pour les entiers (collecter les restes), multiplier par 2 pour les fractions. Hexadécimal (base 16) est un raccourci du binaire — chaque chiffre hexa vaut exactement 4 bits : $0xB = 1011$.

Dérivation du complément à deux. Nous voulons un codage où la soustraction réutilise l'additionneur : l'additionneur : $a - b = a + (b\text{ negated})$ doit contenir modulo $2^N$. L'inverse additif de $b$ modulo $2^N$ est $2^N - b = (2^N - 1 - b) + 1$ — et $2^N - 1 - b$ correspond exactement à « tous les bits de $b$ inversés » (chaque bit de poids 1 bascule vers 0 et revient). Ainsi, négation = inversion + 1, et la dérivation est la preuve que l'addition fonctionne inchangée.

Complément à deux représente les entiers signés sur N bits : inverser inverser chaque bit et ajouter 1 pour négater. En 8 bits, $-5$ correspond à $\overline{00000101}$ plus 1, ce qui équivaut à $11111011$. La plage s'étend de $-2^{N-1}$ jusqu'à $+2^{N-1}-1$ — c'est-à-dire −128 à +127 sur 8 bits. Le débordement se produit lorsque le résultat sort de la plage : l'addition de deux négatifs donnant un positif (ou inversement) constitue la règle de détection basée sur le signe ; le report hors du bit de poids fort n'est pas un débordement, mais un report différent entre le report dans le bit de poids fort et le report hors du bit de poids fort l'est. vers le bit de poids fort.

Exemple résolu 1 (convertir et vérifier). Convertir 156 en binaire : $156 = 128 + 16 + 8 + 4 = 10011100$. Vérifier en réadditionnant les poids : $128 + 16 + 8 + 4 = 156$ ✓. Le même nombre en hexadécimal : regrouper les bits par quatre depuis la droite — $1001\ 1100 = 0x9C$ ✓. Et la fraction 0.625 : multiplier par 2 → 1.25 (1), 0.25×2 → 0.5 (0), 0.5×2 → 1.0 (1) : $0.625 = 0.101_2$ ✓ ($0.5 + 0.125$).

Exemple résolu 2 (négatifs et dépassement, avancé). Encodez −100 en 8 bits : $100 = 01100100$ ; inversez $10011011$ ; ajoutez 1 → $10011100$. Vérifiez par décodeur : comme non signé, cela vaut 156, et $156 - 256 = -100$ ✓. Maintenant le cas de dépassement : $100 + 50 = 150 > 127$, donc une valeur signée sur 8 bit ne peut pas la contenir — les bits calculent $10010110$, ce qui se décode en $-106$. La règle du signe la détecte : positif + positif donne négatif ✓ (et le report entrant dans le MSB était 1 tandis que le report sortant était 0). La machine n'a pas échoué ; c'est la largeur qui a failli.

Erreurs fréquentes. Lire un complément à deux comme non signé (156 et −100 partagent des bits — l'interprète décide). Oublier la plage asymétrique : −128 existe, +128 n'existe pas. Traiter le report sortant comme un dépassement — seul le désaccord des reports compte.

Résumé : binaire↔décimal par poids et doubles ; hexa groupe par quatre ; complément à deux = inverser + 1, plage $-2^{N-1}\ldots 2^{N-1}-1$ ; le dépassement est détecté par un désaccord de signe, pas par le report sortant.

Une lumière de couloir doit être actionnable depuis chaque extrémité : deux interrupteurs, une ampoule — le XOR que l'électricien câble est une fonction booléenne. Algèbrebooléenne manipule les expressions avec ET ($\cdot$), OU ($+$), NON ($'$). Les lois imitent l'algèbre ordinaire plus absorption : $A + A\cdot B = A$ et $A\cdot (A+B) = A$. Théorème de De Morgan est l'outil principal :

— lever la barre, changer l'opérateur.

La carte de Karnaugh organise une table de vérité pour que les cases adjacentes diffèrent d'une variable (ordre de Gray) ; groupes de 1, 2, 4, 8 cases (puissances de deux, (rectangles) se lisent comme des termes produit.

Exemple résolu 1 (la fonction impaire). La fonction à 3 variable $F = \sum m(1, 3, 5, 7)$ (les lignes impaires) correspond à une paire de colonnes — chaque case où $C = 1$ — donc $F = C$ directement : les quatre mintermes partagent uniquement $C$. Le vérification : évaluer $C$ contre toutes les 8 lignes originales ; il correspond exactement (vérifié par ordinateur). Indifférents (combinaisons d'entrées impossibles) peuvent joindre n'importe quel groupe — utilisez-les pour agrandir les groupes, jamais pour en créer de nouveaux.

Exemple résolu 2 (la majorité à 4 variables, vérifiée par ordinateur, étendue). La fonction de majorité $M(A,B,C,D)$ est 1 lorsque trois entrées ou plus sont 1 : ses mintermes sont $\sum m(7, 11, 13, 14, 15)$. Regroupement sur la carte de Karnaugh à 4 variables : quatre paires chevauchantes, chacune partageant $m_{15}$, donnent $ABC + ABD + ACD + BCD$, qui se factorise vers $M = A\cdot B\cdot(C + D) + C\cdot D\cdot(A + B)$. Vérification machine : évaluer à la fois la définition (compter $\geq 3$) et la expression sur toutes les 16 lignes — ils concordent partout ✓. Remarquez la forme de la réponse : la carte donne quatre produits à entrées 3 au lieu d'une somme de mintermes uniformes 5, et la factorisation en deux produits économise des portes supplémentaires.

Erreurs courantes. Regrouper des cases diagonales (les cases doivent être des rectangles dans le enroulement Gray-code, donc les bords se touchent). Écrire un terme de groupe à partir de variables qui changent à l'intérieur du groupe — seules les constantes subsistent. Faire confiance à une simplification non vérifiée : la vérification sur les 16 lignes est gratuite.

Résumé : Les lois booléennes et De Morgan transforment les expressions ; les cartes de Karnaugh regroupent les rectangles de puissances de deux dans l'ordre de Gray ; les groupes conservent uniquement les variables constantes ; les « ne m'importe pas » élargissent mais ne créent jamais ; vérifiez exhaustivement chaque simplification.

Une distribute automatique sert l'un de quatre boissons par deux appuis sur des boutons : ce sélecteur, le décodeur derrière l'affichage, l'additionneur à l'intérieur de la logique du change — les blocs combinatoires constituent la couche intermédiaire réutilisable entre les portes et les systèmes. Les portes logiques s'assemblent en blocs de logique combinatoire standards dont le comportement est une fonction pure des entrées actuelles :

• Multiplexeur (MUX) : sélecteur de données de $2^n$ vers 1 ; les n bits de sélection choisissent une seule entrée. $Y = \sum (D_i \cdot minterm_i(selects))$.
• Décodeur : n entrées vers $2^n$ sorties, exactement une haute — générateur de mintermes.
• Additionneur : un demi-additionneur additionne deux bits ($S = A \oplus B$, retenue $C = A\cdot B$) ; un plein additionneur additionne trois (deux opérandes plus retenue d'entrée) : $S = A \oplus B \oplus C_{in}$, $C_{out} = A\cdot B + C_{in}\cdot (A \oplus B)$.

Exemple résolu 1 (le MUX et l'additionneur, vérifiés). Un MUX de 4 vers 1 avec sélection $S_1S_0 = 10$ sort $D_2$ — le poids décimal du code de sélection nomme l' entrée de données. Vérification du plein-additionneur à $A=1, B=1, C_{in}=1$ : $S = 1\oplus 1\oplus 1 = 1$, $C_{out} = 1 + 1\cdot 0 = 1$ — trois uns en entrée, binaire 11 en sortie (somme 1, retenue 1) : $3 = 2 + 1$ ✓.

Exemple résolu 2 (un additionneur à propagation bit à bit de 2 bits, vérifié machine, escaladé). Chaînez deux pleins additionneurs : le premier additionne les bits de poids faible, sa retenue alimente le second. En ajoutant $11_2 + 01_2$ ($3 + 1$) : les bits de poids faible $1 + 1$ donnent $S_0 = 0$, retenue 1 ; haut les bits $1 + 0 + 1$ produisent $S_1 = 0$, report 1 — sortie $100_2 = 4$ ✓ (machine vérifiée par les quatre paires d'entrées à chaque étape). Le motif s'étend exactement : un additionneur n-bit est composé de n additionneurs complets et rien d'autre, et le report propage à travers lui — ce qui constitue également sa limite de vitesse, fixée ultérieurement par l'avancée du report.

Les hazards sont des parasites temporaires en sortie lorsque les changements d'entrées empruntent des chemins ; ils sont importants car un glissement peut être capté au bord d'horloge. La solution est le regroupement redondant (en conservant la couverture du risque) — les détecter par énumération lorsque la spécification interdit les glissements.

Erreurs courantes. Lire un MUX à l'envers (la sélection choisit les données, pas la valeur de la sortie). Oublier la direction de la chaîne de report dans les additionneurs à propagation. Considérer un risque comme une erreur logique — la valeur finale est correcte ; le transitoire est le bug.

Résumé : le MUX sélectionne via un code pondéré, le décodeur génère des mintermes, l'additionneur complet = cinq portes sommant trois bits ; les chaînes à propagation s'étendent par répétition ; les risques sont transitoires, et la couverture redondante les élimine.

Une sonnette se souvient qu'elle a été pressée après que le doigt l'a quittée — la mémoire la plus simple est la rétroaction. Logique séquentielle possède un état — mémoire. Un verrou est sensible au niveau : le verrou SR (NOR croisés) se souvient quel entrée a pulsé ; le verrou D suit D tant que ENABLE est haut, il fige lorsque bas. Basculants sont déclenchés sur front : le bascule D échantillonne D au front d'horloge et le maintient jusqu'au prochain front — Q après le front est égal à D avant celui-ci.

La bascule J-K supprime l’état interdit du SR : $J=K=1$ inverse ($Q'$ suivant). La table d'excitation procède dans l'autre sens : étant donné une transition souhaitée $Q \to Q^+$, elle énumère les entrées requises (D : $D = Q^+$ ; J-K : maintenir $0{,}0$, définir $1{,}0$, réinitialiser $0{,}1$, basculer $1{,}1$).

Exemple résolu 1 (lire le diagramme temporel). Un bascule D voit $D = 1$ à premier front montant, $D = 0$ au deuxième, $D = 1$ au troisième : Q prend les valeurs 1, 0, 1. Entre les fronts, D peut fluctuer librement — rien n'est échantillonné. Les diagrammes temporels rendent cela visible : Q ne change qu'aux instants de front.

Exemple résolu 2 (la séquence J-K, tracée machine, amplifiée). Partir de Q = 0, appliquer $J,K$ = (1,0), (1,1), (0,1), (0,0). Étape par étape : (1,0) met à → 1 ; (1,1) inverse → 0 ; (0,1) remet à → 0 ; (0,0) maintient → 0. Q affiche 1, 0, 0, 0 (tracé machine ✓). L'usage du design : les tables d'excitation fonctionnent dans le sens inverse — pour construire un compteur qui passe de 0 → 1 → 0 → 0 → 0, lire chaque réinitialiser, maintenir). Le choix de la bascule est une simple consultation, pas un casse-tête. Erreurs courantes. Échantillonnage sur le mauvais front (descendant ou montant — la spécification indique lequel). Confondre verrou et bascule : un verrou est transparent pendant tout un niveau, une bascule uniquement à un instant précis. S'attendre à ce que Q

change dès que D le fait — Q attend le front. Résumé : les verrous sont transparents sur niveau, les bascules déclenchées par front ; Q après le transparent sur tout un niveau, une bascule uniquement à un instant. S'attendre à ce que Q change dès que D change — Q attend l'impulsion.

Résumé : les verrous sont transparents au niveau, les bascules déclenchées par impulsion ; Q après la frontière = D avant ; J-K élimine l'état interdit par bascule ; excitation les tables inversent le comportement en entrées requises.

Une distribute automatique rejette une séquence de pièces acceptée hier — non pas parce que les pièces ont changé, mais parce que la séquence est différente. Les séquences nécessitent une machine avec mémoire de son état actuel : une machine à états finis (FSM) comporte des états + transitions : un diagramme d'états (bulles et flèches étiquetées), réalisé sous forme de logique d'état suivant + registres d'état + logique de sortie. Les machines Moore calculent les sorties uniquement à partir de l'état (les sorties changent après l'horloge) ; les machines Mealy calculent à partir de l'état et des entrées (les sorties peuvent changer en cours de cycle, plus tôt mais sujettes aux glissements).

Exemple résolu 1 (détecteur de parité, traçage). Activer une sortie lorsque le nombre de 1 vus est impair. Deux états (EVEN, ODD) ; chaque bit d'entrée fait passer la machine entre ces états ; sortie = (état == ODD). Séquence 1, 0, 1, 1 : EVEN → ODD → ODD → EVEN → ODD, donc la sortie après le quatrième bit est 1 (trois 1 vus — impair ✓ traçage machine). Procédure de conception : diagramme d'états → table d'états → codage (binaire) codage des états → table d'excitation pour chaque bascule → minimisation de la logique d'état suivant. Avec un seul bit d'état ($0$ = EVEN, $1$ = ODD), la logique d'état suivant est une XOR unique : $Q^+ = Q \oplus in$ — la machine est elle-même un bit de parité.

Exemple résolu 2 (le détecteur 1011, amélioré). Détecter la séquence série 1011 (chevauchement). Les états suivent le préfixe le plus long correspondant : S0 (départ), S1 (vu 1), S10 (vu 10), S101 (vu 101). Chaque transition mène à la queue la plus longue de l'entrée jusqu'à présent qui reste un préfixe de 1011 :

Depuis S101, un 1 complète 1011 : la sortie indique détecté et la machine passe à S1, car le « 1 » final commence déjà la prochaine correspondance (le chevauchement). Un 0 depuis S101 laisse « 1010 », dont la queue « 10 » est un préfixe, donc elle va vers S10, pas vers S0. Quatre états nécessitent deux bascules ($2^2 = 4$ ✓). Tracez le flux 1,0,1,1,0,1,1 : S0→S1→S10→S101→détection (S1), puis 0→S10, 1→S101, 1→détection à nouveau. Le flux contient deux copies chevauchantes, aux bits 1–4 et 4–7, et la machine les trouve toutes deux (trace machine ✓). Un détecteur qui redémarre à S0 après une correspondance manquerait la seconde. Minimisation des états fusionne les états équivalents (même sorties, mêmes états suivants) — un FSM avec des états redondants fonctionne mais gaspille des bascules et de la logique.

Erreurs courantes. Oublier la réinitialisation du chevauchement (un suffixe correspondant est le le préfixe de la correspondance suivante). Encodage des états avant vérification de la table d'état pour des états équivalents. Choisir Moore lorsque la spécification nécessite une réponse sur le même cycle (Mealy), ou Mealy lorsque les sorties alimentent une logique asynchrone (glitches).

Résumé : états + transitions + sorties ; Moore à partir de l'état, Mealy à partir de l'état et de l'entrée ; diagramme → tableau → codage → excitation → minimiser ; détection de chevauchement et fusion d'états sont là où les points sont gagnés ou perdus.

Un tableau de bord affiche 7, puis 8 — un seul nombre a changé tandis que le reste est resté stable : que cette mise à jour sélective est un registre, et que le comptage est un registre qui se met à jour lui-même. Un registre est un ensemble de bascules partageant une horloge : chargement de n bits par front d'horloge. Un registre à décalage transmet les bits séquentiellement : entrée série, sortie série (prochain) ; un compteur synchrone alimente toutes les horloges depuis un seul front retarde un flux de bits ; entrée série sortie parallèle convertit du série vers du parallèle.

Un compteur asynchrone enchaîne des bascules T (la sortie de chacune alimente l' et calcule chaque bascule par la logique — sans délai cumulatif. et calcule chaque bascule avec logique — aucun délai cumulatif.

Exemple résolu 1 (le compteur ascendant à 3 bits, tracé). Un compteur ascendant synchrone à 3 bits bascule le bit 0 à chaque horloge, le bit 1 lorsque $Q_0 = 1$, le bit 2 lorsque $Q_1\cdot Q_0 = 11$ : après RÉINITIALISATION, les comptes s'écoulent 000, 001, 010, 011 … 111, then roll to 000 (8 states = $2^3$ ✓ — the count range check; signifie. — un compteur binaire incrémente lorsque tous les bits inférieurs valent 1, ce qui correspond à l'opération « ajouter 1 ». signifie.

Exemple résolu 2 (compteur mod-6, étendu). Un compteur mod-6 compte de 000–101 et retour à 000 — six états, pas huit. Pour une implémentation synchrone implémentation, choisir l'état suivant 000 lorsque le mot actuel est 101, 110 ou 111 ; sinon ajouter 1. Trace : 000, 001, 010, 011, 100, 101, puis 000. Ainsi 101→000 se produit à la prochaine front d'horloge ; soit un code inutilisé 110 ou 111 se rétablit également à 000 au front suivant. La condition $Q_2\cdot Q_1$ détecte seuls 110 et 111. Il est 0 à 101, donc utiliser cette seule condition pour choisir l'état suivant 000 permettrait encore de conserver un 110 stocké après 101. Réinitialisation asynchrone est une implémentation différente : elle peut brièvement atteindre 110 avant la réinitialisation, elle ne doit donc pas être décrite comme ce saut synchrone. Mémoire est un tableau organisé : k bits d'adresse sélectionnent l'un des $2^k$ mots de m bits — un 8K×8 possède 13 lignes d'adresse et 8 lignes de données ($8K = 2^{13} = 8192$ mots ✓).

Erreurs courantes. Les compteurs en cascade ont l'air corrects à basse vitesse mais échouent au spécification ; le délai cumulé est par étage. Oublier de gérer les états non utilisés dans les compteurs mod-N (ils doivent revenir à un état valide). Confondre les conventions de direction du décalage (MSB-first vs LSB-first série).

Résumé : les registres chargent sur front commun ; les registres à décalage convertissent entre série et parallèle ; les compteurs synchrones calculent les bascules via logique ; mod-N nécessite la gestion des états inutiles ; la mémoire contient $2^k$ mots de m bits, avec k lignes d'adresse.

Câbler 64 portes manuellement invite aux erreurs 64 ; la réponse de l'industrie ne consiste pas en un dessin plus soigné mais en une description suivie de vérifications. Un langage de description matérielle (Verilog/VHDL) décrit la structure et le comportement sous forme de code synthétisable — ce qui peut devenir des portes — séparé du testbench, qui simule mais ne devient jamais matériel.

module full_adder(input a, b, cin, output sum, cout);
  assign sum  = a ^ b ^ cin;
  assign cout = (a & b) | (cin & (a ^ b));
endmodule

Exemple résolu 1 (banc de test exhaustif). Le banc de test applique toutes les 8 combinaisons d'entrées et les compare à la vérité arithmétique ($a + b + cin = 2· cout + somme$) — vérifié par machine : tous les 8 passent ✓. La propriété est le point : le modèle de référence est arithmétique, et non une autre description de porte, donc la vérification est indépendante de l'implémentation.

Exemple résolu 2 (registre à décalage en HDL, étendu). Décrire un registre à décalage serial-in sur 4 bit : registre à décalage à entrée série :

module shift4(input clk, sin, output reg [3:0] q);
  always @(posedge clk) q <= {q[2:0], sin};
endmodule

La concaténation {q[2:0], sin} est le décalage — l'entrée entre par la droite, sortie tombe à gauche. Le banc de test applique sin = 1,0,1,1 sur quatre impulsions d'horloge et la trace affiche q = 0001, 0010, 0101, 1011 ✓ (simulé machine) — registre à décalage de l'unité 3.6, maintenant décrit par quatre lignes.

Erreurs courantes. Bancs d'essai qui réitérent l'implémentation (une copie ne prouve rien). Constructeurs non synthétisables dans des modules matériels. Oubli ne prouve rien). Constructs non synthétisables dans les modules matérielles. Absence de réinitialisations dans les blocs always — l'erreur de l'unité 3.6 se reproduit.

Résumé : module synthétisable vs banc d'essai non synthétisable, toujours séparés ; le modèle de référence doit être indépendant (arithmétique ou trace) ; vérifications exhaustives pour les petits espaces d'entrées ; livrer les modules avec leur preuve. vérifications exhaustives pour les petits espaces d'entrées ; livrez les modules avec leur preuve.