#Logique numérique et interfacesCopier le lien

Les circuits logiques relient le monde analogique (capteurs, boutons) aux systèmes numériques (microcontrôleurs, FPGA). Cette page couvre le cœur du SPUE100 : codage de l’information, portes, tables de vérité, simplification par Karnaugh, bascules, registres et machines à états, jusqu’à la conversion analogique-numérique. Comprendre seuils de tension et synchronisation évite les erreurs coûteuses, du FPGA au simple bouton poussoir.

Prérequis : bases de numération (binaire, hexadécimal) et page composants passifs pour le filtrage. Objectifs : analyser et synthétiser un système combinatoire, simplifier par Karnaugh, décrire bascules et registres, construire une machine à états simple, et dimensionner une chaîne d’acquisition complète.

#Codage de l’informationCopier le lien

Une grandeur physique devient exploitable une fois codée en bits. Sur n bits non signés, on représente 2ⁿ valeurs, de 0 à 2ⁿ − 1. Le complément à deux code les signés sur n bits : le bit de poids fort vaut −2ⁿ⁻¹, les autres +2^k. Sur 8 bits, 1111 1111 vaut −1 et 1000 0000 vaut −128. L’addition se fait alors avec le même additionneur que pour les non signés, la seule différence étant la détection du débordement : il y a débordement si deux opérandes de même signe donnent un résultat de signe opposé. Les codes pondérés voisins servent l’affichage : BCD code chaque chiffre décimal sur 4 bits, et le code de Gray change un seul bit entre valeurs successives, propriété exploitée par les codeurs de position pour éviter les lectures transitoires fausses.

#Pourquoi la règle du complément à deuxCopier le lien

Le format est fixé à n bits et toute retenue qui sort du format est perdue : les opérations se font donc modulo $2^n$. Pour trouver le code $y$ de $-X$ connaissant le code $x$ de $X$, on écrit $x + y \equiv 0 \bmod 2^n$, soit $y \equiv 2^n - x \bmod 2^n$. Or $\sum_{i=0}^{n-1} 2^i = 2^n - 1$, donc $2^n = \sum_{i=0}^{n-1} 2^i + 1$ et

$y \equiv \sum_{i=0}^{n-1} 2^i + 1 - \sum_{i=0}^{n-1} x_i 2^i = \sum_{i=0}^{n-1} (1 - x_i)\, 2^i + 1 \bmod 2^n .$

Sur les deux valeurs 0 et 1, $1 - x_i$ vaut exactement le complément logique $\overline{x_i}$ : le terme $\sum_{i} (1 - x_i) 2^i$ est le mot inversé bit à bit, auquel il reste à ajouter 1. La règle est donc démontrée, et la démonstration ne sépare jamais le bit de signe des autres : ce bit se traite comme n'importe quel autre.

L'exception à connaître. La démonstration suppose que $-X$ soit codable. Or l'échelle du binaire signé va de $-2^{n-1}$ à $2^{n-1}-1$ : la valeur $-2^{n-1}$ n'a pas d'équivalent positif. Lui appliquer la règle du complément à deux redonne le même mot (1000 0000 sur 8 bits reste 1000 0000) : l'opération ne l'a pas changé. Pour tout le reste de l'intervalle, deux applications successives redonnent bien la valeur de départ.

#Étendue de l'échelle de numérotationCopier le lien

Connaître le format est indispensable quel que soit le codage, car c'est lui qui fixe les valeurs représentables. Sur n bits il existe $2^n$ combinaisons, donc $2^n$ valeurs distinctes.

En binaire naturel, le −1 vient de ce que la combinaison « tout à zéro » occupe déjà une place. En binaire signé, le bit de poids fort est pris par le signe : il reste $n-1$ bits pour la valeur, et le zéro consomme une des combinaisons positives, d'où la dissymétrie entre $-128$ et $+127$. En DCBN, le raisonnement change de base : chaque groupe de 4 bits porte un chiffre décimal, donc $N = n/4$ groupes portent $10^N$ valeurs — c'est cette échelle réduite (99 au lieu de 255 sur un octet) qui paie la lisibilité.

#DCBN : lisible, mais coûteux en calculCopier le lien

Le décimal codé binaire naturel code chaque chiffre décimal séparément sur 4 bits : 754 se code 0111 0101 0100. Le codage est direct et l'affichage immédiat, mais l'arithmétique devient pénible, car les poids ne sont plus des puissances de 2 : un groupe de 4 bits vaut $2^3 \cdot 10^k$ pour les bits internes au groupe, et $10^k$ pour le poids du groupe. Une addition en DCBN exige donc une correction (ajustement décimal) en plus de la retenue binaire. C'est pourquoi ce code vit dans les interfaces — roue codeuse, afficheur sept segments — et non dans les unités de calcul.

#Code de Gray : un seul bit à la foisCopier le lien

Le code binaire réfléchi (Gray) ne change qu'un seul bit entre deux valeurs successives, et il est cyclique : la dernière valeur et la première ne diffèrent elles aussi que d'un bit. On le construit récursivement — le code $G_n$ s'écrit en prenant $G_{n-1}$ précédé d'un 0, puis $G_{n-1}$ à l'envers précédé d'un 1 :

Cette propriété le destine aux capteurs de position : si deux pistes changeaient en même temps, une lecture pendant la transition pourrait donner une valeur arbitraire ; avec le code de Gray, une seule piste change à la fois, donc la lecture transitoire est au pire l'une des deux valeurs voisines, jamais une valeur aberrante. Comme le code est cyclique, faire « tourner » la table — déplacer la première ligne en dernière position — redonne encore un code de Gray : c'est exactement la question posée à l'examen 2024-2025.

#Détecter et corriger les erreursCopier le lien

Le codage binaire est robuste au bruit parce qu'on ne s'intéresse qu'à la présence ou à l'absence de signal, mais un bit peut malgré tout basculer. Le bit de parité ajoute un bit au message :

