BCD (decimal codificado en binario): fundamentos explicados

BCD codifica cada dígito decimal con 4 bits. Aprende las formas empaquetada y desempaquetada, la corrección de suma +6, el escalado decimal y sus ventajas prácticas.

Denny

7 de mayo de 202610 min de lectura

Chalkboard feature illustration for “BCD (decimal codificado en binario): fundamentos explicados”

Resumen: El decimal codificado en binario (BCD) almacena cada dígito decimal 0–9 en un nibble de 4 bits y deja 1010–1111 sin usar. Un sumador BCD aplica una corrección de +6 cuando la suma binaria supera 9 o produce un acarreo de salida. BCD conserva exactamente los dígitos decimales almacenados, pero la división y el escalado con precisión finita aún requieren reglas de redondeo explícitas.

El sistema binario y el decimal usan factores primos distintos en sus valores posicionales, por lo que muchas fracciones decimales finitas —incluido 0,1— no tienen una expansión binaria finita. El decimal codificado en binario almacena directamente los dígitos decimales. Así evita el error inicial de representación de una fracción binaria, pero una aplicación sólida aún debe definir la escala, la precisión y el redondeo de las operaciones cuyo resultado tiene más dígitos de los que admite el formato.

¿Qué es el decimal codificado en binario?

BCD representa cada dígito decimal del 0 al 9 con su propio código binario de 4 bits. Cuatro bits pueden codificar 16 patrones, pero BCD solo usa los diez primeros:

Decimal	Nibble BCD
0	0000
1	0001
2	0010
3	0011
4	0100
5	0101
6	0110
7	0111
8	1000
9	1001

Los seis patrones restantes, de 1010 a 1111 — valores del 10 al 15 en binario puro—, son inválidos en BCD. Un circuito que produce uno de ellos ha desbordado un dígito o ha recibido una entrada malformada; los sumadores BCD deben detectar este caso y corregirlo.

Un número decimal de varios dígitos se codifica concatenando nibbles. Por ejemplo, el número 327 se convierte en:

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

Compáralo con la representación binaria pura $327_{10}=101000111_2$ , que usa 9 bits en lugar de 12. BCD emplea bits adicionales para conservar una representación orientada a dígitos y simplificar algunas interfaces decimales.

BCD empaquetado frente a desempaquetado

Hay dos disposiciones de almacenamiento habituales.

El BCD desempaquetado almacena un dígito decimal por byte. El nibble bajo contiene el dígito; el alto es cero o lleva una marca de estilo ASCII (0x30 en las primeras instrucciones BCD de IBM y x86, lo que produce directamente el dígito ASCII imprimible). El BCD desempaquetado desperdicia la mitad del almacenamiento, pero es trivial de imprimir.

El BCD empaquetado almacena dos dígitos decimales por byte, uno en cada nibble. El número 327 en BCD empaquetado ocupa dos bytes: 0x03 0x27. El BCD empaquetado tiene el doble de densidad y es el formato utilizado dentro de los sumadores BCD de hardware y en las instrucciones x86 DAA/DAS.

Formato	Dígito 327	Bytes	Densidad
Desempaquetado	`0x03 0x02 0x07`	3	1 dígito/byte
Empaquetado	`0x03 0x27`	2	2 dígitos/byte
Binario puro (16 bits)	`0x01 0x47`	2	rango completo

Para valores que caben en 16 bits (hasta 65.535), el binario puro iguala al BCD empaquetado en densidad, aunque codifica 65.536 valores distintos en lugar de 10.000. El coste reaparece cuando necesitas realizar operaciones aritméticas que deben coincidir exactamente con el decimal.

Por qué existe BCD

Si el binario es más denso, ¿para qué usar BCD? Tres razones lo mantienen vigente.

Dígitos decimales almacenados exactamente. El decimal 0,1 no tiene una representación binaria terminante. BCD puede almacenar 0.1 exactamente cuando la posición de la coma decimal forma parte del formato. La aritmética solo es exacta mientras el resultado matemático cabe en la cantidad de dígitos y la escala elegidas; la división y otros resultados no terminantes siguen requiriendo redondeo. La coma flotante IEEE 754 explica el lado binario de esta disyuntiva.

Conversión directa para la pantalla. Un reloj digital o una calculadora controla una pantalla de 7 segmentos a partir de cada nibble BCD mediante un pequeño decodificador de consulta. No hace falta dividir entre 10, repetir restas ni convertir por software. La misma ventaja motiva el decodificador de BCD a 7 segmentos que tratamos en una publicación posterior.

