BCD (décimal codé binaire) : les fondamentaux expliqués

Le BCD encode chaque chiffre décimal sur 4 bits. Découvrez les formes compactes et non compactes, la correction d'addition +6, la mise à l'échelle décimale et les compromis pratiques.

Denny

7 mai 202610 min de lecture

Chalkboard feature illustration for “BCD (décimal codé binaire) : les fondamentaux expliqués”

En bref : le décimal codé binaire (BCD) stocke chaque chiffre décimal de 0 à 9 dans un quartet de 4 bits, laissant 1010–1111 inutilisés. Un additionneur BCD applique une correction de +6 lorsque la somme binaire brute dépasse 9 ou produit une retenue. Le BCD conserve exactement les chiffres décimaux stockés, mais la division et la mise à l’échelle en précision finie nécessitent toujours des règles d’arrondi explicites.

Le binaire et le décimal utilisent des facteurs premiers différents pour leurs valeurs de position ; de nombreuses fractions décimales finies — notamment 0,1 — n’ont donc pas d’écriture binaire finie. Le décimal codé binaire stocke directement les chiffres décimaux. Cela évite l’erreur initiale de représentation des fractions binaires, mais une application correcte doit tout de même définir l’échelle, la précision et l’arrondi lorsque le résultat comporte plus de chiffres que le format ne peut en contenir.

Qu’est-ce que le décimal codé binaire ?

Le BCD représente chaque chiffre décimal de 0 à 9 par son propre code binaire de 4 bits. Quatre bits peuvent coder 16 motifs, mais le BCD n’en utilise que les dix premiers :

Décimal	Quartet BCD
0	0000
1	0001
2	0010
3	0011
4	0100
5	0101
6	0110
7	0111
8	1000
9	1001

Les six motifs restants, 1010 à 1111 — les valeurs 10 à 15 en binaire pur — sont invalides en BCD. Un circuit qui produit l’un de ces motifs a soit dépassé la capacité d’un chiffre, soit reçu une entrée mal formée ; les additionneurs BCD doivent détecter ce cas et le corriger.

Un nombre décimal à plusieurs chiffres est codé en enchaînant des quartets. Ainsi, 327 devient :

327_{10} \;=\; \underbrace{0011}_{3}\;\underbrace{0010}_{2}\;\underbrace{0111}_{7}

À comparer à la représentation binaire pure $327_{10}=101000111_2$ , qui utilise 9 bits au lieu de 12. Le BCD consomme donc davantage de bits afin de préserver une représentation orientée chiffres et de simplifier certaines interfaces décimales.

BCD compact et non compact

Deux organisations de stockage sont courantes.

Le BCD non compact stocke un chiffre décimal par octet. Le quartet de poids faible contient le chiffre ; le quartet de poids fort vaut zéro ou porte une marque de type ASCII (0x30 dans les premières instructions BCD IBM et x86, ce qui produit directement le chiffre ASCII imprimable). Le BCD non compact gaspille la moitié du stockage, mais il est trivial à afficher.

Le BCD compact stocke deux chiffres décimaux par octet, un dans chaque quartet. Le nombre 327 occupe deux octets en BCD compact : 0x03 0x27. Il est deux fois plus dense et constitue le format utilisé dans les additionneurs BCD matériels et par les instructions x86 DAA/DAS.

Format	Chiffre 327	Octets	Densité
Non compact	`0x03 0x02 0x07`	3	1 chiffre/octet
Compact	`0x03 0x27`	2	2 chiffres/octet
Binaire pur (16 bits)	`0x01 0x47`	2	plage complète

Pour les valeurs tenant sur 16 bits (jusqu’à 65 535), le binaire pur égale le BCD compact en densité tout en codant 65 536 valeurs distinctes au lieu de 10 000. Le coût ne réapparaît que lorsque l’arithmétique doit rester exactement décimale.

Pourquoi le BCD existe-t-il encore ?

Si le binaire est plus dense, pourquoi s’en servir ? Trois raisons maintiennent le BCD en usage.

Des chiffres décimaux stockés exactement. Le décimal 0,1 n’a pas de représentation binaire terminée. Le BCD peut stocker 0.1 exactement lorsque la position de la virgule fait partie du format. L’arithmétique n’est exacte que tant que le résultat mathématique tient dans le nombre de chiffres et l’échelle choisis ; la division et les autres résultats non terminants exigent toujours un arrondi. L’article sur les nombres flottants IEEE 754 détaille le compromis côté binaire.

Une conversion d’affichage triviale. Une horloge numérique ou une calculatrice alimente un afficheur 7 segments à partir de chaque quartet BCD via un petit décodeur de recherche. Il n’y a ni division par 10, ni boucle de soustractions répétées, ni conversion logicielle. C’est le même avantage qui motive le décodeur BCD vers 7 segments, traité dans l’article suivant.

Des règles métier décimales. Les applications financières et de mesure spécifient souvent des échelles et des arrondis décimaux. Le décimal compact, COBOL COMP-3, le flottant décimal et les entiers binaires à virgule fixe sont autant de représentations possibles. Le BCD est utile lorsque le stockage par chiffres ou les interfaces comptent ; la réglementation n’impose pas universellement le BCD.

