CÓDIGOS, CIRCUITOS CONVERSORES DE CÓDIGO Y DETECTORES DE ERROR

1 Codificación de números y tipos de códigos
1.1 Sistema Numérico Binario
1.2 Sistema Numérico Octal
1.3 Sistema Numérico Hexadecimal
1.4 Códigos
1.4.1 Código Decimal Codificado en Binario
1.4.2 Código Exceso-3
1.4.3 Código Gray
1.4.4 Códigos Alfanuméricos
2 Circuitos Conversores de Código 3 Paridad
4 Códigos para Detección y Corrección de Errores

5 Ejercicios

    La disponibilidad de una gran variedad de códigos para los mismos elementos discretos de información da como resultado el uso de códigos diferentes para distintos sistemas digitales. Es necesario, en ocasiones, usar la salida de un sistema como entrada de otro, por lo que debe utilizarse un circuito de conversión entre los dos sistemas, si cada uno usa diferentes códigos para la misma información. De esta forma un conversor de código es un circuito que hace compatibles dos sistemas a pesar de que ambos tengan diferente código binario.


1.     CODIFICACIÓN DE NÚMEROS Y TIPOS DE CÓDIGOS

    En los sistemas digitales la información numérica está generalmente representada en el sistema numérico binario (u otro código binario relacionado). En temas previos, se ha hecho énfasis en la importancia y utilización del sistema binario, sin embargo, también son importantes otros sistemas numéricos, principalmente el OCTAL, HEXADECIMAL y DECIMAL CODIFICADO EN BINARIO (BCD por sus siglas en inglés).


1.1    Sistema numérico binario

    El sistema numérico binario es un sistema posicional, en el cual cada dígito binario (bit) lleva un cierto peso basado en su posición relativa al punto binario (separación de la parte entera y la fraccionaria). Cualquier número binario puede convertirse a su equivalente decimal sumando juntos los pesos de las diferentes posiciones en el número binario que contienen un 1. Por ejemplo:

1 1 0 1 1

    binario

24 +23   +21 +20

= 16 + 8 + 2 + 1

  = 2710 (decimal)

    Es mismo método se emplea para números binarios que contienen una parte fraccional:

1 0 1 . 1 0 1 = 22 + 20 + 2-1 + 2-3 = 4 + 1 + 0.5 + 0.125 = 5.62510

EJEMPLO 1.     Aplicar el método anterior para verificar las siguientes conversiones:

a)                   1001102 = 3810
b)                0.1100012 = 0.76562510
c)    11110011.01012 = 243.31510

    Se tienen diferentes maneras para convertir un número decimal a su representación equivalente en el sistema binario. Un método, que es conveniente para números pequeños, es el reverso del proceso descrito previamente. El número decimal se expresa simplemente como una suma de potencias de 2 y luego se escriben unos y ceros asociados a las posiciones apropiadas de los bits. Por ejemplo:

1310 = 8 + 4 + 1 = 23 + 22 + 0 + 20 = 11012

Otro ejemplo:

25.37510 = 16 + 8 + 1 + 0.25 + 0.125 =
  = 24 +23 +0 +0 +20 .   +2-2 +2-3 =
 

=  1

1 0 0 1 . 0 1 12

division binaria parte entera.gif (11386 bytes)    Para números decimales mayores, el método anterior es laborioso. Un método más conveniente, consiste en la conversión separada de las partes entera y fraccionaria. Por ejemplo, para el número decimal 25.375, el cual se convirtió previamente, el primer paso es la conversión de la parte entera 25. Esto se hace dividiendo repetidamente 25 por 2 y escribiendo los residuos después de cada división, hasta obtener un cociente de ceros, como se muestra en la cuadro adjunto.

    La conversión deseada se obtiene escribiendo los residuos como se muestra en el cuadro adjunto. Obsérvese que el primer residuo es el bit menos significativo (bms) y el último el Bit Más Significativo (BMS).

    La parte fraccionaria del número (0.375), se convierte a binario multiplicándola repetidamente por 2 y anotando cualquier acarreo en la posición de los enteros, como se muestra en el cuadro siguiente:

    division binaria parte fraccionaria.gif (9611 bytes)Nótese que las multiplicaciones continúan hasta obtener un producto de 1.00 (la mayoría de las veces esto no ocurre y el proceso se termina hasta alcanzar el número de bits deseado), puesto que las multiplicaciones posteriores resultan igual a cero. Obsérvese que el primer acarreo se escribe en la primera posición a la derecha del punto binario.

    Finalmente, la conversión completa para 25.375 se escribe como la combinación de las conversiones entera y fraccionaria:

25.37510 = 11001.0112

 

 

 


EJEMPLO 2.     Aplicar este método para comprobar la siguiente conversión:

632.8510 = 1001111000.110112


1.2    Sistema numérico octal

    El sistema numérico octal es muy importante en el trabajo con computadoras digitales. El sistema octal tiene una base de 8, significando que tiene ocho dígitos posibles: 0, 1, 2, 3, 4, 5, 6 y 7. Así, cada dígito de un número octal tiene los siguientes pesos:

---- 84 83 82 81 80 . 8-1 8-2 8-3 8-4 8-5 ----
                      punto ^ octal

   Un número octal puede convertirse fácilmente a su equivalente decimal, multiplicando cada dígito octal por su peso posicional. Por ejemplo:

3728 = 3 x (82) + 7 x (81) + 2 x (80) =
  = 3 x 64 + 7 x 8 + 2 x 1 =