• parité impaire : le bit ajouté vaut 1 si la somme des bits du message est paire, de sorte que le mot transmis contienne toujours un nombre impair de 1 ;
• parité paire : convention inverse, le mot transmis contient toujours un nombre pair de 1.

Le récepteur recompte les 1 : un compte qui ne respecte plus la convention signale une erreur. Trois limites à retenir. D'abord la parité ne localise pas l'erreur : elle dit « il y a une erreur », pas « au bit 5 ». Ensuite elle est aveugle aux erreurs paires : deux bits inversés rétablissent la parité. Enfin son efficacité est statistique : si un bit a une probabilité p d'être faux, la probabilité d'en avoir deux faux est p² pour des bits indépendants — négligeable devant p. Le bit de parité peut être placé en tête ou en queue du message, à condition que l'émetteur et le récepteur en conviennent.

Un code auto-correcteur va plus loin : il place plusieurs bits de contrôle de façon que le motif des contrôles faux — le syndrome — désigne le bit erroné, qu'on corrige alors sans retransmettre. Le code de Hamming sur 4 bits de données est le cas d'école : on émet D3 D2 D1 P2 D0 P1 P0 avec

$P_2 = \text{Fip}(D_1, D_2, D_3), \qquad P_1 = \text{Fip}(D_0, D_2, D_3), \qquad P_0 = \text{Fip}(D_0, D_1, D_3),$

où « Fip » est la fonction d'imparité : elle vaut 1 lorsque le nombre d'entrées à 1 est impair. À la réception, on recalcule les mêmes fonctions en y incluant les bits de contrôle reçus :

$R_2 = \text{Fip}(P_2', D_1', D_2', D_3'), \quad R_1 = \text{Fip}(P_1', D_0', D_2', D_3'), \quad R_0 = \text{Fip}(P_0', D_0', D_1', D_3').$

Le triplet $(R_2 R_1 R_0)$ lu en binaire donne la position du bit erroné comptée depuis la droite, le bit de droite P0 portant le numéro 1 — puis P1 le numéro 2, D0 le 3, P2 le 4, et ainsi de suite jusqu'à D3 au numéro 7. Un syndrome nul signifie « pas d'erreur ». Le TD 2 du SPUE100 fait dérouler le calcul complet sur quatre mots et vérifie ce décodage. Un code bien conçu détecte donc une erreur et la corrige : c'est le principe des CD-ROM musicaux, qui codent 16 bits utiles sur 24 bits réels.

#Niveaux logiques et famillesCopier le lien

Une entrée numérique interprète une tension selon deux seuils : V_IL (tension maximale encore lue comme 0) et V_IH (tension minimale lue comme 1). Entre les deux s’étend la zone indéterminée : une tension qui s’y trouve produit un résultat imprévisible. En TTL 5 V classique, V_IL ≈ 0,8 V et V_IH ≈ 2 V ; en CMOS alimenté en 5 V, les seuils montent vers 1,5 V et 3,5 V, et suivent la moitié de la tension d’alimentation. Conséquence directe : une sortie TTL (0,4 V / 3,4 V typiques) pilote une entrée CMOS 5 V dans la zone grise ; il faut un pull-up, un buffer ou une famille à seuils compatibles. En 3,3 V, la plupart des familles logiques modernes acceptent des entrées 5 V tolérantes, mais vérifiez la mention « 5 V tolerant » dans la fiche technique avant de mixer.

Les sorties ont aussi des limites de courant (source et sink, typiquement ±4 mA en TTL, ±20 mA et plus en CMOS moderne) à ne pas dépasser ; au-delà, les niveaux se dégradent et le boîtier vieillit prématurément.

#Portes logiques et tables de véritéCopier le lien

Les portes NOT, AND, OR, NAND, NOR, XOR, XNOR composent toute fonction booléenne. NAND et NOR sont universelles : chacune seule suffit à construire les autres, ce qui explique leur omniprésence en technologie CMOS (une NAND = 4 transistors).

Manipulez les entrées A et B : le schéma, la table de vérité et l’expression booléenne se mettent à jour ensemble. Ligne par ligne, vérifiez sur papier au moins la porte XOR et la porte NAND avant de regarder le résultat : c’est le geste qui installe les tables pour de bon. Notez la symétrie : NAND est le complément exact de AND, NOR celui de OR, XNOR celui de XOR.

Le constructeur de tables invite à l’exercice inverse : partir d’un énoncé (« la sortie vaut 1 si exactement deux des trois entrées valent 1 ») et remplir la table, puis la comparer à la table générée. Cette démarche, de l’énoncé vers la table puis vers les équations, est exactement celle des TD 1 à 4 du SPUE100.

#Algèbre de Boole et simplificationCopier le lien

Les identités utiles : A · 1 = A, A + 1 = 1, A · A = A, A + Ā = 1, plus les lois de De Morgan ¬(A · B) = Ā + B̄ et ¬(A + B) = Ā · B̄. Ces dernières permettent de changer de technologie : une équation en ET/OU se réalise en NAND/NAND pur ou NOR/NOR pur en complémentant deux fois et en appliquant De Morgan.

La table de Karnaugh réarrange la table de vérité en grille où deux cases adjacentes ne diffèrent que d’un bit ; les regroupements de 1, 2, 4, 8 cases adjacentes (puissances de deux, rectangle sans trou) donnent directement les termes simplifiés. Exemple : la fonction majorité sur trois entrées F = 1 si au moins deux entrées valent 1. Sa table comporte quatre 1, qui se regroupent en trois paires, d’où F = AB + AC + BC. Trois termes de deux lettres au lieu de quatre mintermes de trois lettres : l’économie se paie en portes, en surface de silicium et en délai.

Méthode fiable : lister les mintermes, remplir la grille de Karnaugh (attention à l’ordre de Gray des lignes et colonnes : 00, 01, 11, 10), chercher les plus grands regroupements d’abord, accepter les recouvrements, puis relire chaque groupe comme un produit où ne figurent que les variables constantes.