Additionner des chiffres BCD : la correction de +6

L’addition BCD utilise des additionneurs binaires ordinaires de 4 bits — voir l’article sur l’additionneur à propagation de retenue de 4 bits — suivis d’une étape d’ajustement décimal qui corrige les résultats supérieurs à 9.

La règle est simple. Additionnez deux chiffres BCD comme des nombres binaires de 4 bits. Ensuite :

Si la somme binaire est inférieure ou égale à 9 et qu’il n’y a pas eu de retenue, le résultat BCD est la somme binaire inchangée.
Si la somme binaire est supérieure à 9 ou si l’additionneur de 4 bits a produit une retenue, ajoutez 6 (0110) pour corriger et propagez une retenue au chiffre suivant.

Pourquoi 6 ? Parce que le BCD ignore les six motifs invalides 1010–1111. Toute somme binaire qui tombe dans cette plage ou au-delà se trouve exactement six positions après sa place dans la numérotation BCD ; ajouter 6 la ramène donc à la bonne valeur tout en produisant la retenue attendue par l’arithmétique décimale.

Exemple détaillé : 7 + 5

Codez les opérandes et additionnez-les en binaire sur 4 bits :

\begin{aligned} 7 &= 0111 \\ 5 &= 0101 \\ \hline 12 &= 1100 \end{aligned}

Le résultat 1100 vaut 12 en binaire, et constitue l’un des motifs BCD invalides. Appliquez la correction de +6 :

\begin{aligned} 1100 \;(12) \\ +\;0110 \;(6) \\ \hline 1\,0010 \end{aligned}

Le résultat corrigé est 0001 0010, soit le BCD de 12 : une retenue vers les dizaines et un 2 aux unités. C’est exactement ce que doit produire l’arithmétique décimale.

Exemple détaillé : 8 + 9

\begin{aligned} 8 &= 1000 \\ 9 &= 1001 \\ \hline 17 &= 1\,0001 \end{aligned}

L’additionneur de 4 bits produit 0001 avec une retenue. Cette retenue déclenche la correction de +6, même si 0001 semble être un chiffre BCD valide :

\begin{aligned} 0001 \\ +\;0110 \\ \hline 0111 \end{aligned}

Le résultat final est 0001 0111, le BCD de 17. Sans correction, la concaténation de la retenue brute et du quartet bas donnerait 0001 0001, que le décodeur BCD lirait comme 11 — et non 17.

La condition générale de détection du besoin de correction est :

\text{adjust} \;=\; C_{\text{out}} \;\lor\; (S_3 \land S_2) \;\lor\; (S_3 \land S_1)

où $S_3 S_2 S_1 S_0$ est la somme binaire de 4 bits. Les deux termes ET couvrent ensemble les six motifs invalides 1010–1111, et $C_{\text{out}}$ détecte le cas où la somme a déjà dépassé 15.

Matériel : un additionneur BCD à un chiffre

Un additionneur BCD à un chiffre se construit avec deux additionneurs binaires de 4 bits et un petit circuit de détection de correction :

  A[3:0]  B[3:0]
     |      |
     v      v
 +-----------------+
 |  4-bit adder #1 |  <-- ordinary binary add (see /docs/adder)
 +-----------------+
   S[3:0]   C_out
     |        |
     +--+--+--+
        |  |
        v  v
   +----------+
   |  detect  |  --> adjust = C_out OR (S3·S2) OR (S3·S1)
   +----------+
        |
        v       0110 if adjust, else 0000
 +-----------------+
 |  4-bit adder #2 |  <-- adds the correction
 +-----------------+
        |
        v
     BCD result, BCD carry-out

Le premier additionneur effectue l’addition binaire brute. Le bloc de détection calcule le signal d’ajustement. Le second additionneur ajoute toujours 0 ou 6 à la somme intermédiaire. La retenue BCD est le signal d’ajustement lui-même : chaque fois que nous avons dû ajouter 6, nous propageons également un 1 au chiffre décimal suivant. Enchaînez $n$ de ces blocs pour obtenir un additionneur BCD à propagation de retenue de $n$ chiffres. La structure rappelle la chaîne d’additionneurs complets et demi-additionneurs binaires, avec un chiffre plus large et une étape de correction.

Vous pouvez en construire un avec deux blocs additionneur et la logique de détection, puis piloter un afficheur de chiffres avec le résultat. Gardez les entrées limitées aux chiffres BCD valides 0–9 ; l’expression de correction ne nettoie pas de façon générale les quartets d’entrée invalides.

Soustraction BCD

La soustraction suit le même schéma, mais utilise le complément à 9 ou le complément à 10 à la place du complément à 2 binaire. Pour calculer $A - B$ :

Formez le complément à 9 de $B$ en remplaçant chaque chiffre $d$ par $9 - d$ .
Additionnez le résultat à $A$ comme une addition BCD.
S’il y a une retenue finale, ajoutez 1 au résultat (ajustement par complément à 10). La retenue indique un résultat positif.
S’il n’y a pas de retenue, le résultat est négatif ; complémentez-le à nouveau pour retrouver sa valeur absolue.

