Décodeurs et encodeurs : piloter un afficheur 7 segments

En bref : un décodeur binaire actif à l’état haut et validé associe un code de $n$ bits à l’une des $2^n$ sorties activées ; les variantes actives à l’état bas inversent cette convention. Un encodeur simple suppose une entrée one-hot, tandis qu’un encodeur prioritaire définit un gagnant lorsque plusieurs entrées sont actives. Un bloc BCD vers sept segments est un convertisseur de code — et non un décodeur one-hot — car plusieurs sorties de segment peuvent être actives simultanément.

Les décodeurs et encodeurs traduisent des index binaires compacts en ensembles de signaux plus larges, et inversement. On les trouve dans la sélection d’adresses, le contrôle des instructions, le codage d’événements, la logique d’affichage et de nombreuses autres interfaces. Leurs noms décrivent une direction logique, mais une interface complète doit aussi préciser la polarité, le comportement de validation et la politique pour les entrées invalides ou simultanées.

Dans ce guide, nous construirons un pilote d’afficheur BCD vers 7 segments fonctionnel à partir d’expressions booléennes, comprendrons la différence entre afficheurs à anode commune et à cathode commune, explorerons les encodeurs prioritaires et leur rôle dans la gestion des interruptions, puis construirons ces circuits sur digisim.io.

Qu’est-ce qu’un décodeur ?

Un décodeur binaire est un circuit combinatoire qui associe une entrée de $n$ bits à une sortie sélectionnée parmi au plus $2^n$. Dans l’exemple actif à l’état haut ci-dessous, la sortie sélectionnée est HIGH et les autres sont LOW. Les vrais circuits intégrés décodeurs disposent souvent d’entrées de validation et peuvent utiliser des sorties actives à l’état bas ; dans ce cas, la ligne sélectionnée est LOW.

Un décodeur 2 vers 4 : l’entrée de 2 bits sélectionne la sortie HIGH parmi les 4. L’entrée 10 (2 en binaire) active la sortie $Y_2$.

Décodeur 2 vers 4 : table de vérité et expressions booléennes

Chaque sortie est une combinaison AND unique des variables d’entrée (complémentées ou non) :

$Y_0 = \overline{A_1} \cdot \overline{A_0}$ $Y_1 = \overline{A_1} \cdot A_0$ $Y_2 = A_1 \cdot \overline{A_0}$ $Y_3 = A_1 \cdot A_0$

Le schéma canonique somme de produits utilise deux inversions et quatre termes AND à deux entrées. Un ASIC ou un FPGA synthétisé peut mapper la même fonction vers d’autres cellules ou tables de recherche.

Étendre à des décodeurs plus grands

Un décodeur 3 vers 8 suit le même motif booléen avec huit mintermes. En général, une forme directe en somme de produits possède un minterme par sortie. Il s’agit d’une construction pédagogique, et non d’une exigence universelle de nombre de portes physiques ; les décodeurs plus grands sont souvent hiérarchiques.

L’afficheur 7 segments

Un afficheur 7 segments montre les chiffres décimaux au moyen de sept segments LED disposés comme un 8. Chaque segment est nommé de a à g :

 ━━━━━ (a)
│     │
(f)   (b)
│     │
 ━━━━━ (g)
│     │
(e)   (c)
│     │
 ━━━━━ (d)

Pour afficher un chiffre de 0 à 9, nous allumons sélectivement la combinaison appropriée de segments. Par exemple, le chiffre « 7 » nécessite que les segments a, b et c soient allumés, tandis que d, e, f et g restent éteints.

Cathode commune ou anode commune

Il existe deux configurations physiques pour les afficheurs 7 segments, et cette distinction compte lors de la conception du pilote :

• Cathode commune : toutes les LED de segment partagent une connexion de masse (cathode). Un segment s’allume lorsque son anode est pilotée à HIGH. Dans cette configuration, les sorties du décodeur sont actives à l’état haut : un 1 logique allume un segment.
• Anode commune : toutes les LED de segment partagent une alimentation positive (anode). Un segment s’allume lorsque sa cathode est tirée à LOW. Dans cette configuration, les sorties du décodeur doivent être actives à l’état bas : un 0 logique allume un segment.

Le composant logique sept segments de DigiSim utilise des commandes de segment actives à l’état haut. Pour un afficheur physique, la polarité de sortie n’est qu’une partie de l’interface : prévoyez une limitation de courant, vérifiez que le pilote peut fournir ou absorber le courant nécessaire et respectez les limites de puissance de chaque segment et du boîtier.

Idée clé : ce n’est PAS un simple décodeur