#L’axiomatique et les théorèmesCopier le lien

L’ensemble $\mathbb{B} = \{0, 1\}$ muni de ET, OU et NON forme une algèbre de Boole : il vérifie dix axiomes — commutativité et associativité de + et de ., distributivité de . sur + ($x(y+z) = xy + xz$), distributivité de + sur . ($x + yz = (x+y)(x+z)$, propre à cette algèbre et fausse en arithmétique), éléments neutres ($x + 0 = x$, $x \cdot 1 = x$) et complémentation ($x + \bar{x} = 1$, $x \cdot \bar{x} = 0$). À chaque propriété sur le OU correspond une propriété « de même forme » sur le ET : on dit que les deux opérateurs sont duaux. De ces axiomes se déduisent les théorèmes d’usage courant :

Démontrer ces théorèmes est un exercice d’algèbre moins trivial qu’il n’y paraît, et l’ordre des étapes compte. L’idempotence $x + x = x$ se démontre en partant de $x$ et en n’utilisant que les axiomes :

$x = x + 0 = x + x\bar{x} = (x + x)(x + \bar{x}) = (x + x) \cdot 1 = x + x .$

En revanche la démonstration « $x = x \cdot 1 = x(1 + 1) = x + x$ » est fausse : elle utilise $x + 1 = 1$, qui se déduit de l’idempotence et suppose donc le résultat. Ce piège de raisonnement circulaire est explicitement signalé dans le polycopié.

#Absorption et consensus par les couverturesCopier le lien

Un impliquant de $f$ est un produit dont l’évaluation à 1 entraîne celle de $f$ ; la couverture $\complement_f$ est l’ensemble des mintermes qui forcent $f$ à 1. Absorption et consensus se démontrent alors par simple inclusion d’ensembles :

$P + P' = P \iff \complement_{P'} \subset \complement_P, \qquad P + P' + P'' = P + P'' \iff \complement_{P'} \subset \complement_P \cup \complement_{P''}.$

Le consensus en est le cas d’école : $\complement_{xy} = \{xy\bar{z},\, xyz\}$, $\complement_{\bar{x}z} = \{\bar{x}yz,\, xyz\}$ et $\complement_{yz} = \{xyz,\, \bar{x}yz\}$ ; comme $\complement_{yz} \subset \complement_{xy} \cup \complement_{\bar{x}z}$, le terme $yz$ est absorbé « à moitié » par chacun des deux autres. C’est la démonstration demandée au TD 4.

#L’impasse de la simplification algébriqueCopier le lien

Simplifier consiste à alterner des regroupements de produits (distributivité et complémentation) et des absorptions (idempotence comprise) jusqu’à obtenir une somme d’impliquants premiers. Une expression peut sembler « simplifiée au mieux » et ne plus l’être du tout : c’est l’impasse classique. Ainsi $f = xy + \bar{x}y\bar{z}$ paraît terminée, alors que

$xy + \bar{x}y\bar{z} = xy\bar{z} + xy\bar{z} + \bar{x}y\bar{z} = xy + y\bar{z}.$

Il faut donc parfois redévelopper avant de mieux simplifier — exactement ce que fait une table de Karnaugh sans qu’on y pense. C’est le principal argument en faveur de la méthode graphique.

#Les fonctions insimplifiables : les damiersCopier le lien

Il existe exactement deux fonctions de $n$ variables qu’aucune simplification ne peut réduire : le OU exclusif de toutes les variables et son complément. Elles vérifient $\text{card}(\complement_F) = \text{card}(\complement_G) = 2^{n-1}$, et chaque produit diffère d’au moins deux variables de tout autre produit. Sur trois variables, $F(a,b,c) = a \oplus b \oplus c$.

En Karnaugh, ces fonctions forment un damier : aucune case n’est adjacente à une case de même valeur, on ne peut donc former que des groupes de 1. La seule écriture compacte est l’opérateur OU exclusif. À retenir aussi : le XOR est un comparateur binaire — $x \oplus y$ vaut 1 si $x$ et $y$ diffèrent, et son complément $x\bar{y} + \bar{x}y$ vaut 1 s’ils sont égaux.

#Impliquants premiers et essentielsCopier le lien

• Impliquant premier : produit impliquant de $f$ qu’on ne peut plus simplifier avec un autre produit.
• Impliquant premier essentiel : impliquant premier qui absorbe au moins un minterme que aucun autre impliquant premier n’absorbe.

La règle de lecture d’un Karnaugh en découle : couvrir d’abord les mintermes par les impliquants premiers essentiels, puis compléter par des impliquants premiers non essentiels. Deux situations à distinguer nettement. Si la somme des essentiels ne couvre pas toute la fonction, il faut choisir en plus des non essentiels, et ce choix peut ne pas être unique : plusieurs expressions de même coût représentent alors la même fonction. Si au contraire aucun impliquant premier n’est essentiel — chaque 1 est couvert par au moins deux impliquants premiers — toutes les formes minimales se valent et le choix est arbitraire.

#Les indifférentsCopier le lien

Une fonction non complètement spécifiée (FNCS) n’est pas définie pour certaines combinaisons d’entrées : on note ces cases X ou φ, ce sont les indifférents. Ils traduisent presque toujours une contrainte du monde physique — deux capteurs jamais actifs en même temps, un afficheur sept segments qui ne reçoit jamais les codes DCBN 1010 à 1111.

Leur usage est encadré par une règle stricte : un indifférent ne s’intègre à la simplification que s’il permet d’agrandir un regroupement déjà existant. L’erreur courante consiste à créer un regroupement nouveau pour couvrir un indifférent : même grand, il est inutile — la fonction était déjà couverte — ou nuisible, puisqu’il complique l’expression. Dans un Karnaugh, un indifférent isolé reste donc à 0.

#Limites des tables de KarnaughCopier le lien