Reglas empresariales decimales. Las aplicaciones financieras y de medición suelen especificar escalas decimales y redondeo. El decimal empaquetado, COMP-3 de COBOL, la coma flotante decimal y los enteros binarios escalados son representaciones viables. BCD resulta útil cuando importan el almacenamiento o las interfaces a nivel de dígito; las normativas no exigen BCD de forma universal.

Suma de dígitos BCD: la corrección +6

La suma BCD usa sumadores binarios ordinarios de 4 bits —consulta la publicación sobre el sumador de acarreo en cascada de 4 bits para repasar—, seguidos de una etapa de ajuste decimal que corrige los resultados mayores que 9.

La regla es sencilla. Suma dos dígitos BCD como si fueran números binarios de 4 bits. Después:

Si la suma binaria es menor o igual que 9 y no hubo acarreo de salida, el resultado BCD es la suma binaria sin cambios.
Si la suma binaria es mayor que 9 o hubo un acarreo de salida del sumador de 4 bits, suma 6 (0110) para corregirla y propaga un acarreo al dígito siguiente.

¿Por qué 6? Porque BCD omite los seis patrones inválidos 1010–1111. Toda suma binaria que cae en ese intervalo o lo supera está exactamente seis posiciones por delante de su posición en la numeración BCD; al sumar 6 vuelve a la posición correcta y produce el acarreo que espera la aritmética decimal.

Ejemplo resuelto: 7 + 5

Codifica los operandos y súmalos como binarios de 4 bits:

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

El resultado 1100 es 12 en binario, uno de los patrones BCD inválidos. Aplica la corrección de +6:

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

El resultado corregido es 0001 0010, que representa 12 en BCD: un acarreo a la posición de las decenas y un 2 en la de las unidades. Es exactamente lo que debe producir la aritmética decimal.

Ejemplo resuelto: 8 + 9

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

El sumador de 4 bits produce 0001 con un acarreo de salida. Ese acarreo activa la corrección de +6 aunque 0001 parezca un dígito BCD válido:

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

El resultado final es 0001 0111, que representa 17 en BCD. Sin la corrección, concatenar el acarreo bruto y el nibble bajo produciría 0001 0001, que un decodificador BCD interpretaría como 11, no como 17.

La condición general de detección de que «se necesita corrección» es:

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

donde $S_3 S_2 S_1 S_0$ es la suma binaria de 4 bits. Los dos términos AND cubren juntos los seis patrones inválidos 1010–1111, y $C_{\text{out}}$ detecta el caso en que la suma ya dio la vuelta al superar 15.

Hardware: sumador BCD de un dígito

Un sumador BCD de un dígito se construye con dos sumadores binarios de 4 bits y un pequeño circuito detector de corrección:

  A[3:0]  B[3:0]
     |      |
     v      v
 +-----------------+
 |  4-bit adder #1 |  <-- suma binaria ordinaria (consulta /docs/adder)
 +-----------------+
   S[3:0]   C_out
     |        |
     +--+--+--+
        |  |
        v  v
   +----------+
   |  detect  |  --> ajuste = C_out OR (S3·S2) OR (S3·S1)
   +----------+
        |
   v       0110 si hay ajuste, si no 0000
 +-----------------+
 |  4-bit adder #2 |  <-- suma la corrección
 +-----------------+
        |
        v
     resultado BCD, acarreo BCD de salida

El primer sumador realiza la suma binaria sin corregir. El bloque detector calcula la señal de ajuste. El segundo sumador añade incondicionalmente 0 o 6 a la suma intermedia. El acarreo BCD de salida es la propia señal de ajuste: cada vez que necesitamos sumar 6, también propagamos un 1 al siguiente dígito decimal. Encadena $n$ de estos bloques y tendrás un sumador BCD de acarreo en cascada de $n$ dígitos. La estructura refleja la cadena binaria de sumadores completos y semisumadores, pero con un dígito más ancho y una etapa de corrección.

Puedes construir uno con dos bloques sumador y la lógica detectora, y después controlar una pantalla de dígitos con el resultado. Restringe las entradas a dígitos BCD válidos del 0 al 9; la expresión de corrección no es un saneador general para nibbles de entrada inválidos.

Resta BCD

La resta sigue el mismo patrón, pero usa el complemento a 9 o el complemento a 10 en lugar del complemento a 2 binario. Para calcular $A - B$ :

Forma el complemento a 9 de $B$ reemplazando cada dígito $d$ por $9 - d$ .
Suma el resultado a $A$ como una suma BCD.
Si se produce un acarreo final, suma 1 al resultado (ajuste de complemento a 10). El acarreo indica un resultado positivo.
Si no hay acarreo de salida, el resultado es negativo; vuelve a complementar para recuperar la magnitud.