Un décodeur 7 segments est fondamentalement différent d’un décodeur binaire standard. Un décodeur 4 vers 16 active exactement UNE sortie à la fois. Un décodeur 7 segments active PLUSIEURS segments simultanément (le chiffre « 8 » allume les 7 segments). C’est un circuit logique combinatoire doté de 7 fonctions de sortie indépendantes, chacune dérivée de la même entrée BCD de 4 bits.

BCD vers 7 segments : table de vérité

Le BCD (Binary Coded Decimal) utilise 4 bits pour représenter les chiffres de 0 à 9. Le décodeur associe chaque chiffre au motif de segments correspondant :

Les valeurs BCD 10 à 15 ne font pas partie du code des chiffres décimaux. Leurs motifs d’affichage dépendent de la conception : définissez un affichage vide, un glyphe d’erreur, les chiffres hexadécimaux A–F ou un comportement don’t-care selon le contrat du système.

Déduire les expressions booléennes des sorties de segments

Chacun des sept segments possède sa propre fonction booléenne des quatre entrées BCD $D$, $C$, $B$, $A$. Pour déduire ces expressions, nous regardons quels chiffres allument chaque segment et écrivons la somme de produits (ou utilisons des cartes de Karnaugh pour minimiser).

Segment a (horizontal supérieur)

Le segment a est allumé pour les chiffres 0, 2, 3, 5, 6, 7, 8 et 9, et éteint pour 1 et 4. Listons les mintermes où $a=1$ :

$a = \overline{D}\,\overline{C}\,\overline{B}\,\overline{A} + \overline{D}\,\overline{C}\,B\,\overline{A} + \overline{D}\,\overline{C}\,B\,A + \overline{D}\,C\,\overline{B}\,A + \overline{D}\,C\,B\,\overline{A} + \overline{D}\,C\,B\,A + D\,\overline{C}\,\overline{B}\,\overline{A} + D\,\overline{C}\,\overline{B}\,A$

Après minimisation avec une carte de Karnaugh (en traitant les entrées BCD 10–15 comme don’t-care), on obtient :

$a = D + B + (A \cdot C) + (\overline{A} \cdot \overline{C})$

Ou, de manière équivalente : $a = D + B + \overline{A \oplus C}$ (le XNOR de $A$ et $C$).

Segment g (horizontal central)

Le segment g est allumé pour les chiffres 2, 3, 4, 5, 6, 8 et 9, et éteint pour 0, 1 et 7. L’expression minimisée est :

$g = D + (B \oplus C) + (B \cdot \overline{A})$

Ou développée : $g = D + (B \cdot \overline{C}) + (\overline{B} \cdot C) + (B \cdot \overline{A})$.

Segment d (horizontal inférieur)

Le segment d est allumé pour les chiffres 0, 2, 3, 5, 6, 8 et 9, et éteint pour 1, 4 et 7. L’expression minimisée est :

$d = D + (\overline{C} \cdot \overline{A}) + (\overline{C} \cdot B) + (B \cdot \overline{A}) + (C \cdot \overline{B} \cdot A)$

Les quatre segments restants (b, c, e et f) suivent le même processus : listez les mintermes, décidez la politique des entrées invalides, tracez le résultat sur une carte de Karnaugh et extrayez une expression minimisée. Les pilotes commerciaux de la famille 74x47/48 implémentent un comportement BCD vers segments spécifié, mais leurs réseaux internes n’ont pas à correspondre à ces équations particulières.

Gérer les entrées BCD invalides

Le BCD n’utilise que les valeurs d’entrée 0 à 9, mais une entrée de 4 bits peut représenter 10 à 15. Que doit afficher l’afficheur pour ces entrées invalides ? Trois approches sont courantes :

1. Éteindre l’afficheur : tous les segments sont éteints. Le résultat est défini, mais une panne en amont peut rester cachée si un autre diagnostic ne la signale pas.
2. Traitement don’t-care : traiter les entrées 10–15 comme des libertés d’optimisation. Cela peut simplifier la logique, mais les motifs obtenus ne sont pas spécifiés et ne sont acceptables que lorsque ces entrées ne peuvent pas avoir d’importance pour l’affichage.
3. Afficher les chiffres hexadécimaux : pour les afficheurs hexadécimaux, les entrées 10–15 correspondent aux lettres A à F, ce qui exige des motifs de segments supplémentaires.

Les expressions ci-dessus utilisent l’approche don’t-care. Le guide dédié BCD vers sept segments déduit les sept fonctions et explique dans quels cas cette hypothèse est sûre.

Construire un pilote 7 segments sur digisim.io

Suivez ces étapes pour construire un pilote d’affichage fonctionnel :