Jusqu’à 4 variables, le Karnaugh est un outil parfait. À partir de 5, et surtout de 6 variables, il atteint ses limites à cause du code de Gray : sur un code de Gray à trois bits, deux codes séparés d’un seul bit ne sont pas toujours adjacents (001 et 101, par exemple). Un produit tel que $f_5 = b\bar{e}$ se retrouve alors coupé en deux morceaux sur la grille, qu’il faut relier mentalement ; à 6 variables il peut être coupé en quatre. Conclusion pratique : Karnaugh donne une vue graphique des règles algébriques et une représentation synthétique de la fonction jusqu’à 5 variables environ, et devient inutilisable au-delà de 6. Les outils logiciels utilisent alors d’autres représentations, comme les diagrammes de décision binaires (BDD).

#Multiplexeurs et démultiplexeursCopier le lien

Un multiplexeur fait circuler sur un seul conducteur des informations provenant de sources multiples : c’est un aiguillage. Avec $n$ entrées de sélection $S_{n-1} \ldots S_0$, il possède $2^n$ entrées de données $E_i$ et sa sortie s’écrit directement à partir des mintermes :

$Y = \sum_{i=0}^{2^n-1} E_i \, m_i, \qquad \text{où } m_i \text{ est le minterme de } (S_{n-1} \ldots S_0) \text{ égal à } i .$

Pour un multiplexeur 4 vers 1 : $Y = \bar{S_1}\bar{S_0}E_0 + \bar{S_1}S_0E_1 + S_1\bar{S_0}E_2 + S_1S_0E_3$.

Cette écriture est exactement la forme canonique disjonctive d’une fonction booléenne. D’où la propriété fondamentale : tout multiplexeur est un générateur de fonction. Si les entrées de sélection reçoivent les variables de la fonction et les entrées de données les bits de la table de vérité, le multiplexeur est la fonction — sans aucune simplification. On exploite cela directement en TD 6.

Quand le multiplexeur n’a pas assez d’entrées de sélection, on choisit un sous-ensemble de variables comme variables de sélection et on synthétise chaque entrée $E_i$ à partir des variables restantes : la table de vérité est réduite aux lignes où les variables de sélection valent $i$, et l’équation obtenue ne dépend plus que des autres variables. L’inconvénient est que le choix des variables de sélection est arbitraire : trouver l’optimum demande de tester toutes les affectations.

Le démultiplexeur fait l’opération inverse : une entrée, $2^n$ sorties, une seule étant reliée à l’entrée (les autres sont soit en haute impédance, soit fixées à un niveau logique). Utilisé comme décodeur, il est aussi un générateur de mintermes : chaque sortie $Y_i$ vaut 1 exactement pour la combinaison d’adresse $i$. Il suffit alors d’un OU pour sommer les mintermes voulus et réaliser n’importe quelle fonction — la troisième réalisation demandée au TD 6.

#Circuits arithmétiquesCopier le lien

#Additionneur completCopier le lien

Pour additionner deux nombres de $n$ bits, on procède rang par rang comme en décimal. À chaque rang $i$ on calcule la somme modulo 2 de $X_i$, $Y_i$ et de la retenue entrante $R_{i-1}$, ainsi que la retenue sortante :

$S_i = X_i \oplus Y_i \oplus R_{i-1}, \qquad R_i = X_i Y_i + R_{i-1}(X_i \oplus Y_i).$

La seconde équation s’écrit aussi $R_i = R_{i-1} P_i + G_i$ avec $P_i = X_i + Y_i$ (terme de propagation) et $G_i = X_i Y_i$ (terme de génération). Cette cellule élémentaire se duplique $n$ fois : c’est l’additionneur à propagation de retenue.

Le point faible est justement la propagation : la retenue doit traverser toutes les cellules. Si une porte introduit un délai $T$, un additionneur à $n$ cellules met $2nT$ (entrées à 2 entrées) à produire $S_n$. L’additionneur à retenues anticipées calcule toutes les retenues directement à partir des entrées, en déroulant la récursion $R_1 = X_1 R_0 + Y_1 R_0 + X_1 Y_1$, puis $R_2$, etc. Les équations deviennent vite volumineuses, mais elles s’écrivent toujours comme des sommes de produits : le chemin critique ne traverse donc que deux couches de portes, et le temps de calcul devient constant — de l’ordre de $4T$ quel que soit $n$. Le prix à payer est une explosion du nombre de portes, ce qui n’est plus un obstacle avec les densités d’intégration actuelles.

#Indicateurs de validitéCopier le lien

Deux indicateurs accompagnent les opérations :

• CARRY (retenue) : la dernière retenue a été levée ;
• OVERFLOW (dépassement) : le résultat ne tient pas dans le format.

Sur des nombres non signés de $n$ bits, carry et overflow désignent la même chose : la retenue la plus à gauche sort du format, donc $\text{carry} = \text{overflow} = R_{n-1}$. Sur des nombres signés, le carry reste $R_{n-1}$ par définition, mais l’overflow se produit quand la somme de deux positifs devient négative ou celle de deux négatifs devient positive :

$\text{overflow} = \bar{X}_{n-1}\bar{Y}_{n-1}S_{n-1} + X_{n-1}Y_{n-1}\bar{S}_{n-1} .$

C’est la traduction exacte de la règle « deux opérandes de même signe donnent un résultat de signe opposé ». Le TD 7 demande d’illustrer ces indicateurs par des exemples.

#Soustraction, multiplication, divisionCopier le lien

Pour économiser des circuits, la soustraction $A - B$ se réalise comme $A + (-B)$ : on inverse $B$ et on force la retenue entrante à 1, ce qui revient à ajouter le complément à deux de $B$ sans circuit supplémentaire. Un additionneur 4 bits plus quatre inverseurs donne donc un soustracteur 4 bits.