= 25010

Otro ejemplo:

24.68 = 2 x (81) + 4 x (80) + 6 x (8-1) = 20.7510

división binaria parte entera.gif (11386 bytes)   Los métodos para convertir un número decimal a su equivalente octal son los mismos como los usados para convertir de decimal a binario. Para convertir un entero decimal a octal, se divide progresivamente el número decimal por 8, anotando los residuos después de cada división. Los residuos representan los dígitos del número octal, con el primer residuo como el menos significativo (bms). Como ejemplo, convertir 26610 a octal:

    Las fracciones decimales se convierten a octal multiplicando progresivamente por 8 y escribiendo los acarreos en la posición después del punto octal. Por ejemplo, 0.38 se convierte a octal como sigue:

división binaria parte entera.gif (11386 bytes)

   Note que el primer acarreo es el bit más significativo (BMS) de la fracción. Se puede lograr una mayor precisión continuando el proceso para obtener más dígitos octales.

    Es útil cuando se convierte un número decimal relativamente grande a binario, convertirlo primero a octal. El número octal puede entonces convertirse a binario. Este método es generalmente más rápido que la conversión directa decimal a binario, debido a la simpleza de la conversión octal a binario.

    La principal ventaja del sistema numérico octal es la facilidad con la cual puede hacerse la conversión entre números binarios y octales. La conversión desde octal a binario se ejecuta convirtiendo cada dígito octal a su equivalente binario de 3 bits. Los ocho dígitos posibles se convierten como se indica en la siguiente tabla:

Dígito octal 0 1 2 3 4 5 6 7
Equivalente binario 000 001 010 011 100 101 110 111

    Usando estos equivalentes, cualquier número octal se convierte a binario por conversión individual de cada dígito. Por ejemplo, se puede pasar 4728 a binario como sigue:

4 7 2
^ ^ ^
100 111 010

   Por consiguiente, el octal 472 es equivalente al binario 100 111 010. Como otro ejemplo, considérese la conversión de 54.318 a binario:

5 4 . 3 1
^ ^   ^ ^
101 100 . 011 001

    Así, 54.318 = 101 100.011 0012

    La conversión de binario a octal es simplemente el inverso del proceso anterior. Los dígitos binarios se agrupan de tres en tres a cada lado del punto binario, añadiendo ceros en cualquier lado cuando ello sea necesario para completar un grupo de tres. Entonces cada grupo de tres bits se convierte a su equivalente octal. Como ilustración, considérese la conversión de 11010.1011 a octal:

011 010 . 101 100
^ ^   ^ ^
3 2 . 5 4

    Note que se añadieron ceros a cada lado para completar los grupos de a tres. Así, la conversión deseada es 32.548.


1.3    Sistema numérico hexadecimal

    Es sistema numérico hexadecimal usa la base 16. Así, tiene 16 símbolos digitales posibles. Usa los dígitos 0-9 más las letras A, B, C, D, E y F como los 16 símbolos digitales.

hexadecimal Decimal Binario
0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
A
B
C
D
E
F
10
11
12
13
14
15
1010
1011
1100
1101
1110
1111

    La tabla anterior muestra las relaciones entre hexadecimal, decimal y binario. Note que cada dígito hexadecimal representa a un grupo de cuatro bits binarios. Algunas computadoras utilizan el sistema hexadecimal para propósitos de exposición en preferencia al octal. Las conversiones entre decimal y binario se hacen exactamente de la misma manera como entre octal y binario, excepto que se usan grupos de 4 bits. En el siguiente ejemplo se ilustra la conversión de binario a hexadecimal y de hexadecimal a binario:

011101001102 = 0011 1010 0110
  3 A 6

= 3A616

9F116 = 9 F 2
    1001 1111 0010
=

1001111100102


1.4    Códigos

    Cuando se representan números, letras o palabras por un grupo especial de símbolos, se llama codificación y al grupo de símbolos se le denomina un código. Probablemente uno de los códigos más familiares es el código Morse, en el cual las letras del alfabeto se representan por puntos y rayas.

    Ya se ha visto que cualquier número decimal puede representarse por un número binario equivalente. Puede pensarse que el grupo de ceros y unos en el número binario es un código que representa al decimal. Cuando se representa un número decimal por su número binario equivalente, se llama codificación binaria directa.

    Los sistemas binarios usan todos alguna forma de números binarios para sus operaciones internas pero el mundo externo es de naturaleza decimal. Esto significa que se deben ejecutar conversiones frecuentes entre los sistemas decimal y binario. Hemos visto que las conversiones entre decimal y binario pueden llegar a ser largas y complicadas para números grandes. Por esta razón, algunas veces se usan otros medios para codificar los números decimales que combinan algunas características de los sistemas decimal y binario.


1.4.1    Código decimal codificado en binario (BCD, Binary Coded Decimal, por sus siglas en inglés)

    Si cada dígito de un número decimal se representa por su equivalente binario, esto produce un código llamado decimal codificado en binario (abreviado BCD  por sus siglas en inglés). Puesto que un dígito decimal puede ser tan grande como 9, se requieren 4 bits para codificar cada dígito (el código binario para 9 es 1001).

    Para ilustrar el código BCD, tomemos un número decimal como 874. Cada dígito se cambia a su equivalente binario como sigue:

8 7 4
^ ^ ^
1000 0111 0100