1. Placer les entrées BCD. Ajoutez quatre composants INPUT_SWITCH et nommez-les $D$, $C$, $B$ et $A$.
2. Générer les complémentaires. Placez quatre portes NOT pour produire $\overline{D}$, $\overline{C}$, $\overline{B}$ et $\overline{A}$.
3. Construire la logique des segments. Pour chaque segment (a à g), implémentez son expression booléenne avec des portes AND et OR. Commencez par le segment a avec l’expression minimisée ci-dessus.
4. Relier l’afficheur. Placez un composant SEVEN_SEGMENT_DISPLAY et reliez chaque sortie de segment à l’entrée correspondante de l’afficheur.
5. Tester systématiquement. Faites parcourir aux interrupteurs d’entrée toutes les valeurs BCD de 0000 à 1001 et vérifiez que le bon chiffre apparaît pour chaque entrée.

Pour aller plus vite, utilisez le composant DIGIT_DISPLAY. Pour l’exercice au niveau des portes, testez les dix chiffres valides et les six codes invalides plutôt que de vous arrêter après un seul exemple visible.

Qu’est-ce qu’un encodeur ?

Un encodeur effectue l’opération inverse d’un décodeur. Il reçoit $2^n$ lignes d’entrée (dont une seule au plus devrait être active) et produit un code binaire de $n$ bits identifiant l’entrée active.

Encodeur simple 4 vers 2

Un encodeur de base 4 vers 2 possède 4 entrées ($D_3$, $D_2$, $D_1$, $D_0$) et 2 sorties ($Y_1$, $Y_0$). Les expressions booléennes sont :

$Y_1 = D_2 + D_3$ $Y_0 = D_1 + D_3$

Cela ne fonctionne correctement que si exactement une entrée est active à la fois. Si plusieurs entrées sont actives simultanément, la sortie devient ambiguë.

Encodeurs prioritaires

Dans les systèmes réels, plusieurs entrées peuvent être actives simultanément. Un encodeur prioritaire résout cette ambiguïté en n’encodant que l’entrée active de plus haute priorité (généralement celle dont l’index est le plus élevé).

Les entrées X signifient « don’t-care ». Les entrées de priorité inférieure sont ignorées dès qu’une entrée de priorité supérieure est active. La sortie Valide indique si une entrée quelconque est active, ce qui est important pour la logique en aval qui doit distinguer « l’entrée 0 est active » de « aucune entrée n’est active ».

Encodeur prioritaire dans la gestion des interruptions

L’une des applications les plus importantes des encodeurs prioritaires concerne les contrôleurs d’interruptions. Dans un système à microprocesseur, plusieurs périphériques matériels (clavier, carte réseau, temporisateur, lecteur de disque) peuvent demander simultanément l’attention du CPU en activant leurs lignes de requête d’interruption.

Un encodeur prioritaire peut identifier la requête éligible de rang le plus élevé et produire son index. Un contrôleur d’interruptions complet enregistre en plus les événements en attente, applique les masques et l’état de priorité, fournit un identifiant ou vecteur d’interruption défini par le protocole, suit le service et conserve les requêtes non sélectionnées. Un encodeur sans état ne peut pas garder en attente les requêtes de priorité inférieure.

Le Intel 8259A est un exemple historique de contrôleur combinant requêtes, masques, service en cours, résolution de priorité et génération de vecteur. Réduire tout le composant à un encodeur à huit entrées ferait oublier ces fonctions avec état.

Construire un décodeur 3 vers 8 sur digisim.io

Voici un guide pas à pas pour construire un décodeur 3 vers 8 complet :

1. Placer les entrées. Ajoutez trois composants INPUT_SWITCH nommés $A_2$, $A_1$ et $A_0$.
2. Générer les complémentaires. Placez trois portes NOT pour $\overline{A_2}$, $\overline{A_1}$ et $\overline{A_0}$.
3. Construire le réseau AND. Placez huit portes AND à 3 entrées. Chaque porte reçoit une combinaison unique des entrées originales et complémentaires :
   • $Y_0 = \overline{A_2} \cdot \overline{A_1} \cdot \overline{A_0}$
   • $Y_1 = \overline{A_2} \cdot \overline{A_1} \cdot A_0$
   • $Y_2 = \overline{A_2} \cdot A_1 \cdot \overline{A_0}$
   • …suite…
   • $Y_7 = A_2 \cdot A_1 \cdot A_0$
4. Ajouter les sorties. Reliez chaque sortie AND à un OUTPUT_LIGHT. Lorsque vous faites varier les entrées, une seule lumière doit être allumée à la fois.
5. Ajouter une ligne de validation (facultatif). Faites un AND entre chaque sortie et un signal de validation pour créer un décodeur validé, utilisable pour le décodage d’adresses mémoire.