La multiplication binaire est calquée sur la multiplication décimale : suivant que le bit du multiplicateur vaut 1 ou 0, on ajoute ou non le multiplicande, décalé d'un rang vers la gauche. Elle est même plus simple qu'en décimal, puisque le chiffre multiplicateur n'a que deux valeurs : chaque produit partiel est soit le multiplicande recopié, soit zéro. Le décalage à gauche traduit la multiplication par la base, ce qui se démontre en réécrivant $N = \sum x_i b^i$ : le produit $bN$ a pour chiffres $x'_{i} = x_{i-1}$, avec $x'_{0} = 0$. La division entière suit la même logique, réduite à sa plus simple expression puisque les seuls facteurs possibles sont 0 et 1.

#Nombres à virguleCopier le lien

Diviser par la base revient à décaler à droite, et rien n'interdit de répéter l'opération pour faire apparaître des exposants négatifs : $N = \sum_{i=-m}^{n-1} x_i b^i$. La somme est en général infinie, et un format fini impose une mantisse normalisée sous la forme $X = \text{signe} \times \text{mantisse} \times b^{\text{exposant}}$. Conséquence directe pour le programmeur : $3{,}75$ s'écrit exactement $11{,}11$ en binaire, mais $3{,}7$ s'écrit $11{,}1001 + \varepsilon$ sur quatre chiffres après la virgule — l'erreur est calculable et bornable, mais elle existe. Tout test d'égalité entre deux nombres réels devient donc illusoire dans ce format.

#L'UALCopier le lien

Les circuits arithmétiques précédents sont assemblés dans l'unité arithmétique et logique (UAL), brique de base de tout microprocesseur. Elle est composée de $2^n$ circuits arithmétiques différents — additionneur, soustracteur, incrémenteur, décrémenteur — dont un multiplexeur à $n$ bits de sélection ne laisse passer qu'un seul résultat. Le nombre de multiplexeurs nécessaires est égal au nombre de bits du résultat. La sélection $S_1 S_0$ choisit l'opération, et une cellule d'addition complétée par un multiplexeur sur $B$ permet d'inverser $B$, de le forcer à zéro ou à un : c'est ainsi qu'une seule cellule fait à la fois addition, soustraction, incrémentation et décrémentation.

#Coût, encombrement et vitesseCopier le lien

Concevoir un système numérique, c'est optimiser trois critères : le coût financier, l'encombrement et la vitesse. Deux idées fausses à écarter d'emblée.

Le coût financier est lié au nombre de boîtiers utilisés et à leurs caractéristiques, pas au nombre de portes réellement employées : un boîtier 7404 contient six inverseurs, et si le logigramme n'en demande que deux, les quatre autres sont payés quand même. L'encombrement suit à peu près le même raisonnement, les boîtiers ayant des surfaces comparables (les connexions représentant de 5 à 10 % de la surface totale).

La vitesse, en revanche, est complètement découplée du nombre de composants. Modifier une entrée déclenche une vague de remises à jour qui traverse le système ; le temps de propagation dépend du nombre de couches logiques traversées, pas du nombre de composants. La vitesse du système est donnée par la transmission la plus lente, c'est-à-dire par le chemin critique : le chemin qui traverse le plus de couches intermédiaires. Le TD 3 en donne l'application numérique type : un codeur de parité dont le chemin critique a une longueur de 5, avec des portes à 10 ns, est garanti stable au bout de 50 ns, soit une fréquence maximale de 20 MHz.