Como otro ejemplo, cambiemos 94.3 a su representación en código BCD:

9 4 . 3
^ ^   ^
1001 0100 . 0011

    Una vez más, cada dígito decimal se cambia a su equivalente binario directo. Note que siempre se usan 4 bits para cada dígito.

    El código  BCD, entonces representa cada dígito del número decimal por un número binario de 4 bits. Claramente, sólo los números binarios de 4 bits desde 0000 hasta 1001 se usan. El código BCD no usa los números 1010, 1011, 1100, 1101, 1110 y 1111. En otras palabras, sólo 10 de los 16 grupos codificados posibles de 4 bits se usan. Si cualesquiera de estos números prohibidos de 4 bits alguna vez ocurren en una máquina que usa el código BCD, generalmente indica que ha ocurrido un error.


EJEMPLO 3.     Convertir el número BCD 0110100000111001 a su equivalente decimal:

SOLUCIÓN

0110 1000 0011 1001
^ ^ ^ ^
6 8 3 9

EJEMPLO 4   Convierta el número BCD 011111000001 a su equivalente decimal:

0111 1100 0001
7 ^ 1
grupo de código prohibido indica error en el número BCD

    Al hacer una comparación entre BCD y binario común, es importante darse cuenta que un número BCD no es lo mismo que un número binario común. Un código binario común toma el número decimal completo y lo representa en binario, mientras que el código BCD convierte cada dígito decimal a binario en forma individual. Para ilustrar, tome el número 137 y compare las representaciones binaria común y codificada BCD:

13710 = 10001001 binario
13710 = 0001 0011 0111 BCD

    El código BCD requiere 12 bits mientras que el código binario común requiere sólo 8 bits para representar 137. Es siempre verdadero que el código BCD para un número decimal dado requiere más bits que el código binario común. Esto es porque BCD no usa todos los grupos posibles de 4 bits, como se señaló antes y es por consiguiente algo ineficiente.

    La principal ventaja del código BCD es la facilidad relativa para convertir a y desde decimal. Sólo se requiere recordar los grupos codificados de 4 bits para los dígitos decimales del 0 al 9. Esta facilidad de conversión es especialmente importante desde el punto de vista de circuitos, porque en un sistema decimal son los circuitos lógicos los que ejecutan las conversiones a y desde decimal.

    BCD se usa en máquinas digitales siempre y cuando se aplique información digital, ya sea como entradas o mostradas como salidas. Los voltímetros digitales, contadores de frecuencia y relojes digitales usan todos BCD, porque despliegan la información de salida en decimal. Las calculadoras electrónicas usan BCD porque los números de entrada vienen en decimal vía el teclado y los números de salida son mostrados en decimal.

    BCD no es a menudo usado en computadoras digitales modernas de alta velocidad por dos buenas razones. Primero, como ya fue señalado, el código BCD para un número decimal dado requiere más bits que el código binario directo y es por consiguiente menos eficiente. Esto es importante en computadoras digitales porque el número de lugares en memoria donde estos bits pueden ser almacenados es limitado. Segundo, los procesos aritméticos para números representados en código BCD son más complicados que en binario ordinario y requieren así de circuitería más compleja. La circuitería más compleja contribuye a una disminución en la velocidad a la cual tienen lugar las operaciones aritméticas. Las calculadoras que usan BCD son, por consiguiente, considerablemente más lentas en su operación que las computadoras.


1.4.2    Código exceso-3

    El código exceso-3 está relacionado con el código BCD y usado a veces en lugar de él porque posee ventajas en ciertas operaciones aritméticas. El código exceso-3 para un número decimal se ejecuta de la misma manera que en BCD excepto que se añade 3 a cada dígito decimal antes de codificarlo en binario. Por ejemplo, para codificar el número decimal 4 en el código exceso-3, debemos añadir 3 para obtener 7. Luego el 7 se codifica en código binario equivalente de 4 bits para obtener 0111.

    Como otro ejemplo, convirtamos 46 a su representación en código exceso-3:

  4
+
3
  6
+
3
añada 3 a cada dígito
  7
0111
  9
1001
convierta a código binario de 4 bits

    La siguiente tabla muestra las listas para las representaciones BCD y exceso-3 para los dígitos decimales. Note que ambos códigos usan 10 de los 16 posibles grupos codificados de 4 bits. El código exceso-3, sin embargo, no usa los mismos grupos codificados. Para exceso-3, los grupos codificados no válidos son 0000, 0001, 0010, 1101, 1110 y 1111.

Decimal BCD Exceso-3
0
1
2
3
4
5
5
7
8
9
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100

1.4.3    Código Gray

    El código Gray pertenece a una clase de códigos llamados códigos de cambio mínimo, en los cuales sólo cambia un bit en el grupo codificado cuando se va de un paso al siguiente. El código Gray es un código no ponderado, significando que las posiciones de los bits en los grupos codificados no tienen un peso específico asignado. Debido a esto, el código Gray no es apropiado para operaciones aritméticas, pero encuentra aplicaciones en dispositivos de entrada/salida y en algunos tipos de convertidores analógicos a digital.

    La siguiente tabla muestra la representación en Código Gray para los números decimales 0 al 15, junto con el código binario directo. Si examinamos los grupos codificados Gray para cada número decimal, puede verse que al ir desde cualquier número decimal al siguiente, sólo un bit del código Gray cambia. Por ejemplo, al ir desde 3 a 4, el código Gray cambia de 0010 a 0110, con solo el segundo bit desde la izquierda experimentando cambio. Yendo de 14 a 15 los bits del código Gray cambian de 1001 a 1000, con una sola variación en el último bit. Esta es la principal característica del código Gray. Compare esto con el código binario en el cual de uno a todos los bits cambian de un número al siguiente.