El complemento a 9 desempeña para el decimal el mismo papel que el complemento a 1 para el binario, y el complemento a 10 es el equivalente decimal del complemento a 2. La ALU BCD solo necesita las mismas etapas de corrección en el lado de la resta.

Desventajas de BCD

Las ventajas tienen costes reales.

Sobrecoste de almacenamiento. Cada dígito decimal cuesta 4 bits, así que 4 bytes codifican como máximo 99.999.999. Los mismos 32 bits en binario puro representan valores de hasta unos 4.290 millones: una ventaja de rango de 43 veces. Para trabajos científicos o gráficos, BCD resulta derrochador.

Más trabajo aritmético. Cada suma de dígitos necesita una suma binaria, detección de corrección y corrección. Varias instrucciones x86 antiguas de ajuste decimal no están disponibles en modo de 64 bits. Que rindan mejor el decimal empaquetado, la coma flotante decimal o los enteros escalados depende de la ISA, la carga de trabajo, la biblioteca y la semántica requerida.

Sin soporte fraccionario nativo. El BCD descrito aquí codifica enteros. El BCD fraccionario requiere fijar la coma decimal por convenio o pasar al decimal densamente empaquetado o a las flotantes decimales IEEE 754-2008, que codifican los dígitos en grupos de tres mediante un código más compacto. La historia de estas codificaciones se remonta a los primeros sistemas numéricos binarios y al largo debate sobre si contar de diez en diez o de dos en dos.

Dónde sigue presente BCD

BCD sobrevive allí donde las entradas y salidas son decimales, aunque el cálculo no lo sea.

Relojes digitales y de pulsera. Un reloj de 24 horas almacena horas, minutos y segundos como seis dígitos BCD. Un chip contador incrementa los segundos; un pequeño comparador detecta 60 y pasa a los minutos; el mismo patrón gestiona 60 minutos y 24 horas. Cada dígito controla un LED de 7 segmentos mediante un decodificador BCD a 7 segmentos.
Calculadoras. La aritmética orientada a dígitos puede simplificar la introducción y la visualización decimal, aunque las calculadoras también usan binario y otras representaciones internas.
Paneles de control industrial. Los interruptores de rueda digital entregan BCD directamente. Las entradas de los PLC leen BCD sin conversión.
Sistemas empresariales. Las arquitecturas y lenguajes con soporte para decimal empaquetado siguen siendo útiles para datos empresariales de escala fija y cargas de trabajo COBOL.
Medidores y equipos de punto de venta. Las pantallas decimales y las reglas de redondeo especificadas pueden hacer convenientes los formatos orientados a dígitos, aunque las decisiones de implementación varían.

La lección es general. Cuando el dominio del problema es naturalmente decimal, codificar los dígitos de forma explícita suele ser mejor que convertir entre bases en cada operación. La misma lógica respalda hoy la aritmética entera de punto fijo en el software que maneja dinero, aunque la CPU subyacente trabaje cómodamente en binario.

Pruébalo en el simulador

Un ejercicio claro: construye un sumador BCD de un dígito y observa la corrección en acción.

Conecta dos registros de entrada de 4 bits, $A$ y $B$ , a un bloque sumador. Muestra la suma bruta de 5 bits.
Construye la lógica detectora: una OR de $C_{\text{out}}$ , $(S_3 \land S_2)$ y $(S_3 \land S_1)$ .
Usa la señal de detección para habilitar la constante 0110 en un segundo sumador y sumarla a la primera suma.
Lleva el nibble inferior del resultado corregido a una pantalla de dígitos. Lleva el acarreo BCD de salida a un dígito separado.
Recorre $A = 0..9$ y $B = 0..9$ . Confirma que la pantalla muestra 0–18 en dos dígitos sin que aparezcan nunca símbolos A–F.

Para valores más amplios, encadena un segundo bloque sumador BCD. El acarreo de salida del primero se convierte en el acarreo de entrada del segundo, igual que en una cadena binaria de acarreo.

Qué sigue

Un sumador BCD de un dígito solo es útil si puedes leerlo. La siguiente publicación, Decodificador de BCD a 7 segmentos: de los números a la pantalla, deriva las expresiones booleanas que controlan los segmentos a partir de la tabla de verdad BCD y muestra cómo conectar el resultado a una pantalla real, sobre la base de los fundamentos de los decodificadores que vimos antes. Si quieres conocer el lado binario del mismo problema, el recorrido por la coma flotante IEEE 754 defiende las fracciones binarias y explica por qué el código financiero sigue eligiendo el decimal.

Abre la plantilla de contador binario de 4 bits para alimentar un sumador BCD con una entrada contadora y observa cómo se activa la corrección en cada décimo pulso: la forma más directa de ver el +6 en acción.