Deux niveaux d'optimisation en découlent : l'équation logique (moins d'opérateurs booléens) et le choix des composants (moins de boîtiers). Réduire l'un dégrade souvent l'autre, et c'est précisément l'arbitrage que demandent les TD 3 et TD 6.

#Bascules et synchronisationCopier le lien

Un circuit combinatoire associe à chaque combinaison d'entrée une combinaison de sortie unique, indépendante de l'histoire : présenter deux fois la même entrée donne deux fois la même sortie. Un circuit séquentiel n'a pas cette propriété — son état dépend de la séquence des entrées précédentes et de son état initial. Il possède donc un état interne, qui caractérise le chemin chronologique parcouru, et se décrit comme un circuit combinatoire bouclé : les entrées externes et les variables internes $y_1 \ldots y_p$ entrent dans la partie combinatoire, dont les sorties repassent par un bloc de retard — les bascules — pour former les variables internes suivantes. Conséquence directe : à une même combinaison d'entrées peuvent correspondre plusieurs états du système, et c'est exactement ce qui distingue le séquentiel du combinatoire.

Deux familles en découlent. Les systèmes asynchrones voient leurs sorties évoluer spontanément dès qu'une entrée change ; les systèmes synchrones subordonnent toute évolution à une commande explicite, l'horloge. C'est cette dernière famille que l'on construit en pratique, parce qu'elle rend le comportement prévisible : tout change au front, et seulement au front.

Les bascules stockent un bit. Le latch est transparent tant que son entrée de validation est active ; la bascule D n'échantillonne qu'au front d'horloge et maintient sinon. Le respect des temps de setup (donne stable avant le front) et de hold (stable après le front) est impératif : une violation ne donne pas une valeur fausse, elle donne une valeur métastable, qui peut basculer à un instant quelconque, voire rester entre les deux niveaux un moment indéterminé. La parade des systèmes synchrones est simple : une seule horloge, des chemins de données équilibrés, et deux étages de synchronisation pour toute entrée asynchrone venant de l'extérieur.

#Latch SR : mémoire asynchroneCopier le lien

Le latch SR (Set/Reset) est la brique mémoire minimale. En version NOR, les entrées actives haut suivent l’intuition : S=1 → Q=1, R=1 → Q=0, S=R=0 maintient l’état. En version NAND, les entrées sont actives bas : l’événement est un 0 bref sur S̅ ou R̅, pratique pour construire la mémoire avec des portes universelles. L’animation expose la boucle de rétroaction qui maintient la sortie, et les états interdits (S=R=1 pour NOR, S=R=0 pour NAND) où les deux sorties cessent d’être complémentaires. Avant de cliquer, prédises la sortie pour chaque combinaison : le latch NOR n’est que deux portes NOR croisées, chaque sortie entre dans l’entrée de l’autre.

#Les équations des basculesCopier le lien

Chaque bascule possède une équation caractéristique qui donne l'état suivant $Q^+$ en fonction des entrées et de l'état courant $Q$. C'est elle qu'on utilise en synthèse séquentielle, quand il faut « identifier » les équations simplifiées à celles d'un type de bascule.

La bascule SR en NOR admet donc un état interdit : si $S = R = 1$, les deux sorties sont forcées à 0 et cessent d'être complémentaires ; à la disparition simultanée des deux entrées, la bascule retombe dans un état imprévisible — c'est ce que la condition $R \cdot S = 0$ interdit. La bascule JK supprime ce problème : à $J = K = 1$, elle bascule à chaque front, et sa table de vérité se lit $00$ : mémoire, $01$ : mise à 0, $10$ : mise à 1, $11$ : basculement. Attention toutefois : sur une bascule JK validée par un niveau et non par un front, $J = K = 1$ provoque une oscillation tant que le niveau reste actif — d'où l'intérêt du déclenchement sur front.

Une bascule D sur front n'est pas un composant magique : c'est un montage maître-esclave, formé de deux latchs commandés par des niveaux opposés. Le premier (maître) échantillonne $D$ pendant la première phase de l'horloge, le second (esclave) recopie le maître pendant la seconde. La sortie ne change donc qu'au front, et non pendant tout le niveau haut : c'est exactement la différence entre un latch D (transparent) et une bascule D (sur front).

#Décomposition en bascule DCopier le lien

#Registres et machines à étatsCopier le lien

Un registre est un alignement de n bascules D partageant la même horloge : il mémorise un mot de n bits. Le registre à décalage relie chaque sortie Q à l'entrée D de la suivante ; à chaque front, les bits avancent d'un cran, ce qui convertit parallèle ↔ série et génère des retards numériques. Un compteur est un registre rebouclé dont l'état suivant est l'état courant plus un.

#Registres à décalage : quatre applicationsCopier le lien

Un décalage d'un rang vers la gauche multiplie par 2, vers la droite divise par 2 : le registre à décalage est donc un multiplicateur ou diviseur par $2^k$ en $k$ fronts, sans une seule porte. Quatre usages en découlent :

• conversion série-parallèle et inverse : un mot arrive bit par bit sur l'entrée du premier étage et se reconstitue en sortie du dernier ;
• multiplication et division par une puissance de 2 ;
• ligne à retard : la sortie du $k$-ième étage reproduit l'entrée avec $k$ périodes d'horloge de retard. C'est le principe d'un écho numérique : en rebouclant la sortie retardée sur un additionneur, on ajoute au signal sa propre copie retardée. Un montage à 22 000 étages cadencé à 22 kHz répète ainsi le signal toutes les secondes — c'est le sujet d'examen 2024-2025 traité dans les annales ;
• générateur de séquences : un registre rebouclé parcourt un cycle d'états fixé.

Le sens du décalage se commande par multiplexeurs : une entrée sens relie la sortie du registre $n$ à l'entrée du registre $n-1$ (décalage à droite) ou à celle du registre $n+1$ (décalage à gauche). En remplaçant le multiplexeur 2 vers 1 par un multiplexeur plus large, on ajoute le chargement parallèle : le registre devient alors un composant universel — décalage, chargement, maintien.

#CompteursCopier le lien

Un compteur est une machine de Moore sans entrée : son état suivant ne dépend que de son état courant, ce qui le rend très simple à synthétiser. Il sert de diviseur de fréquence — le bit de poids faible bascule à $f/2$, le suivant à $f/4$, le $k$-ième à $f/2^{k+1}$ — et de base à toute séquence. Un compteur modulo $m$ boucle après $m$ états : comme $m$ n'est pas toujours une puissance de 2, il subsiste des états inutilisés qu'il faut traiter explicitement sous peine de cycles parasites.

Une machine à états finis (FSM) enchaîne trois blocs : registre d'état, logique de transition (fonction de l'état courant et des entrées), logique de sortie. Le compteur ou le diviseur de fréquence en est le cas d'école : un compteur modulo 8 sur 3 bits passe par les états 000, 001, …, 111 et revient à 000 ; pour un modulo 6, on détecte l'état 110 et on force le retour à 000. Les TP 5 du SPUE100 font synthétiser exactement de telles machines sous Logisim, du graphe d'états vers les équations de bascules. Règle de conception : un état inutilisé doit toujours avoir une transition définie vers un état de reprise, sinon la machine peut s'y perdre définitivement.

Erreur de conception classique : prendre les sorties pour les variables d'état. Un chenillard qui allume quatre sorties successives n'a que quatre états, donc besoin de deux bascules seulement — pas de quatre. L'état d'un système est indépendant de la vision qu'en a l'extérieur : entre état interne et sortie il y a une relation de cause à effet, rarement une bijection. Le TD 11 fait tomber le piège explicitement, en montrant qu'une synthèse « naïve » produit des cycles parasites qu'il faut ensuite rafistoler.

#Les deux méthodes de synthèseCopier le lien

Toute la démarche se résume en sept étapes, quels que soient l'automate et le type de bascule :

1. modélisation par un automate d'états finis (Moore ou Mealy) ;
2. table d'évolutions : pour chaque état et chaque combinaison d'entrées, l'état suivant ;
3. codage des états : on fixe le nombre de variables d'état, donc le nombre de bascules ;
4. table de vérité des variables d'état et des sorties ;
5. simplification par Karnaugh ;
6. recherche des cycles parasites — et dégradation des équations si nécessaire ;
7. schéma final, intégrant les bascules.

L'étape 3 mérite une remarque : le codage n'a aucune importance pour le comportement, mais il en a beaucoup pour la complexité des équations. Un bon codage peut supprimer plusieurs portes ; c'est pourquoi on place souvent l'état initial en 00...0, ce qui facilite la remise à zéro par une simple impulsion sur les entrées CLEAR des bascules.