Applications

Décodage d’adresses mémoire

Dans les systèmes à processeur, les décodeurs aident à sélectionner la cible mémoire ou E/S qui répond à une adresse. Un décodeur 2 vers 4 relié à deux bits d’adresse de poids fort peut diviser un espace en quatre régions de taille égale, puissance de deux. D’autres bits d’adresse et qualificatifs d’accès sont nécessaires pour les autres mappages. Si les cibles partagent un bus trois états, la logique de contrôle du bus doit garantir qu’au plus une sortie est activée ; de nombreuses interconnexions modernes sur puce utilisent des réponses multiplexées plutôt qu’un câblage trois états interne.

Encodage de clavier

Une matrice de touches balayée produit des observations de lignes et de colonnes. Un encodeur prioritaire peut intentionnellement réduire plusieurs lignes de colonne actives à un seul index, mais il perd les autres touches simultanées. Les conceptions qui nécessitent le rollover de plusieurs touches conservent et traitent l’état complet de la matrice. Les fantômes électriques, l’anti-rebond des contacts, la génération du code de balayage et la priorité sont des aspects distincts.

Systèmes d’affichage

La conversion BCD vers sept segments apparaît dans les horloges, compteurs, appareils électroménagers et tableaux de score. Dans un affichage multiplexé, plusieurs positions de chiffres peuvent partager le pilotage des segments. Le contrôleur présente un motif et active le chiffre correspondant, puis passe au suivant. Choisissez les fréquences de rafraîchissement de trame complète et par chiffre en fonction du scintillement, de la caméra, de la luminosité, du rapport cyclique et des limites du composant ; il n’existe pas de seuil universel de 1 kHz. Insérez un blanking si les délais du pilote et de la sélection du chiffre créeraient sinon des segments fantômes.

Décodage des instructions dans les CPU

Dans un petit CPU pédagogique, un opcode de 4 bits peut alimenter un décodeur 4 vers 16 dont la ligne sélectionnée contribue aux contrôles de l’ALU, des registres et de la mémoire pendant le cycle fetch–decode–execute. Le décodage réel des instructions peut être hiérarchique, piloté par table, microprogrammé ou distribué ; les signaux de contrôle combinent normalement les informations de l’opcode avec l’état temporel et d’autres champs de l’instruction.

Timing et aléas

Les sorties combinatoires ne changent pas simultanément. Lorsque plusieurs bits d’entrée changent, un décodeur à mintermes peut brièvement sélectionner l’ancienne sortie, aucune sortie ou — dans le matériel physique — une sortie imprévue, car les chemins complémentaires et non complémentaires ont des délais différents. Un réseau 7 segments peut afficher momentanément un motif de transition.

Utilisez des entrées ou sorties enregistrées lorsque le récepteur échantillonne de manière synchrone. Pour un affichage multiplexé, faites un blanking pendant le changement de chiffre ou de motif si les images fantômes sont importantes. Pour les chip-select et validations d’écriture, analysez les aléas et respectez les exigences de timing du composant cible au lieu de vous fier uniquement à une table de vérité statique.

À vous de jouer

1. Construisez un décodeur 2 vers 4 avec quatre termes AND et les inversions appropriées. Vérifiez qu’exactement une sortie est HIGH pour chaque combinaison d’entrée validée et qu’aucune ne l’est lorsque le décodeur est désactivé.
2. Câblez un afficheur 7 segments en implémentant de zéro les expressions booléennes d’au moins les segments a et g, puis reliez les sorties à un SEVEN_SEGMENT_DISPLAY.
3. Créez un encodeur 4 vers 2 qui encode le bouton parmi 4 pressé en un code binaire de 2 bits.
4. Ajoutez une logique de priorité afin que, lorsque deux boutons sont pressés simultanément, celui dont le numéro est le plus élevé gagne.
5. Construisez un compteur BCD complet avec affichage en connectant un COUNTER à votre décodeur 7 segments et en le regardant compter automatiquement de 0 à 9.

Poursuivez avec les compteurs et machines à états pour fournir une entrée de comptage au décodeur, ou ouvrez la référence du composant porte AND, le bloc de base de chaque sortie de décodeur. Les multiplexeurs résolvent le problème inverse de routage ; consultez le guide du multiplexeur.

Références

• Fiche technique du décodeur/pilote BCD vers sept segments SN74LS47 de Texas Instruments
• Documentation produit de l’encodeur prioritaire SN74HC148 de Texas Instruments