Decimal Código binario Código Gray
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
0000
0001
0011
0010
0110
0111
0101
0100
1100
1101
1111
1110
1010
1011
1001
1000

    El código Gray se usa a menudo donde otros códigos tales como el binario, pudieran producir resultados erróneos o ambiguos durante esas transiciones en las cuales más de un bit del código está cambiando. Usando el código binario, por ejemplo, y yendo de 0111 a 1000 requiere que todos los 4 bits cambien simultáneamente. Dependiendo del dispositivo o circuito que está generando los bits, puede haber una diferencia significativa en los tiempos de transición de los diferentes bits. Si esto es así, las transiciones de 0111 a 1000 pudiera producir uno o más estados intermedios. Por ejemplo, si el bit más significativo cambia más rápido que el resto, ocurrirán las siguientes transiciones:

0111   decimal
1111   código erróneo
1000   decimal 8

    La ocurrencia de 1111 es sólo momentánea pero pudiera concebiblemente producir una operación errónea de los elementos que están siendo controlados por los bits. Obviamente, usando el código Gray se elimina este problema, puesto que sólo ocurre el cambio de un bit por transición y no puede ocurrir una carrera.

    Cualquier número binario puede convertirse a su representación en código Gray como sigue:

  1. El primer bit del código Gray es el mismo como el primer bit del número binario.
  2. El segundo bit del código Gray es igual a la operación O EXCLUSIVA del primer y segundo bits del número binario; esto es, será 1 si estos bits del código binario son diferentes y 0 si son los mismos.

  3. El tercer bit del código Gray es igual a la O EXCLUSIVA del segundo y tercer bits del número binario y así sucesivamente.

    Para ilustrar esto, convirtamos el binario 10110 al código Gray:

1   0   1   1   0 código binario
^   ^   ^   ^   ^  
1   1   1   0   1 código Gray

    El primer bit del código Gray es el mismo como el primer bit del código binario. El primero y segundo bits del código binario son diferentes, dando un 1 para el segundo bit Gray. El segundo y tercer bits del número binario son diferentes, dando un 1 para el tercer bit Gray. El tercero y cuarto bits del número binario son lo mismo, así que el cuarto bit Gray es 0. Finalmente, el cuarto y quinto bits binarios son diferentes, dando un quinto bit Gray de 1.


    Otro ejemplo es como sigue:

1   0   0   1   1   0   0   1 binario
^   ^   ^   ^   ^   ^   ^   ^  
1   1   0   1   0   1   0   1 Gray

    Para convertir de Gray a binario se requiere el procedimiento opuesto dado previamente:

  1. El primer bit binario es el mismo que el primer bit Gray.
  2. Si el segundo bit Gray es 0, el segundo bit binario es el mismo como el primero; si el segundo bit Gray es 1, el segundo bit binario es el inverso del primer bit binario.

  3. El paso 2 se repite para el bit sucesivo.

    Para ilustrar esto, convirtamos 1101 de Gray a binario:

1   1   0   1 Gray
^   ^   ^   ^  
1   0   0   1 binario

    El primer bit Gray es 1, así que el primer bit binario se escribe como 1. El segundo bit Gray es un 1, así que el segundo bit binario se hace un 0 (inverso del primer bit binario). El tercer bit Gray es un 0. así que el tercer bit binario se hace un 0 (lo mismo como el segundo bit binario). El cuarto bit Gray es 1, haciendo el cuarto bit un 1 (inverso del tercer bit binario).

    Este proceso puede ser visto de otra manera: Cada bit binario (exceptuando el primero) puede obtenerse tomando la O EXCLUSIVA del bit correspondiente del código Gray y el bit binario previo.

    Finalmente, en las siguientes tablas, se presentan los códigos Gray y los ponderados exceso-3, 8 4 -2 -1 y Biquinario, referidos al código BCD.

CÓDIGO
Decimal BCD Gray Exceso-3
8 4 2 1 8 4 2 1 8 4 2 1
0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
0
0
1
1
0
0
0
1
0
1
0
1
0
1
0
1
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
1
1
1
0
0
1
1
1
1
0
0
0
0
0
1
1
0
0
1
1
0
0
1
0
0
0
0
0
1
1
1
1
1
0
1
1
1
1
0
0
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
10
:
15
        x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
CÓDIGO
Decimal 8 4 -2 -1 Biquinario
8 4 -2 -1 5 0 4 3 2 1 0
0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
1
1
1
1
1
0
1
1
1
1
0
0
0
0
1
0
1
1
0
0
1
1
0
0
1
0
1
0
1
0
1
0
1
0
1
0
0
0
0
0
1
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
0
10
:
15
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x

    En las tablas anteriores, se indican los términos indiferentes (prohibidos).


1.4.4    Códigos alfanuméricos

    Hemos estudiado varios códigos que se usan para representar datos numéricos, esto es, números. Muchos sistemas digitales, tales como la computadora, usan también datos alfabéticos (letras) y caracteres especiales (tales como símbolos de puntuación y matemáticos) en adición a números. Tales códigos se llaman alfanuméricos.

    La siguiente tabla muestra dos de los diferentes códigos alfanuméricos que están en uso corriente. El código interno de 6 bits se usa a menudo en computadoras para representar internamente caracteres alfanuméricos.