L'étape 4 se décline ensuite selon le type de bascule :

• synthèse directe avec des bascules D : c'est le cas le plus simple, puisque $Q^+ = D$ — la table des variables d'état suivantes est la table des entrées D. Aucun calcul supplémentaire ;
• synthèse de Marcus avec des bascules JK : il faut d'abord déduire, de chaque couple $(Q, Q^+)$, les conditions suffisantes sur $J$ et $K$ :

La lecture de ce tableau est directe : pour passer de 0 à 1, il faut $J = 1$ et $K$ est indifférent ; pour passer de 1 à 0, il faut $K = 1$ et $J$ est indifférent ; pour rester dans le même état, l'entrée qui ferait changer est forcée à 0 et l'autre est indifférente. On remplit alors deux nouvelles colonnes par bascule — $J_i$ et $K_i$ — et on les simplifie par Karnaugh comme n'importe quelle fonction. L'intérêt est que les indifférents sont nombreux, donc les équations souvent plus simples qu'en synthèse directe ; le prix est un tableau à remplir plus long et plus propice aux erreurs de recopie.

#Cycles parasitesCopier le lien

L'étape 6 est celle qu'on oublie, et c'est celle qui décide si le circuit fonctionne. Les états non utilisés — ceux que le codage laisse libres — reçoivent des valeurs indifférentes pendant la simplification : on les traite comme des X, ce qui permet d'agrandir les regroupements. Mais une fois les équations figées, ces états ont un successeur déterminé par le circuit. Si ce successeur les ramène entre eux, ils forment un cycle parasite : une machine qui démarre dans un état non prévu — à la mise sous tension, après un aléa ou une impulsion parasite — s'y enferme et n'atteint jamais le cycle utile. C'est exactement le piège du TD 11, où la synthèse « naïve » du chenillard produit deux cycles parasites, dont un qui passe par l'état 0000.

Deux parades, par ordre de qualité :

1. revoir le codage ou le choix des impliquants pour que tous les états non utilisés convergent vers le cycle utile — c'est la vraie solution, et elle ne coûte rien ;
2. dégrader volontairement une équation (ou ajouter une impulsion sur les entrées asynchrones SET/RESET des bascules) pour forcer le retour — c'est une rustine, à réserver aux cas où la première est impossible.

La bonne nouvelle est que le nombre d'états non utilisés dépend du codage : plus on code juste — un nombre de bascules minimal pour le nombre d'états réel — moins il y a d'états libres, et moins il y a de risque. C'est un argument de plus pour compter les états avant de compter les bascules.

#Moore ou Mealy ?Copier le lien

Les deux structures ont la même puissance d'expression, mais des comportements temporels différents. Dans un automate de Moore, les sorties ne dépendent que de l'état : elles ne changent qu'aux fronts d'horloge, donc le signal de sortie est propre — immunisé contre les aléas des entrées. Dans un automate de Mealy, les sorties dépendent aussi des entrées : elles réagissent immédiatement à un changement d'entrée, sans attendre le front, ce qui les rend plus rapides mais sensibles à l'instabilité des entrées. Le TD 11 en donne la démonstration la plus nette : sur deux automates dont la partie séquentielle est identique, les sorties de Mealy se trouvent être exactement les variables d'état suivantes de Moore — le même calcul, avec un coup d'avance pour Mealy. Le choix est donc un compromis latence / immunité au bruit, pas une question de goût.

#Construire un mini-circuit combinatoireCopier le lien

Ce constructeur permet d’assembler votre propre logique combinatoire : partez des entrées A/B/C, ajoutez des portes, chaînez leurs sorties et organisez le plan en glissant chaque bloc. La sortie se recalcule en temps réel et l’expression booléenne s’affiche, pour repérer les simplifications possibles. Exercice guidé : réalisez d’abord F = AB + AC + BC (majorité) avec des portes AND et OR, comptez les portes ; puis refaites-la exclusivement en NAND pour constater l’universalité ; enfin comparez l’expression affichée à votre table de Karnaugh.

#Conversion analogique-numériqueCopier le lien

Un convertisseur analogique-numérique (CAN) échantillonne la tension et la convertit en code binaire. Paramètres clés :

• résolution : n bits ⇒ 2ⁿ niveaux ; le quantum vaut q = pleine échelle / 2ⁿ. Sur 0–5 V en 10 bits, q ≈ 4,9 mV ; en 12 bits, q ≈ 1,2 mV ;
• fréquence d’échantillonnage : le théorème de Nyquist impose f_e > 2 · f_max du signal ; en pratique on échantillonne bien au-delà (4 à 10 fois) ;
• erreur de quantification : ±½ quantum, bruit inhérent de ±q/2 ;
• filtre anti-repliement : passe-bas analogique avant le CAN, indispensable car tout ce qui dépasse f_e/2 se replie dans la bande utile et devient indétectable du signal réel.

Un mot de n bits code donc une mesure avec une incertitude de ±½ quantum, à additionner aux incertitudes de la chaîne analogique : la page instrumentation détaille ce bilan.

#Un CAN réel : celui de l'ATmega2560Copier le lien

Le microcontrôleur utilisé en TP fournit l'illustration concrète de tout ce qui précède. Son convertisseur est un CAN 10 bits à approximations successives, qui consomme 13 cycles d'horloge ADC par échantillon — 25 cycles pour la première conversion, celle-ci initialisant le convertisseur. Un présélecteur (prescaler) ramène l'horloge du processeur à une fréquence d'horloge ADC acceptable, et le résultat est rangé dans deux registres dont l'alignement se règle par le bit ADLAR.

Quatre registres suffisent à le piloter :

• ADMUX — choix du canal (MUX[4:0]) et de la référence : tension d'alimentation AVCC, référence interne (1,1 V ou 2,56 V) ou AREF externe ;
• ADCSRA — activation (ADEN), démarrage d'une conversion (ADSC), déclenchement automatique (ADATE), drapeau de fin de conversion (ADIF), autorisation d'interruption (ADIE) et présélecteur (ADPS[2:0]) ;
• ADCSRB — choix de la source de déclenchement automatique (ADTS[2:0]) ;
• ADCH/ADCL — le résultat.