Le complément à 9 joue pour le décimal le même rôle que le complément à 1 pour le binaire, et le complément à 10 est le pendant décimal du complément à 2. L’UAL BCD n’a besoin que des mêmes étapes de correction de l’autre côté de la soustraction.

Inconvénients du BCD

Ces avantages ont des coûts réels.

Surcoût de stockage. Chaque chiffre décimal coûte 4 bits : 4 octets codent au plus 99 999 999. Les mêmes 32 bits en binaire pur représentent des valeurs jusqu’à environ 4,29 milliards — un avantage de plage de 43 fois. Pour les applications scientifiques ou graphiques, le BCD est coûteux.

Davantage de travail arithmétique. Chaque addition de chiffre nécessite une addition binaire, une détection de correction et la correction elle-même. Plusieurs anciennes instructions x86 d’ajustement décimal ne sont plus disponibles en mode 64 bits. Le meilleur choix entre décimal compact, flottant décimal et entiers à virgule fixe dépend de l’ISA, de la charge, de la bibliothèque et des sémantiques requises.

Pas de fractions natives. Le BCD décrit ici encode des entiers. Un BCD fractionnaire exige de fixer la virgule décimale par convention ou de passer au décimal densément compacté ou aux flottants décimaux IEEE 754-2008, qui codent les chiffres par groupes de trois avec un code plus compact. L’histoire de ces codages remonte aux premiers systèmes de numération binaire et au long débat sur le comptage en dizaines ou en deux.

Où trouve-t-on encore le BCD ?

Le BCD subsiste partout où les entrées et les sorties sont décimales, même si le calcul ne l’est pas.

Horloges et montres numériques. Une horloge de 24 heures stocke heures, minutes et secondes sous forme de six chiffres BCD. Un circuit compteur incrémente les secondes ; un petit comparateur détecte 60 et passe aux minutes ; le même schéma gère 60 minutes et 24 heures. Chaque chiffre pilote une LED 7 segments par l’intermédiaire d’un décodeur BCD vers 7 segments.
Calculatrices. L’arithmétique orientée chiffres peut simplifier la saisie et l’affichage décimaux, même si les calculatrices utilisent aussi le binaire et d’autres représentations internes.
Panneaux de commande industriels. Les commutateurs à roue codeuse produisent directement du BCD. Les entrées d’automates programmables lisent le BCD sans conversion.
Systèmes d’entreprise. Les architectures et langages qui prennent en charge le décimal compact restent utiles pour les données métier à échelle fixe et les charges COBOL.
Compteurs et terminaux de point de vente. Les affichages décimaux et les règles d’arrondi prescrites peuvent rendre les formats orientés chiffres pratiques, même si les choix d’implémentation varient.

La leçon est générale : lorsque le domaine est naturellement décimal, coder explicitement les chiffres est souvent préférable à une conversion de base à chaque opération. Le même raisonnement justifie aujourd’hui l’arithmétique entière à virgule fixe dans les logiciels manipulant l’argent, même si le processeur sous-jacent travaille volontiers en binaire.

Essayez dans le simulateur

Un exercice simple consiste à construire un additionneur BCD à un chiffre et à observer la correction en action.

Reliez deux registres d’entrée de 4 bits $A$ et $B$ à un bloc additionneur. Affichez la somme brute sur 5 bits.
Construisez la logique de détection : un OU entre $C_{\text{out}}$ , $(S_3 \land S_2)$ et $(S_3 \land S_1)$ .
Utilisez le signal de détection pour commander une constante 0110 vers un second additionneur, puis additionnez-la à la première somme.
Envoyez le quartet bas du résultat corrigé vers un afficheur de chiffres. Envoyez la retenue BCD vers un chiffre séparé.
Faites varier $A = 0..9$ et $B = 0..9$ . Vérifiez que l’affichage indique 0–18 sur deux chiffres sans jamais afficher de symbole A–F.

Pour des valeurs plus larges, enchaînez un deuxième bloc additionneur BCD. La retenue du premier devient l’entrée de retenue du second, exactement comme dans une chaîne binaire à propagation.

Et ensuite ?

Un additionneur BCD à un chiffre n’est utile que si son résultat est lisible. Le prochain article — Décodeur BCD vers 7 segments : des nombres à l’affichage — déduit les expressions booléennes de commande des segments à partir de la table de vérité BCD et montre comment relier le résultat à un afficheur réel, en s’appuyant sur les fondamentaux des décodeurs vus précédemment. Pour le côté binaire du même problème, l’article sur les nombres flottants IEEE 754 défend les fractions binaires et explique pourquoi le code financier choisit malgré tout souvent le décimal.

Ouvrez le modèle de compteur binaire 4 bits pour fournir une entrée de comptage à un additionneur BCD et observer la correction à chaque dixième impulsion — le moyen le plus direct de voir le +6 à l’œuvre.