Carácter 6-bits
Código interno
7-bits
Código ASCII
A
B
C
D
E
:
V
W
X
Y
Z
010 001
010 010
010 011
010 100
010 101

:
110 101
110 110
110 111
111 000
111 001
100 0001
100 0010
100 0011
100 0100
100 0101

:
101 0110
101 0111
101 1000
101 1001
101 1010
0
1
2
3
:
7
8
9
000 000
000 001
000 010
000 110

:
000 111
001 000
001 001
011 0000
011 0001
011 0010
011 0011

:
011 0111
011 1000
011 1001
espacio
.
(
:
/
,
=
110 000
011 011
111 100

:
110 001
111 011
001 011
010 0000
010 1110
010 1000

:
010 1111
010 1100
011 1101

    El código interno de 6 bits puede representar hasta 64 caracteres diferentes, ya que 26=64. La necesidad de representar más de 64 caracteres, en ciertas aplicaciones, da lugar a códigos de 7 y 8 bits. Uno de tales códigos es el ASCII, por sus siglas en inglés (American Standard Code for Information Interchange - Código Estándar Americano para Intercambio de Información), el cual se usa en la transmisión de información digital. El ASCII mostrado en la tabla tiene 7 bits, lo cual indica que puede representar 27=128 caracteres diferentes. Sólo algunos de éstos se muestran en la tabla.


2    CIRCUITOS CONVERSORES DE CÓDIGO

    Para convertir el código binario A al código binario B, las líneas de entrada deben dar una combinación de bits de los elementos, tal como se especifica por el código A y las líneas de salida deben generar la correspondiente combinación de bits del código B.


EJEMPLO 1:     Realizar un circuito mínimo conversor de código de BCD a GRAY para 4 variables de entrada A, B, C, D, utilizando inversores, una compuerta O y compuertas No-O. Considere las condiciones irrelevantes.

SOLUCIÓN

a)    Tabla funcional:

DEC B C D G R A Y
A B C D G3 G2 G1 G0
0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
0
0
1
1
0
0
0
1
0
1
0
1
0
1
0
1
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
1
1
1
0
0
1
1
1
1
0
0
0
0
0
1
1
0
0
1
1
0
0
1
10
:
15
  x
:
x
x
:
x
x
:
x
x
:
x

b)    Variables de salida: Como el logigrama deberá realizarse con compuertas No-O, las funciones de conmutación a la salida del conversor, deberán expresarse como producto de maxitérminos:

G3(A, B, C, D) = JM (0-7) Jx (10-15)
G2(A, B, C, D) = JM  (0-3) Jx (10-15)
G1(A, B, C, D) = JM  (0,1,6-9) Jx (10-15)
G0(A, B, C, D) = JM  (0,3,4,7,8) Jx (10-15)

c)    Minimización de las funciones de conmutación: Reduciendo por el método de Karnaugh, se obtiene:

división binaria parte entera.gif (11386 bytes)

división binaria parte entera.gif (11386 bytes)

    Las funciones mínimas son:

G3(A, B, C, D) = A
G2(A, B, C, D) = A + B
G1(A, B, C, D) = (B + C)(B' +C')
G0(A, B, C, D) = (C + D)(C' +D')

d)    Logigrama:

división binaria parte entera.gif (11386 bytes)


EJEMPLO 2:     Realice un circuito mínimo conversor de código exceso-3 (BCD) a 8 4 -2 -1, utilizando sólo inversores.

SOLUCIÓN

a)    Tabla funcional:

CÓDIGO
Decimal Exceso-3 mi 8 4 -2 -1
E3 E2 E1 E0 A B C D
0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
1
1
1
1
1
0
1
1
1
1
0
0
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
3
4
5
6
7
8
9
10
11
12
0
0
0
0
0
1
1
1
1
1
0
1
1
1
1
0
0
0
0
1
0
1
1
0
0
1
1
0
0
1
0
1
0
1
0
1
0
1
0
1
10
:
15
  0-2

13-15
x

x
x

x
x

x
x

x

Obsérvese que el código exceso-3 sólo puede generarse hasta el 9 decimal, puesto que se toma como base el código BCD. Asimismo, los minitérminos de entrada para el código 8 4 -2 -1, son los que genera el código exceso-3, los cuales se indican en la columna mi. También, los términos indiferentes corresponden a aquellos que no aparecen a la salida del código exceso-3, puesto que no se generarán.

b)    Funciones de conmutación: Las funciones de conmutación a la salida del código 8 4 -2 -1, pueden expresarse como suma de minitérminos, ya que no existe una condición previa:

A(E3,E2,E1,E0) = 3m (8-12) + 3x (0-2,13-15)
B(E3,E2,E1,E0) = 3m (4-7,12) + 3x (0-2,13-15)
C(E3,E2,E1,E0) = 3m (4,5,8,9,12) + 3xS (0-2,13-15)
D(E3,E2,E1,E0) = 3m (4,6,8,10,12) + 3xS (0-2,13-15)

c)    Reducción de las funciones de conmutación: Utilizando los mapas K para minimizar las funciones de conmutación, se obtiene:

división binaria parte entera.gif (11386 bytes)

división binaria parte entera.gif (11386 bytes)

d)    Funciones de conmutación minimizadas:

A(E3, E2, E1, E0) = E3
B(E3, E2, E1, E0) = E2
C(E3, E2, E1, E0) = E1'
D(E3, E2, E1, E0) = E0'

e)    Logigrama:

división binaria parte entera.gif (11386 bytes)


3    PARIDAD

    La transmisión de datos binarios de una localización a otra es un lugar común en todos los sistemas digitales. Se presentan cuatro ejemplos de esto:

  1. Salida de datos binarios desde una computadora y que están registrándose en cinta magnética.
  2. Transmisión de datos binarios por línea telefónica, tal como entre una computadora y una consola remota.
  3. Un número se toma de la memoria de la computadora y se coloca en la unidad aritmética, en donde se añade a otro número. La suma es luego regresada a la memoria.

  4. Información almacenada en un disco flexible se lee para cargarse en la memoria de una computadora personal.

división binaria parte entera.gif (11386 bytes)    Lo anterior se ejemplifica en la figura adjunta.

    El proceso de transferir datos está sujeto a error, aun cuando el equipo moderno ha sido diseñado para reducir la probabilidad de error. Sin embargo, aun errores relativamente infrecuentes pueden causar resultados inútiles, así que es deseable detectarlos siempre que ello sea posible. Uno de los esquemas usados más ampliamente para la detección de errores es el método de paridad.

    Un bit de paridad es un bit extra que se agrega a un grupo codificado el cual se transmite de una localización a otra. El bit de paridad se hace ya sea 0 o 1, dependiendo del número de unos que están contenidos en el grupo codificado.

    Se usan dos métodos diferentes. En el método de paridad par el valor del bit de paridad se escoge de tal manera que el número total de unos en el grupo codificado (incluyendo el bit de paridad) sea un número par. Supóngase por ejemplo, que el grupo codificado es 10110. El grupo codificado tiene tres unos. Por tanto, se añade un bit de paridad de 1 para hacer el número total de unos un valor par. El nuevo grupo codificado, incluyendo el bit de paridad es:

10110

1  
  ^  
bit de paridad añadido

   Si el grupo codificado contiene un número par de unos inicialmente, el bit de paridad recibe el valor de 0. Por ejemplo, si el código es 10100, el bit de paridad asignado sería 0, así que el nuevo código, incluyendo el bit de paridad sería 101000.

   El método de paridad impar se usa exactamente de la misma manera, excepto que el bit de paridad se escoge de tal modo que el número total de unos (incluyendo el bit de paridad) sea un número impar. Por ejemplo, para el grupo codificado 01100, el bit de paridad asignado sería un 1. Para el grupo 11010, el bit de paridad sería un 0.

división binaria parte entera.gif (11386 bytes)    Sin importar si se usa paridad par o impar, el bit de paridad se añade a la palabra codificada y es transmitido como parte de la palabra codificada. La figura adjunta muestra como se usa el método de paridad.

    Los bits del grupo codificado están representados por A, B y C. Estos bits pudieran venir de las salidas de un conversor de código. Se alimentan entonces a un circuito generador de paridad, el cual es un circuito lógico que examina los bits de entrada y produce un bit de paridad de salida del valor correcto. El bit de paridad se transmite junto con los bits de entrada, como lo muestra la figura adjunta.

   La siguiente tabla muestra la forma de obtener los bits de paridad para el código binario de 3 bits. Pp y Pi, son las funciones resultantes de aplicar paridad par e impar, respectivamente.

Decimal A B C Pp Pi
0 0 0 0 0 1
1 0 0 1 1 0
2 0 1 0 1 0
3 0 1 1 0 1
4 1 0 0 1 0
5 1 0 1 0 1
6 1 1 0 0 1
7 1 1 1 1 0

   Las funciones de conmutación correspondientes a los bits de verificación son:

Pp (A, B, C) = 3m (1,2,3,4,7)
Pi  (A, B, C) = 3m (0,3,5,6)

división binaria parte entera.gif (11386 bytes)    Tanto de la tabla como de las ecuaciones, se observa que Pp y Pi son complementarios. La figura adjunta muestra la reducción de Pp por mapas K:

    La función reducida es:

Pp (A, B, C) = A'B'C + A'BC' + AB'C' + ABC =
                            
(1)           (2)           (3)           (4)
                    =
A'(B'C + BC') + A(B'C' + BC) =
                    =
A'(B r C) + A(B r C)' =
                    =
A r B r C

    Como Pi es el complemento de Pp, entonces:

Pi (A, B, C) = (A r B r C)'

   logigrama prioridad.gif (14937 bytes)El logigrama de Pp junto con una posible aplicación es:

    Cuando los bits transmitidos alcanzan su destino, son alimentados a un circuito comprobador de paridad, el cual es un circuito lógico que examina todos los bits para determinar si la paridad correcta está presente. En un sistema de paridad par, el comprobador de paridad generará una salida baja de error si el número de entradas1 es un número par y una salida de error alta (indicando un error) si el número de entradas 1 es impar. En un sistema de paridad impar sería al contrario.

    Si ocurre un error en uno de los bits transmitidos, el circuito comprobador de paridad lo detectará. Por ejemplo, supongamos que los bits del grupo codificado son 0110 y que estamos usando un sistema de paridad impar. El circuito generador de paridad generará entonces un 1 para un bit de paridad, así que será transmitido 01101. Si estos bits llegan al comprobador de paridad sin cambio, éste producirá una salida 0 (ningún error). Sin embargo, si uno de los bits cambia antes de llegar al verificador de paridad (tal como 00101 en lugar de 01101),   el comprobador de paridad se hará alto indicando que ha ocurrido un error en la transmisión. La salida de error puede usarse para sonar una alarma, detener la operación del sistema o activar un indicador de error.

    Debería ser aparente que este método de paridad puede detectar errores únicos pero no puede detectar errores dobles. Esto es porque un error doble no cambiará la paridad del grupo de bits, así que el verificador de paridad indicará ningún error. También, este método de paridad no señala al error; esto es, no determina al bit erróneo. Para detectar y señalar errores dobles, deberán usarse métodos más sofisticados, que permitan hacer correcciones. Tal es el caso del método de Hamming, tratado a continuación.