Le bit ADIF passe à 1 lorsque la conversion est terminée et le résultat disponible : c'est le drapeau d'interruption, analogue matériel d'un read qui se termine côté logiciel. Le déclenchement automatique permet de cadencer les conversions sur un événement matériel plutôt que sur une boucle logicielle : mode « free running », comparateur analogique, débordement ou comparaison de compteur. Une restriction à connaître : le mode free running ne peut pas être utilisé sur les canaux différentiels.

Rapporté aux ordres de grandeur de cette page : sur 0–5 V, un CAN 10 bits a un quantum de 4,9 mV ; sur la référence interne 1,1 V, le même convertisseur descend à environ 1,1 mV — on gagne en résolution ce qu'on perd en dynamique.

#ExercicesCopier le lien

1. Complément à deux : codez −25 sur 8 bits, puis vérifiez que 25 + (−25) = 0 en binaire. Vérification : 25 = 0001 1001 ; inversion 1110 0110, plus 1 : 1110 0111 ; la somme bit à bit donne 0000 0000 avec retenue finale ignorée.
2. Karnaugh : simplifiez F = Σm(0,1,2,3,4,6) sur trois variables. Vérification : les quatre cases 0, 1, 2, 3 forment un groupe de 4 (A reste à 0) et les cases 0, 2, 4, 6 un second groupe de 4 (C reste à 0), d'où $F = \bar{A} + \bar{C}$. Vérifiez chaque minterme dans le résultat : le minterme 6 (A=1, B=1, C=0) n'est couvert que par $\bar{C}$ — un terme $\bar{B}\bar{C}$, qui ne couvre que 0 et 4, laisserait passer ce minterme.
3. NAND pur : réalisez F = A · B puis F = A + B uniquement avec des portes NAND. Vérification : A · B = NAND(NAND(A,B), NAND(A,B)) ; A + B = NAND(NAND(A,A), NAND(B,B)) par De Morgan.
4. Diviseur de fréquence : combien de bascules D pour diviser par 32 une horloge de 1 MHz, et quelle fréquence en sortie ? Vérification : 5 bascules en cascade (2⁵ = 32), sortie à 31,25 kHz.
5. Quantification : un CAN 12 bits sur la plage 0–3,3 V mesure une batterie via un diviseur. Quantum et incertitude relative à pleine échelle ? Vérification : q = 3,3/4096 ≈ 0,81 mV ; l'erreur de quantification ±0,4 mV reste négligeable devant la tolérance du diviseur (1 %, soit 33 mV).
6. Code de Gray : construisez $G_4$ à partir de $G_3$, puis vérifiez que la table obtenue reste un code de Gray quand on déplace la première ligne en dernière position. Vérification : $G_4$ se lit 0000, 0001, 0011, 0010, 0110, 0111, 0101, 0100, 1100, 1101, 1111, 1110, 1010, 1011, 1001, 1000. Chaque transition ne change qu'un bit, y compris la dernière vers la première (1000 → 0000) : le code est cyclique, donc n'importe quelle rotation de la table reste un code de Gray.
7. Codeur de parité 3 bits : établissez la table de vérité de la sortie S valant 1 quand le nombre de 1 parmi E2 E1 E0 est impair, puis son équation canonique. Vérification : S = 1 pour 001, 010, 100 et 111, d'où S = Ē2Ē1E0 + Ē2E1Ē0 + E2Ē1Ē0 + E2E1E0. Cette fonction est un damier : elle ne se simplifie pas en produits de moins de trois lettres, et s'écrit plus simplement S = E2 ⊕ E1 ⊕ E0.
8. Indifférents : un monte-charge n'actionne ses contacts que dans trois situations — aucun contact (à vide, autorisé), C1 et C2 seuls (10 à 60 kg, autorisé), les trois contacts (> 60 kg, interdit) ; C1 seul (5 à 10 kg) est interdit. Établissez la table d'évolution puis simplifiez. Vérification : la table vaut 1 pour 000 et 110, 0 pour 100 et 111, et X pour les quatre autres combinaisons, physiquement impossibles. Sans indifférents on trouve $F = \bar{C_3}(\bar{C_1}\bar{C_2} + C_1C_2)$ ; en intégrant les indifférents 001 et 010, on obtient la forme nettement plus simple $F = \bar{C_1}\bar{C_2} + C_2\bar{C_3}$.
9. Additionneur complet : donnez les équations de $S_i$ et $R_i$, puis comparez un additionneur à propagation de retenue et un additionneur à retenues anticipées pour $n = 32$. Vérification : $S_i = X_i \oplus Y_i \oplus R_{i-1}$ et $R_i = X_iY_i + R_{i-1}(X_i \oplus Y_i)$. À $T$ par porte, la propagation met $2nT = 64T$ pour 32 bits, contre environ $4T$ en retenues anticipées : le temps devient constant, au prix d'une explosion du nombre de portes.
10. Multiplexeur générateur de fonction : réalisez S2 et S1 du TD 6 à l'aide de deux multiplexeurs 8 vers 1. Vérification : les entrées de sélection reçoivent E2 E1 E0 et les entrées de données recopient la colonne de la table de vérité ; aucun calcul booléen n'est nécessaire, puisque l'équation du multiplexeur $Y = \sum E_i m_i$ est la forme canonique disjonctive.

Toutes les corrections détaillées, y compris celles des sujets d'examen, sont regroupées dans les annales corrigées.

Cette transition analogique-numérique est cruciale pour connecter le monde physique aux logiciels : comprendre les seuils et les temporisations évite d’interpréter du bruit comme des événements, et la démarche table de vérité → Karnaugh → équations → bascules est exactement celle qu’attendent les sujets d’examen.