4    CÓDIGOS PARA DETECCIÓN Y CORRECCIÓN DE ERRORES

    Uno de los métodos más empleados para detectar y corregir errores es el código desarrollado por Hamming. A continuación se presentan algunas definiciones iniciales:

    La expresión que relaciona la distancia mínima, detección y corrección de errores es:

M - 1 = D + C para toda C <= D                                         (1)

    Donde:

M = Distancia mínima
D =
Bits erróneos que se detectan
C =
Bits erróneos que se corrigen

    La Tabla 1, muestra la relación para diferentes valores de M, D y C:

Tabla 1  
M D C  
0
1
2
0
0
1
0
0
0
 
3 2
1
0
1
Código de
Hamming
4 3
2
0
1
 
5 4
3
2
0
1
2
 

    Considerando a:

k = Número de bits de verificación de paridad

    y

M = k

    Entonces, la relación entre los bits de paridad y los bits del código original, está dada por la siguiente expresión:

2k - 1 = k + n                                         (2)

donde:

n       = No. de bits del código original
k + n =
No. de bits del nuevo código

    La siguiente tabla, muestra la relación entre k y n, para algunos valores de k:

k n k + n  
0 0 0  
1 0 1  
2 1 3  
3 4 7 Código de Hamming
4 11 15  
5 26 31  

    De la tabla anterior, se observa que entre más bits de seguridad se deseen en el código de interés, el número de bits de éste aumenta considerablemente.

    Para un código original de 4 bits A, B, C y D, al que le corresponden 3 bits de paridad C1, C2 y C3, éstos se colocan en las posiciones 2n, con n=0,1,2; es decir, en las posiciones 1, 2 y 4, como se muestra a continuación:

1 2 3 4 5 6 7
C1 C2 A C3 B C D

    Cada bit de paridad se selecciona para generar paridad (par o impar) en las siguientes posiciones:

C1 6 1,3,5,7
C2 6 2,3,6,7
C3 6 4,5,6,7

   Una manera sencilla de recordar las posiciones para generar paridad de cada uno de los bits de paridad, se muestra en la siguiente tabla:

  1 2 3 4 5 6 7 Posición
C1 1 0 1 0 1 0 1 1,3,5,7
C2 0 1 1 0 0 1 1 2,3,6,7
C3 0 0 0 1 1 1 1 4,5,6,7

Por ejemplo, si se quiere transmitir 910 = 10012 con paridad par, el nuevo código será:

1 2 3 4 5 6 7  
C1 C2 A C3 B C D  
0 0 1 1 0 0 1 nuevo código

EJEMPLO 3   Dado el código exceso-3 (BCD), obtener el nuevo código con distancia mínima de 3 (M = 3) y diseñar el circuito generador de paridad.

SOLUCIÓN

a)    Tabla funcional.

DEC Código exceso-3 mi Código a transmitir
E3 E2 E1 E0 C1 C2 E3 C3 E2 E1 E0
0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
1
1
1
1
1
0
1
1
1
1
0
0
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
3
4
5
6
7
8
9
10
11
12
1
1
0
1
0
1
0
1
0
0
0
0
1
1
0
1
0
0
1
1
0
0
0
0
0
1
1
1
1
1
0
1
0
0
1
0
1
1
0
1
0
1
1
1
1
0
0
0
0
1
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
0
10
:
15
        0-2
:
13-15
x
:
x
x
:
x
  x
:
x
     

b)    Funciones de conmutación: Las funciones de conmutación correspondientes a los bits de verificación de paridad son:

C1(E3,E2,E1,E0) = 3m (3,4,6,8,10) + 3x (0-2,13-15)
C2(E3,E2,E1,E0) = 3m (5,6,8,11,12) + 3x (0-2,13-15)
C3(E3,E2,E1,E0) = 3m (4,7,9,10,12) + 3x (0-2,13-15)

c)    Reducción por mapas K: Los mapas K para los bits de verificación son:

división binaria parte entera.gif (11386 bytes)

división binaria parte entera.gif (11386 bytes)

   De los mapas, se obtienen las siguientes funciones reducidas:

C1(E3, E2, E1, E0) = E3'E0' + E2'E0' + E3'E2'
                                   
(1)            (2)            (3)

C2(E3, E2, E1, E0) = E3E1'E0' + E2E1'E0 + E3E1E0 + E2E1E0' =
                                    
(1)                 (2)                 (3)               (4)
                             =
E3(E1'E0' + E1E0) + E2(E1'E0 + E1E0') =
                             =
E3(E1 r E0)' + E2(E1 r E0)

C3(E3, E2, E1, E0) = E2E1'E0' + E2E1E0 + E3E1'E0 + E3E1E0' =
                                     
(1)                (2)                (3)               (4)
                              =
E2(E1 r E0)' + E3(E1 r E0)

d)    Logigrama:

división binaria parte entera.gif (11386 bytes)


EJEMPLO 4.     Determinar las posiciones de paridad para los bits de verificación para k=4 (distancia mínima igual a 4).

SOLUCIÓN

    Sustituyendo el valor de k en la expresión (1), se tiene:

2k - 1 = 24 - 1 = 15 = k + n

       Por tanto, el número de bits del código original, n, es igual a 11.  El código a transmitir es de 15 bits (k+n).

    La posición para determinar la paridad de los bits de verificación se obtiene de la siguiente tabla:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
C1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
C2 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
C3 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
C4 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

Para C1: Se debe tener paridad par en las posiciones: 1,3,5,7,9,11,13,15
Para
C2: Se debe tener paridad par en las posiciones: 2,3,5,7,10,11,14,15
Para
C3: Se debe tener paridad par en las posiciones: 4,5,6,7,12,13,14,15
Para
C4: Se debe tener paridad par en las posiciones: 8,9,10,11,12,13,14,15

    Como los bits de verificación deben estar en una posición correspondiente a una combinación binaria (1,2,4,8), entonces el código a transmitir es:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
C1 C2 x10 C3 x9 x8 x7 C4 x6 x5 x4 x3 x2 x1 x0

   Donde: C1, C2, C3 y C4 son los bits de verificación y x10, x9, ... , x0 corresponden al código original.


5    EJERCICIOS


  1. Realice un circuito convertidor de código Gray a binario para 4 bits, de tal manera que se utilicen sólo compuertas O EXCLUSIVAS.

  1. Realice los siguientes conversores de código, cuya codificación se muestra en la tabla:

a)    De BCD a 8 4 -2 -1.
b)    De BCD a 2 4 2 1

BCD 8 4 -2 -1 2 4 2 1
A B C D W X Y Z
0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
1
1
1
1
1
0
1
1
1
1
0
0
0
0
1
0
1
1
0
0
1
1
0
0
1
0
1
0
1
0
1
0
1
0
1
0
0
0
0
0
1
1
1
1
1
0
0
0
0
1
0
1
1
1
1
0
0
1
1
0
1
0
0
1
1
0
1
0
1
0
1
0
1
0
1
10
:
15
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x
x
:
x

NOTA: Considere los términos indiferentes.


  1. Obtenga el diagrama lógico mínimo del conversor de código de exceso-3 (BCD) a un código BCD autocomplementario, cuyas combinaciones 0, 1, 2,  y 4 están excedidas en 2 y las restantes tienen un exceso en 4.

Obtenga el mayor número de relaciones exclusivas posibles para realizar el diagrama lógico.


  1. Diseñe el circuito que permita transmitir el código 8 4 -2 -1 (BCD) con distancia mínima de 3. Considere las condiciones irrelevantes.


  1. Se desea transmitir el número 5710 empleando la técnica de Hamming. ¿Cuál es el código deseado?


  1. Si se recibe el siguiente mensaje:

110000011101101

Determine si existe error y en qué posición se encuentra.


  1. Codificar el carácter de información 01101110101 de acuerdo con el código de Hamming de 15 bits.

  1. Si existe, determinar cuál bit está equivocado en el carácter con código de Hamming 1100111.

  1. Dado el siguiente diagrama a bloques de un circuito combinacional:

división binaria parte entera.gif (11386 bytes)a)    Obtenga las salidas mínimas del bloque (1) como una suma de productos.

b)    Obtenga las salidas mínimas del bloque (2) como suma de productos.

c)    Realice el logigrama de a) y b) utilizando sólo inversores y compuertas No-Y.

NOTA: A, E3 y C1 son las variables de mayor peso binario. Considere los términos indiferentes.

 


  1. .    Dado el siguiente diagrama a bloques de un circuito combinatorio:

división binaria parte entera.gif (11386 bytes)a)    Obtenga las salidas mínimas del bloque (1) como un producto de sumas.

b)    Obtenga las salidas mínimas del bloque (2) como un producto de sumas.

c)    Realice el logigrama de a) y b) utilizando sólo inversores y compuertas No-O

NOTA: A, H1 y E3 son las variables de mayor peso binario. Considere los términos indiferentes.

 

 


  1. .    Dado el código 8 4 -2 -1 (BCD), determine el nuevo código de Hamming con distancia mínima de 3 y obtenga el logigrama reducido utilizando sólo inversores y compuertas No-O. Considere los términos indiferentes.


      división binaria parte entera.gif (11386 bytes)12.    Diseñe un circuito mínimo de segundo orden para convertir una entrada decimal codificada en binario a una salida biquinaria (2 de 7). Como se indica en la figura adjunta, deberá contar con 4 entradas y 7 salidas. Los códigos para la entrada y la salida correspondientes a los dígitos decimales se dan en la siguiente tabla. Se puede suponer que las 6 combinaciones posibles de entrada no anotadas en ella (correspondientes a 10-15) nunca se producirán.

DÍGITO BCD BIQUINARIO
D8 D4 D2 D1 B5 B0 Q4 Q3 Q2 Q1 Q0
0
1
2
3
4
5
6
7
8
9
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
1
0
0
0
0
1
1
0
0
1
1
0
0
0
1
0
1
0
1
0
1
0
1
0
0
0
0
0
1
1
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
1
0
0
0
0
1
0
0
0
0