Unidad 1.pdf
Unidad 1.pdf
Unidad 1.pdf
Create successful ePaper yourself
Turn your PDF publications into a flip-book with our unique Google optimized e-Paper software.
<strong>Unidad</strong> 1<br />
SISTEMAS NUMERICOS<br />
Objetivos<br />
• Comprender el manejo de números y operaciones aritméticas desde un lenguaje de<br />
programación de bajo nivel.<br />
• Repasar los métodos de representación numérica de los sistemas: decimal, binario,<br />
octal y hexadecimal, para números enteros y fraccionarios.<br />
• Discutir los métodos de conversión entre los sistemas numéricos de nuestro interés,<br />
tanto para números enteros y fraccionarios.<br />
• Comprender la representación de números binarios con signo empleando la notación<br />
complemento a 2.<br />
• Repasar las operaciones aritméticas elementales: suma, resta, multiplicación y<br />
división.<br />
• Establecer claramente el concepto de “overflow” y su comparación con el “carry”.<br />
• Concepto de punto fijo y flotante.<br />
• Comprender la necesidad de codificar la información.<br />
• Describir lo métodos de detección y corrección de errores: paridad, “checksum”,<br />
códigos de redundancia cíclica y “Hamming”.<br />
1 INTRODUCCION<br />
Un microprocesador, como cualquier sistema digital, emplea dos estados (0 y 1) para la<br />
representación de información. Cabe recordar que los símbolos 1 y 0 representan esos dos<br />
estados y no tienen ningún significado numérico por sí mismos. Sin embargo, cuando estos<br />
símbolos se utilizan para representar los dígitos del sistema numérico binario, ellos se deben<br />
manejar de acuerdo a las reglas del sistema numérico. Por lo tanto, en esta unidad se verá el<br />
tratamiento de los sistemas numéricos necesario para su implementación en computadoras.<br />
Al final de la unidad veremos la necesidad de codificar la información y distintas alternativas<br />
para la detección y corrección de errores en la transmisión de datos.<br />
2 SISTEMA DE NUMERACIÓN<br />
Un sistema de numeración es un conjunto de símbolos y reglas de generación que<br />
permiten construir todos los números válidos en el sistema. Un sistema de numeración puede<br />
representarse como N = S + R donde:
• N es el sistema de numeración considerado.<br />
• S son los símbolos permitidos en el sistema. En el caso del sistema decimal son<br />
{0,1...9}; en el binario son {0,1}; en el octal son {0,1...7}; en el hexadecimal son<br />
{0,1...9,A,B,C,D,E,F}.<br />
• R son las reglas de generación que nos indican qué números son válidos y cuáles son<br />
no-válidos en el sistema.<br />
Estas reglas son diferentes para cada sistema de numeración considerado, pero una regla<br />
común a todos es que para construir números válidos en un sistema de numeración<br />
determinado sólo se pueden utilizar los símbolos permitidos en ese sistema (para indicar el<br />
sistema de numeración utilizado se añade como subíndice al número).<br />
De una forma general y amplia podemos clasificar los sistemas de numeración en dos<br />
grandes tipos:<br />
Posicionales: El valor de los símbolos que componen el sistema depende del valor que se les<br />
ha asignado, y de la posición que ocupan en el número (Números decimales).<br />
No Posicionales: El valor de los símbolos que componen el sistema es fijo, y no depende de<br />
la posición que ocupa el símbolo dentro del número (Números romanos)<br />
3 METODOS DE REPRESENTACION NUMERICA<br />
Un número N, en un sistema de numeración posicional, se representa como:<br />
donde:<br />
N = dp-1*b p-1 + dp-2*b p-2 + .....+ d0*b 0 + d-1*b -1 + d-q*b -q [1]<br />
b : base o raíz del sistema numérico.<br />
d´s: dígitos o símbolos del sistema numérico, que son los b dígitos permitidos.<br />
p : número de dígitos enteros.<br />
q : número de dígitos fraccionarios.<br />
N se puede expresar como:<br />
N = dp-1dp-2 ... d0.d-1d-2 ... d-q<br />
punto base<br />
p = 0 número fraccionario<br />
q = 0 número entero<br />
p0 y q0 número mixto<br />
3.1 Sistema Decimal<br />
N10 = 27,510 = 2*10 1 + 7*10 1 + 5*10 -1
(base)= 10<br />
d (dígito)= 0,1,2,3,4,5,6,7,8,9<br />
p=2 y q=1.<br />
3.2 Sistema Binario<br />
N2 = 101.012 = 1*2 2 + 0*2 1 + 1*2 0 + 0*2 -1 + 1*2 -2 = 4 + 0 + 1 + 0 + 1/4 = 5.2510<br />
b (base) = 2<br />
d (dígito)= 0,1<br />
p=3 y q=2.<br />
3.3 Sistema decimal codificado en BCD<br />
Decimal Binario<br />
0 0000<br />
1 0001 El código BCD es la representación<br />
2 0010 de los 10 dígitos del sistema decimal<br />
3 0011 con 4 bits del sistema binario.<br />
4 0100<br />
5 0101<br />
6 0110<br />
7 0111<br />
8 1000<br />
9 1001<br />
- 1010<br />
| 1011<br />
| 1100<br />
no 1101<br />
usados 1110<br />
| 1111<br />
3.4 Sistema Octal<br />
N8 = 34.18 = 3*8 1 + 4*8 0 + 1*8 -1 = 24 + 4 + 1/8 = 28.12510<br />
b (base) = 8<br />
d (dígito) = 0,1,2,3,4,5,6,7<br />
p=2 y q= 1.<br />
3.5 Sistema Hexadecimal<br />
N16 = D56.A216 = 13*16 2 + 5*16 1 + 6*16 0 + 10*16 -1 + 2*16 -2 = 3414.632810
(base) = 16<br />
d (símbolo) = 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F<br />
p=3 y q=2<br />
La utilidad y conversión con el sistema binario es similar al sistema octal, con la única<br />
diferencia que los bits se agrupan de a cuatro. Este sistema es usado como entrada/salida en<br />
muchas aplicaciones con microprocesadores, como kits de desarrollo, interfaces, etc., ya que<br />
provee un medio eficiente para especificar direcciones, datos e instrucciones (8 y 16 bits).<br />
4 RANGO DE UN NUMERO<br />
Cuando se representan números en una base b y m dígitos, hay b m números posibles en un<br />
rango de 0....b m-1 .<br />
Sea Nb un número entero cualquiera, éste tendrá un equivalente decimal que caerá en el<br />
rango 0...b m-1 , y podrá ser representado exactamente como muestra la Fig. 1.1<br />
Sea:<br />
b: base<br />
m: número de dígitos<br />
Entonces habrá b m números en el rango [0 ..... b m–1 ]<br />
Números Enteros<br />
|__________|_________|__________| b=2<br />
00 01 10 11 m=2<br />
Nb = 012 =110<br />
Números Fraccionarios (rango [0...1] )<br />
Figura 1.1<br />
Cuando se trabaja con números fraccionarios hay infinitos números en el intervalo entre 0<br />
y 1, por lo tanto, como m (número de dígitos) es finito, únicamente se pueden representar b m<br />
fracciones (puntos), siendo el salto entre puntos:<br />
(@: Intervalo de resolución)<br />
@ = b -m [2]<br />
|____|____|____|____|____|__....__|____|____|<br />
0 | | 1<br />
@<br />
valor de fracción que puede ser representado exactamente.<br />
Figura 1.2
Aproximaciones:<br />
Para representar una fracción (punto) que no corresponda a los valores de representación<br />
exacta, será necesario aproximar. Para ello hay dos formas comunes:<br />
- Truncación<br />
- Redondeo<br />
Sea Fb el valor verdadero del número tal cual se expresa a continuación:<br />
Fb = .a-1a-2a-3...a-ma-(m+1)a-(m+2)....a-(m+p)<br />
∑ −1<br />
−i<br />
i *<br />
i=<br />
−(<br />
m+<br />
p)<br />
b<br />
Siendo m el número de dígitos a utilizar.<br />
4.1 Truncación<br />
a [3]<br />
Se dice que una fracción es truncada cuando todos los dígitos a la derecha de a-m se<br />
desprecian.<br />
@<br />
|______...__________|___________.______|________.....<br />
0 fv Fb fv+1<br />
Et<br />
fv: valor truncado<br />
Fb: valor real<br />
Et: error por truncación (Et < b -m )<br />
Figura 1.3<br />
El máximo error cometido (ver Fig 1.3) será siempre menor que el intervalo de<br />
resolución; es decir:<br />
Ejemplo<br />
Fb = .23749<br />
fv = .237<br />
m = 3<br />
donde fv es el valor truncado.<br />
Et < b -m
4.2 Redondeo<br />
Se dice redondeo cuando se selecciona el valor más próximo al valor deseado, es decir que<br />
verifica si el valor se encuentra de la mitad del intervalo de resolución a la derecha o a la<br />
izquierda. Por supuesto, esto requiere una complejidad adicional en el hardware.<br />
@<br />
|______...__________|___________.______|________.....<br />
0 fv Fb fv+1<br />
Et<br />
Er: error por redondeo (Er ≤ @/2 )<br />
Fb = .23749<br />
fv = .238<br />
m = 3<br />
donde fv es el valor por redondeo.<br />
Figura 1.4<br />
5 CONVERSION DE SISTEMAS NUMERICOS<br />
Las conversiones más importantes son: decimal-binario, decimal-octal y decimal-<br />
hexadecimal, ya que cualquier otra conversión entre esos cuatro sistemas se puede realizar<br />
como una combinación de los anteriores. En muchos casos, la conversión de un número<br />
fraccionario finito, expresado en un sistema numérico de base b1, no produce un número<br />
fraccionario finito equivalente en una base b2. El error entre ambas representaciones lo<br />
determina el número de dígitos empleados en la representación en la base b2.<br />
5.1 Conversión Decimal-Binario<br />
La conversión de números enteros y fraccionarios decimales en binarios, se lleva a cabo por<br />
sucesivas divisiones y multiplicaciones, respectivamente, por la base (2).<br />
Números Enteros<br />
Como resultado de la división de un número decimal por dos, se obtiene un cociente Q y un<br />
resto R. Los restos que se obtienen de las sucesivas divisiones son los bits del número<br />
binario. El resto R es siempre un número entero menor que el divisor (dos en este caso), por<br />
lo tanto R puede ser 0 ó 1.<br />
N = dp-1*2 p-1 + dp-2*2 p-2 + .....+ d0*2 0<br />
1. N/2 = dp-1*2 p-2 + dp-2*2 p-3 + .....+ d0*2 -1<br />
|____________________||______|<br />
Q0: cociente R0: resto<br />
d0=R0: bit menos significativo
2. Q0/2 = Q1 + d1 * 2 -1<br />
d1=R1: próximo bit<br />
. .<br />
. .<br />
. .<br />
p. Qp-2/2 = Qp-1 + Rp-1 donde Qp-1= 0<br />
dp-1=Rp-1: bit más significativo.<br />
Ejemplo:<br />
N=13<br />
13/2 = 6 y R0=1<br />
6/2 = 3 y R1=0<br />
3/2 = 1 y R2=1<br />
1/2 = 0 y R3=1 1310 = 11012<br />
Números Fraccionarios<br />
En este caso se multiplica sucesivamente por dos. Los enteros resultantes son los<br />
sucesivos dígitos a la base convertida.<br />
N = d-1*2 -1 + d-2*2 -2 + ... + d-q*2 q<br />
1. 2*N = d-1*2 0 + d-2*2 -1 + ... + d-q*2 -q+1<br />
|_____| |_________________|<br />
I-1: entero X-1: fracción<br />
d-1=I-1: bit menos significativo.<br />
2. 2*X-1 = d-2*2 0 + d-3*2 -1 + ... + d-q*2 -q+2<br />
|_____| |__________________|<br />
I-2: entero X-2: fracción<br />
d-2=I-2: próximo bit<br />
. .<br />
. .<br />
q+1. 2*X-q+1 = d-q*2 0 = I-q<br />
d-q=I-q: bit más significativo<br />
Ejemplo<br />
N=0.55<br />
2*0.55 = 1.1 ---> d-1= 1<br />
2*0.1 = 0.2 ---> d-2= 0<br />
2*0.2 = 0.4 ---> d-3= 0<br />
2*0.4 = 0.8 ---> d-4= 0<br />
2*0.8 = 1.6 ---><br />
0.5510 = 0.100012<br />
d-5= 1
5.2 Conversión Decimal-Octal<br />
La conversión de números enteros y fraccionarios decimales a octales se lleva a cabo por<br />
sucesivas divisiones y multiplicaciones, respectivamente, por la base (8).<br />
Ejemplo:<br />
N=1310<br />
13/8 = 1 y R0 = 5 1310 = 158<br />
1/8 = 0 y R1 = 1<br />
5.3 Conversión Decimal-Hexadecimal<br />
La conversión de números enteros y fraccionarios decimales a hexadecimales se lleva a<br />
cabo por sucesivas divisiones y multiplicaciones, respectivamente, por la base (16).<br />
Ejemplo:<br />
N=1310:<br />
13/16 = 0 y R0 = 13 1310 = D16<br />
6 NUMEROS CON SIGNO<br />
En el sistema binario (b=2) si se disponen de m dígitos, es posible representar 2 m números<br />
en un rango de 0 hasta 2 m -1. Con esta restricción, si se necesita representar números con<br />
signo, es necesario resignar el rango de operación (2 m-1 -1), ya el bit más significativo<br />
representa el signo del número.<br />
Las premisas más importantes que debe cumplir un buen sistema de representación son:<br />
que tenga igual cantidad de números positivos como negativos, que exista un único cero, que<br />
se puedan realizar las operaciones aritméticas básicas (suma, resta, multiplicación y división),<br />
etc.<br />
6.1 Representación<br />
Hay tres formas básicas de representar números con signo en el sistema binario.<br />
• Bit de Signo o "Magnitud Signada"<br />
• Complemento a dos<br />
• Complemento a uno<br />
Debido a que en el sistema binario no se encuentran otros símbolos más que 0 y 1, es que<br />
se utiliza el bit más significativo del número como signo del número. Donde un 0 significa<br />
que el número positivo, y un 1, que es un número negativo.
6.1.1 Bit de Signo o “Magnitud Signada”<br />
En esta representación, para una palabra de n bits, los n-1 bits de la derecha representan la<br />
magnitud del número y el número positivo si comienza con cero (0) y si el mismo empieza<br />
con uno (1) el número es negativo.<br />
Ejemplo:<br />
Sea N = 810 = 10002<br />
8 = 01000<br />
-8 = 11000<br />
6.1.2 Complemento a Dos<br />
El complemento (N') de un número (N) en una base b se define como:<br />
p: número de dígitos de N<br />
b: base<br />
b p : módulo<br />
N' = b p – N [4]<br />
El módulo toma distintas denominaciones de acuerdo con el sistema numérico que se emplee.<br />
Por ejemplo, para el sistema decimal, se denomina complemento a 10, y para el sistema<br />
binario, complemento a 2.<br />
Ejemplo<br />
N=2010 -----> N' = 100 - 20 = 80<br />
N=10012 -----> N' = 10000 - 1001 = 0111<br />
Es importante notar que el complemento de un número depende del módulo elegido.<br />
Hay dos formas de hallar el complemento a dos de un número:<br />
• Hallar el complemento lógico del número y luego sumarle 1.<br />
1001 -----> 0110 ------> 0110 + 1 = 0111<br />
• Comenzando del bit menos significativo, dejar todos los bits sin cambio hasta el<br />
primer 1 inclusive, luego complementar los restantes.<br />
6.1.3 Complemento a Uno<br />
El complemento a 1 (N") de un número (N), también llamado complemento de base<br />
disminuida, no es más que el complemento lógico del número o el complemento a dos menos<br />
uno.<br />
N" = b p - N - 1
si el número fuese mixto (q 0),<br />
N" = b p - b -q - N<br />
6.1.4 Complemento Como Números Negativos<br />
Para representar números con signo en la forma de complemento, se consideran números<br />
negativos a aquéllos cuyo bit más significativo es "1", y números positivos a aquéllos cuyo<br />
bit más significativo es "0". La diferencia con magnitud-signada, radica en la forma de<br />
interpretar los bits restantes.<br />
La representación de números positivos y negativos como complemento, tiene<br />
significativas ventajas sobre la representación bit de signo desde el punto de vista de<br />
hardware y de software.<br />
6.1.5 Números en Complemento a Dos<br />
Un número entero expresado en complemento a dos tiene la siguiente expresión:<br />
N = -d7*2 7 + . . . + di*2 i [5]<br />
Un número fraccionario expresado en complemento a dos tiene la siguiente expresión:<br />
La representación en una recta sería:<br />
1001 1011 1101 1111 0001 0011 0101 0111<br />
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|<br />
1000 1010 1100 1110 0000 0010 0100 0110<br />
-8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7<br />
N = -d0*2 0 + . . . . + d-i*2 -i [6]<br />
Sea p el número de bits incluido el bit de signo, entonces habrá 2 p números posibles siendo el<br />
rango de variación de números:<br />
6.1.6 Números en Complemento a Uno<br />
La representación en una recta sería:<br />
-2 p-1
Uno de los inconvenientes de esta representación es que tiene dos formas de representar el<br />
cero. Esto requiere de interpretaciones adicionales de los resultados para la toma de<br />
decisiones.<br />
6.1.7 Elección del Sistema de Representación Numérica<br />
Se pueden mencionar tres razones principales por las cuales la elección de la<br />
representación en complemento a dos es la más adecuada:<br />
1. El hardware aritmético es más simple que en bit de signo y no mucho más complejo<br />
que en complemento a uno.<br />
2. En complemento a uno y bit de signo existen dos formas de representar al cero<br />
(existe un +0 y un -0). Esto causa ciertos problemas en el hardware para la toma de<br />
decisiones, por ejemplo saltar si el resultado es negativo.<br />
3. Hay resultados incorrectos en complemento a uno y bit de signo que se deben<br />
corregir. Ejemplo:(-107)+(-10)= =-117<br />
6.2 OPERACIONES ARITMETICAS<br />
En un microprocesador la ALU (<strong>Unidad</strong> Aritmético-Lógica) es la parte del procesador<br />
encargada de realizar las operaciones aritméticas y lógicas con los datos suministrados. Los<br />
datos manejados por la ALU provienen y se almacenan en registros. La ALU debe además<br />
activar indicadores (banderas o “flags”) como resultados de las operaciones realizadas. Por lo<br />
tanto definiremos una serie de banderas que nos permitirán interpretar los resultados<br />
obtenidos. Y para poder descifrar a las banderas, debemos observar las operaciones<br />
aritméticas elementales.<br />
6.2.1 Suma Binaria<br />
La suma de M + N produce: M + N = S<br />
N 0 0 1 1<br />
M 0 1 0 1<br />
___________________________<br />
S 0 1 1 10<br />
transporte (“carry”)<br />
Las funciones lógicas que implementan la operación suma con la generación de su<br />
respectivo carry son:<br />
S = X + Y = X XOR Y<br />
Cy = X AND Y
El carry se produce cuando se supera la capacidad del dígito (en la base que se trabaje 1:<br />
binaria, 9: decimal) en una columna (peso) determinada. Cuando se trabaja con computadoras<br />
no se puede tener infinitos bits de representación de números. Es decir, que los números se<br />
representan por n bits (generalmente 4, 8, 16, 32 bits). Por lo tanto el flag de carry indica que<br />
tuve un desborde en el rango de representación de los números naturales (sin signo).<br />
Si el máximo rango de representación de números con signos (positivos o negativos) se<br />
excede, el flag de carry no nos brinda información de desborde del rango de representación.<br />
Cuando se trabaja con números enteros (con signo), la condición de desborde se indica con<br />
un flag denominado "overflow" (si se desbordan los números positivos) o "underflow" (si se<br />
desbordan los números negativos).<br />
6.2.1.1 Suma en Complemento a Dos<br />
En complemento a dos, con (n+1) bits se pueden representar números en el rango de (2 n -<br />
1) a (-2 n ). Por ejemplo, con 8 bits el rango es de +127 a -128. Por lo tanto, cualquier<br />
operación que exceda dicho rango producirá "overflow".<br />
Condiciones para la Detección de Overflow<br />
Se analizarán cuatro casos testigos, que permiten encontrar cuáles son las condiciones en<br />
las que se produce overflow, y así poder generalizarlo.<br />
0110 (+6) 0110 (+6) 1001 (-7) 1010 (-6)<br />
+ + + +<br />
0011 (+3) 0001 (+1) 1101 (-3) 1111 (-1)<br />
------ ---- ------ ---- ------ ---- ------ ----<br />
0 1001 -7 0 0111 +7 1 0110 +6 1 1001 -7<br />
donde:<br />
C=0 C=0 C=1 C=1<br />
Cs=1 Cs=0 Cs=0 Cs=1<br />
C : es el carry<br />
Cs: es el carry al bit de signo (bit2 bit3)<br />
Por lo tanto, ocurre overflow si y sólo si la suma de dos números de igual signo produce<br />
un número de signo opuesto.<br />
C Cs V<br />
0 0 0<br />
0 1 1<br />
1 0 1<br />
1 1 0<br />
Cs XOR C = V
Otra forma de determinar el overflow (V) es: Z XOR C. Sin embargo es necesario<br />
verificar previamente los signos de los operandos.<br />
6.2.2 Resta Binaria<br />
La resta binaria produce: M - N = R<br />
donde:<br />
M N R B (Borrow)<br />
0 0 0 0<br />
0 1 1 1<br />
1 0 1 0<br />
1 1 0 0<br />
R = M - N = M XOR N<br />
B = /M AND N<br />
M: minuendo<br />
N: sustraendo<br />
Si trabajamos con números naturales, el "borrow" significa que el minuendo es menor que<br />
el sustraendo, y se debe "pedir prestado" a la próxima columna.<br />
Una de las mayores ventajas de usar complemento, es que la resta se lleva a cabo tomando<br />
el complemento del sustraendo y luego se realiza la suma de los mismos. Es decir, se podría<br />
simplificar el hardware.<br />
Ejemplo:<br />
1100 (-4) 1100 (-4)<br />
- +<br />
0110 (+6) 1010 (-6)<br />
------ -------<br />
0 0110 -10 1 0110 -10<br />
M - N = M + (comp N)<br />
6.2.2.1 Relaciones Overflow/Underflow – Carry/Borrow<br />
Se analizarán distintos casos que permitirán establecer relaciones entre los flags<br />
Overflow/Underflow – Carry/Borrow resultantes de operaciones de resta entre 2 números<br />
enteros.
0100 (+4) 0100 (+4) 1100 (-4) 1100 (-4)<br />
- + - +<br />
1011 (-5) 0101 (+5) 0110 (+6) 1010 (-6)<br />
------ ---- ------ ---- ------ ---- ------ ----<br />
1 1001 +9 0 1001 +9 0 0110 -10 1 0110 -10<br />
B=1 C=0 B=0 C=1<br />
Bs=0 Cs=1 Bs=1 Cs=0<br />
donde: C : carry<br />
Cs: carry al bit de signo (bit2 ---> bit3)<br />
B : borrow<br />
Bs: borrow del bit de signo (bit3 ----> bit2)<br />
Analizando los cuatro casos del ejemplo anterior se puede deducir que el borrow es el<br />
carry complementado y que el overflow es:<br />
V' = /B XOR /Bs = C XOR Cs = V<br />
donde:<br />
V’: es el overflow (denominado underflow ) que se produce en la resta.<br />
Por lo tanto, los circuitos que detectan el overflow en la suma también lo harán en la resta.<br />
En general, los procesadores utilizan el mismo bit para representar el carry y el borrow.<br />
Esto se debe a que son complementarios.<br />
6.3 Doble Precisión<br />
Cuando se desea mayor precisión en las operaciones aritméticas que las que provee un<br />
microprocesador utilizando la longitud de palabra estándar, se debe recurrir a la múltiple<br />
precisión.<br />
6.3.1 Suma<br />
Para realizar la suma se procede en igual forma que en simple precisión, con la única<br />
diferencia que la parte más significativa se debe sumar agregando el carry de la operación<br />
anterior.<br />
+<br />
1<br />
0110 1101<br />
1001 0110<br />
1001 0110
6.3.2 Resta<br />
Para realizar la resta se procede en igual forma que en simple precisión, con la única<br />
diferencia que la parte más significativa se debe restar teniendo en cuenta el borrow anterior.<br />
Una forma alternativa de implementarla sería complementar el sustraendo, y proceder como<br />
en el caso de la suma.<br />
1<br />
0001 1001 (25)<br />
+ +<br />
1110 1110 (-18)<br />
0000 0111 07<br />
Con respecto a las condiciones de overflow, valen las mismas reglas que en el caso de<br />
simple precisión.<br />
6.4 Operaciones en BCD<br />
El código BCD es la representación de los 10 dígitos del sistema decimal con 4 bits del<br />
sistema binario. Esta representación genera un conjunto de 6 valores no permitidos, que<br />
requiere que algunos resultados de operaciones aritméticas sean corregidos.<br />
6.4.1 Suma en BCD<br />
Los símbolos BCD son 0...9, por lo tanto, con 4 bits de representación, los símbolos A...F<br />
no son válidos. Esto quiere decir que al realizar operaciones aritméticas será necesario hacer<br />
algunas correcciones al resultado. Veremos los tres casos resultantes de una operación de<br />
suma aritmética:<br />
I. 0110 (6) II. 0110 (6) III. 1001 (9)<br />
+ + +<br />
0010 (2) 0111 (7) 1001 (9)<br />
0 1000 (8) correcto 0 1101 (13) incorr. 1 0010 (18) incorr.<br />
[0] [8] + +<br />
0110 (6) 0110 (6)<br />
1 0011 1 1000<br />
[1] [3] correcto [1] [8] correcto<br />
El caso I. es el único resultado correcto, por lo tanto no necesita ningún tipo de corrección.<br />
Los casos II. y III. Dan resultados incorrectos, por lo tanto es necesario adicionarle 6 para<br />
obtener el valor correcto. Resumiendo, hay dos casos de ajuste decimal de la suma de dos<br />
números A y B:<br />
• si A + B ≥ 10 con carry = 0<br />
• si A + B < 10 con carry = 1
Para usar BCD con signo será necesario usar un bit adicional (en un lugar de memoria)<br />
para llevar el signo.<br />
6.4.2 Resta BCD<br />
Hay dos formas posibles para realizar la resta BCD:<br />
a. Realizar un hardware que realice la resta decimal con borrow.<br />
b. Hallar el complemento a 10 del sustraendo en BCD y luego sumarlos.<br />
Para hallar el complemento a 10 de un número BCD de dos dígitos se puede hacer lo<br />
siguiente:<br />
a. Obtener el complemento a dos de cada dígito individualmente, sin tener en cuenta el<br />
carry.<br />
b. Sumar al dígito menos significativo 1010, y al más significativo, 1001.<br />
Ejemplo<br />
0010 0110 (26)<br />
1110 1010 complemento a 2 individual<br />
+<br />
1001 1010<br />
0111 1010 7410<br />
10010 - 2610 = 7410<br />
6.5 Representación Punto Flotante (FP)<br />
Hasta ahora tratamos con números enteros y/o fraccionarios en notación punto fijo. Es<br />
decir, que los números se representan por una cantidad fija de dígitos y cuyo punto base<br />
(decimal, binario, etc.) era fijo. Este tipo de representación limita el rango de números a<br />
representar (por ejemplo, en complemento a 2 es: [2 m-1 - 1] a [-2 m-1 ] ). La representación en<br />
punto flotante (FP) básicamente presenta las ventajas de ajustar automáticamente la escala y<br />
extender el rango de números que el procesador puede manejar.<br />
Los primeros microprocesadores (4 y 8 bits) no implementaban aritmética en punto<br />
flotante (FP) debido al reducido canal de datos y a la baja velocidad de operación. Sólo<br />
cuando era necesario, se recurría a implementaciones por software. El advenimiento de los<br />
microprocesadores de 16, 32 y 64 bits hicieron posible las implementaciones de aritmética en<br />
FP.<br />
La representación de un número en FP se la siguiente:<br />
N * r p
donde:<br />
N: es la mantisa<br />
r: es la base<br />
p: es el exponente<br />
Dado un número fijo de bits para la representación en FP, existe un compromiso entre<br />
rango y precisión: Cuando mayor es el rango, menor es la precisión.<br />
Formato<br />
Actualmente la Sociedad del IEEE propuso el estándar P754 para aritmética en FP para<br />
números binarios. Este estándar especifica los formatos de números en FP, los resultados de<br />
las operaciones en FP, conversión de números, etc.<br />
Un número en FP se representa como una cadena de bits compuesta por tres componentes<br />
básicos:<br />
Signo de la mantisa (s)<br />
Mantisa (l.f)<br />
Exponente entero con signo (e)<br />
En algunos casos se considera un cuarto campo que corresponde al signo del exponente.<br />
s Exponente (e) 1 Fracción (f) .<br />
Bit: 0 1 8 9 10 31<br />
Si s = 0 el número es positivo y si s = 1, es negativo. El exponente e es la potencia de 2<br />
que determina el rango del número. Y la mantisa, (l.f), determina la precisión del número. La<br />
mayor exactitud se logra cuando l = 1. De esta forma, cualquier número, distinto de cero, se<br />
puede expresar como:<br />
Exponente<br />
± 2 e * (1.f)<br />
El exponente de un número binario en FP puede ser:<br />
Exponente con signo en complemento a dos o en magnitud y signo.<br />
Exponente polarizado.<br />
En el primer caso, el exponente es un número con expresado en alguna de las formas de<br />
expresión de números con signo.<br />
En el segundo caso, correspondiente a la representación estándar del IEEE, al exponente<br />
se le adiciona un número entero constante (polarización) que lo mantiene siempre positivo.<br />
Sea N el número de bits del exponente, por lo tanto la polarización será: 2 N-1 -1 (es decir, la<br />
polarización será de la forma 0111....111).
6.6 Multiplicación<br />
El producto binario P de 2 números X (multiplicando) e Y (multiplicador) es:<br />
X Y P<br />
0 0 0<br />
0 1 0<br />
1 0 0<br />
1 1 1<br />
Sea N:<br />
N = dp-1*2 p-1 + dp-2*2 p-2 + .....+ d0*2 0<br />
Si multiplicamos por la base (2) será:<br />
Ejemplo:<br />
2 * N = dp-1*2 p + dp-2*2 p-1 + .....+ d0*2 1<br />
N = 101<br />
2 * N = 1010<br />
o sea, multiplicar por dos es equivalente a desplazar un bit a la izquierda completando con<br />
ceros en la derecha.<br />
Ejemplo<br />
1011<br />
* 1101<br />
1011<br />
0000<br />
1011<br />
1011<br />
10001111<br />
Veamos algunos algoritmos de multiplicación:<br />
Algoritmo de multiplicación de números naturales:<br />
Sean X e Y dos números de p y q bits, respectivamente. Para implementar el producto será<br />
necesario utilizar dos registros: uno de p+q lugares, para almacenar el producto parcial, y<br />
otro, de p+q-1 lugares, a donde se llevará y rotará X. En los microprocesadores, esto se<br />
puede realizar por hardware o software. En el primer caso, se consigue mayor velocidad, y en<br />
el segundo, mayor flexibilidad.
Algoritmo de Booth:<br />
Este es un algoritmo para multiplicar números con signo expresados en complemento a<br />
dos, sin tener necesidad de testear previamente los signos.<br />
Ejemplo:<br />
Sumar<br />
N<br />
N<br />
Testear<br />
Transiciones en el<br />
Multiplicador<br />
Iguales<br />
0 1<br />
Desplazamiento<br />
Aritmético<br />
Último<br />
Bit<br />
N<br />
S<br />
Restar<br />
Se aplicará el algoritmo de Booth para realizar el producto de dos números<br />
negativos (-3 * -5).<br />
S<br />
S
6.7 División<br />
-3 111101<br />
* -5 111011(0)<br />
15 000000<br />
000011<br />
000011<br />
0000011<br />
00000011<br />
111101<br />
11110111<br />
111110111<br />
000011<br />
000001111<br />
0000001111<br />
00000001111<br />
000000001111 15<br />
\/<br />
signo<br />
La división de un número M/N es:<br />
donde:<br />
M = N*Q + R1<br />
M: dividendo<br />
N: divisor<br />
R1: resto<br />
Q: cociente<br />
Un algoritmo que pueda realizar la división de números naturales, M/N, consiste en restar<br />
sucesivamente R-N (donde R es inicialmente igual a M, y luego R=R-N) hasta que haya<br />
borrow. Entonces en Q nos queda la cantidad de veces que entra el divisor en el dividendo.
7 CODIGOS<br />
Algunos ejemplos de códigos son:<br />
ASCII<br />
EBCDIC<br />
EXCESO 3<br />
GRAY<br />
7.1 Manejo de Información Empaquetada y Desempaquetada<br />
Es muy importante el manejo de información en la memoria del microprocesador. Por<br />
ejemplo, información codificada en ASCII se puede almacenar en la memoria en forma<br />
empaquetada o desempaquetada: supongamos que se desea almacenar los caracteres<br />
hexadecimales A, B, C y D.<br />
Ejemplo: Código ASCII: A (41H), B (42H), C (43H), D (44H)<br />
Empaquetada Desempaquetada<br />
41 42 41<br />
43 44 42<br />
43<br />
44<br />
La ventaja de utilizar la forma empaquetada, es que se emplea mejor la memoria, sin<br />
embargo, en forma desempaquetada, la información se puede manejar más fácil y<br />
rápidamente.
7.2 Códigos Detectores y Correctores de Errores<br />
La capacidad para detectar posibles errores en la información manipulada por las<br />
computadoras es esencial para poder confiar en los resultados ofrecidos.<br />
El error es la alteración del valor correcto en uno o más bits de información producida<br />
durante su almacenamiento, transmisión o manipulación.<br />
Cuando se transmite información entre sistemas digitales, se puede producir pérdida de<br />
información debido a problemas de ruido, deformación de la señal (desadaptación de<br />
impedancias, ancho de banda, "crosstalk", etc.). Los errores en un sistema de comunicaciones<br />
digitales se producen fundamentalmente por dos tipos de fallas:<br />
• Eventos estáticos<br />
• Eventos dinámicos<br />
Los eventos estáticos (EE) son aquellos de comportamiento y existencia conocidos, como<br />
podría ser: distorsión de señal, pérdida por atenuación, “crosstalk”, etc.<br />
Los eventos dinámicos (ED) son aquellos que ocurren en forma aleatoria, como sería los<br />
disturbios eléctricos producido por descargas atmosféricas, transitorios en líneas eléctricas de<br />
alimentación, etc, y todo aquello que por su naturales no se pueda prever su ocurrencia.<br />
S1<br />
ED<br />
Para ello, es necesario detectar los errores producidos. Aquellos provenientes de EE son<br />
más fáciles de manejar, ya que sus efectos son predecibles, no sucede lo mismo con los ED,<br />
cuya naturaleza aleatoria los hace impredecibles. Hay muchos métodos y códigos<br />
sofisticados, siendo posible en algunos casos recuperar la información transmitida.<br />
Para poder detectar o incluso corregir posibles errores en la información, es preciso añadir<br />
información redundante de comprobación.<br />
La redundancia (R) es la información agregada a los datos (D) de acuerdo con alguna<br />
formulación matemática conocida. El proceso de detección de errores consiste en comprobar<br />
si el conjunto datos/redundancia (D,R) cumple o no dicho formulación, entonces:<br />
• Si la formulación se cumple, se asume que la información es correcta.<br />
• Si la formulación no se cumple, está claro que la información contiene errores.<br />
Si la información redundante agregada permite conocer cuáles son los bits erróneos, es<br />
posible realizar la corrección de los mismos y reconstruir la información original.<br />
Un concepto muy importante relativo a la corrección y detección de código de errores es<br />
el término “distancia”. La distancia entre dos números binarios es igual a la cantidad de bits<br />
que difieren entre sí, se decir, es la cantidad de bits diferentes entre un número y otro. Por<br />
ejemplo entre 000 y 001, la distancia es 1 y entre 000 y 011, es 2.<br />
EE<br />
S2
Sean X e Y dos palabras de un códigos de n bits, y sea el operador ⏐w⏐ el número de 1's<br />
del mensaje w. Luego la distancia entre X e Y se define como:<br />
D(X,Y) = ⏐X ⊕ Y⏐<br />
La distancia mínima se define como el número de bits que deben cambiar para pasar de<br />
una palabra de código válida a otra palabra de código válida. Por lo tanto un código que<br />
detecte un error simple, tendrá una distancia mínima de 2.<br />
La regla general para la corrección de errores es: sea un código de n bits y sea k la<br />
cantidad de errores a corregir. La combinaciones deberían elegirse de tal manera que una de<br />
otra difieran de al menos de una distancia 2k + 1. En general si la distancia mínima entre las<br />
combinaciones de un código es 2k, luego es posible detectar 2k-1 errores o detectar hasta k<br />
errores y simultáneamente corregir k - 1 errores. Si la distancia mínima es 4, puede detectar<br />
errores dobles y corregir errores simples.<br />
Regla General:<br />
Código n bits<br />
Cantidad de Errores a Corregir k bits<br />
Distancia Mínima 2k + 1bits<br />
En general:<br />
Dmin = 2 k<br />
Los códigos que vamos a estudiar son:<br />
Detecta 2k-1<br />
Detecta k<br />
Corrige k-1<br />
Mayoría<br />
Paridad<br />
Checksum<br />
Códigos de Redundancia Cíclica (CRC)<br />
Hamming<br />
Como se dijo anteriormente, si D es el campo de datos y R la redundancia a ser agregada,<br />
entonces el paquete de información I a ser enviado será una función de la forma: I = [D+R].<br />
Por lo tanto, el paquete de información I se formará por los dos campos:<br />
Dígitos de Información (D) Dígitos de Checheo (R)
7.2.1 Función Mayoría<br />
El mecanismo denominado “Función Mayoría”, consiste en repetir la información un<br />
determinado número n de veces, normalmente un número impar (n ≥ 3). Por lo tanto, el<br />
receptor dispondría de varias copias de la información que deberían ser exactamente iguales.<br />
Si hay errores en la información recibida, normalmente afectarán a una sola copia o a un<br />
número pequeño de ellas. En consecuencia, el receptor seleccionará como información<br />
correcta a la copia que se repite mayor cantidad de veces. De ahí surge la importancia de<br />
elegir un número de copias impar.<br />
Es posible considerar que la función mayoría se comporte como un mecanismo para<br />
detectar y/o corregir errores.<br />
7.2.2 Paridad<br />
Consiste en enviar un bit extra a cada caracter enviado, para mantener un número par o<br />
impar de unos (paridad par o impar, respectivamente).<br />
Para calcular la redundancia para paridad par, se debe implementar la función or-exclusiva<br />
entre los bits:<br />
P=dn−1♁dn−2♁...♁d1♁d0<br />
Para calcular la redundancia para paridad impar, se debe implementar la función orexclusiva<br />
negado entre los bits:<br />
I=dn−1♁dn−2♁...♁d1♁d0<br />
Ejemplo:<br />
0 1010110 Paridad par<br />
1 1010110 Paridad impar<br />
A este método también se lo llama Chequeo de Redundancia Longitudinal ("Longitudinal<br />
Redundancy Check" LRC).<br />
Una forma alternativa de chequear paridad, es enviando un carácter adicional, en donde se<br />
han calculado las paridades de los bits en columna de cada caracter:<br />
Ejemplo:<br />
10110011 Caracter 1<br />
10100011 Caracter 2<br />
10011110 Caracter 3<br />
10001110 Caracter de Chequeo (paridad par)<br />
Ejemplo de un código ASCII correspondiente a la secuencia CINCO:
En este caso se denomina Chequeo de Redundancia Vertical ("Vertical Redundancy<br />
Check" VRC).<br />
El agregado de un bit de paridad de redundancia, hace que la distancia mínima sea 2.<br />
7.2.3 Checksum<br />
El "Checksum" se calcula como la suma módulo 256 del total de caracteres a enviar (es<br />
decir que no se tiene en cuenta el carry producido). Este método consiste, por lo tanto, en<br />
enviar el resultado del cálculo como un carácter adicional.<br />
Ejemplo:<br />
11001001 Caracter 1<br />
10000110 Caracter 2<br />
00101101 Caracter 3<br />
01111100 Checksum<br />
Este código puede verse como una variedad de VRL.<br />
Los métodos descriptos tienen el inconveniente de detectar únicamente un error simple,<br />
ya que si se genera un error doble éstos no lo detectan.<br />
7.2.4 Chequeo de Redundancia Cíclica (CRC)<br />
Este método es mucho más efectivo que los anteriores en la detección de errores en los<br />
sistemas de comunicaciones. No permite la corrección de errores.<br />
En este método, en forma similar a los anteriormente descriptos, se envía uno o más<br />
caracteres adicionales de redundancia denominados FCS ("frame check sequence") o BCC<br />
("block check caracter"), que difieren fundamentalmente en la forma de calcularlo.<br />
El CRC consiste en considerar a los bits a ser transmitidos como un polinomio en x (para<br />
n bits el orden es n-1) tal que la presencia de un término significa un "1", y la ausencia, un<br />
"0"; es decir: sean 1010101 los bits a transmitir, entonces el mensaje podrá ser considerado<br />
como un polinomio G(x) tal que:<br />
G(x) = x 7 + x 5 + x 3 + 1<br />
Un mensaje de código cíclico consiste en un número de bits de datos y el BCC. Sea n el<br />
número total de bits y k el número de bits de datos, por lo tanto, el número de bits del BCC es<br />
n - k. El código del mensaje (BCC) se obtiene de 2 polinomios:<br />
Dados:<br />
polinomio generador P(x)<br />
mensaje polinomial G(x) (bits de datos).<br />
P(x): polinomio generador<br />
G(x): polinomio de mensaje de datos<br />
Se desea hallar F(x), código del mensaje polinomial, como sigue:
Multiplicar el mensaje G(x) por x, siendo n - k el número de bits del BCC para dar<br />
lugar al BCC (multiplicar por x, es lo mismo que desplazar el mensaje polinomial de<br />
datos n-k lugares completando con ceros a la derecha).<br />
G(x) * x n-k<br />
Dividir el producto resultante G(x) * x n-k por el polinomio generador P(x).<br />
G(x) * x n-k = Q(x) P(x) + C(x)<br />
Despreciar el cociente y sumarle a G(x) * x n-k el resto C(x) de la división para<br />
producir el código de mensaje polinomial F(x).<br />
F(x) = G(x) * x n-k + C(x) ; Mensaje Polinomial a Transmitir<br />
Para entender las operaciones anteriores, es necesario tener en cuenta que estamos<br />
utilizando aritmética módulo 2. Es decir que tanto la suma como la resta binaria son la<br />
función OR exclusivo bit a bit sin acarreo.<br />
Además es importante notar que la cantidad de bits del resto C(x) (n-k) será de un orden<br />
menor que el del polinomio generador P(x) (n-k+1). Por lo tanto, conociendo el número de<br />
bits de P(x), se puede determinar la cantidad de ceros que se debe agregar a G(x) para realizar<br />
la división polinomial.<br />
Para hallar el polinomio G(x) se considera que la mayor potencia de x corresponde al bit<br />
más significativo, es decir: sean 101000111 los bits a transmitir, entonces G(x) será:<br />
Ejemplo de cálculo de la redundancia:<br />
Sea la información original G(x) = 11001, patrón P(x)=101<br />
Primero se multiplica G(x) por 2 2 : G(x) · 2 k = 1100100<br />
El resultado anterior se divide entre P(x)=101<br />
Entonces la trama enviada será: 1100110<br />
G(x) 0........0
Ejemplo de implementación:<br />
Sea el mensaje de datos:<br />
101000111<br />
entonces:<br />
G(x) = x 8 + x 7 + x 6 + x 2 + 1<br />
El hardware necesario para realizar la división en aritmética módulo 2 será el siguiente:<br />
x 0 x 2 x 4 x 5<br />
donde el polinomio generador es:<br />
P(x) = x 5 + x 4 + x 2 + 1<br />
Un polinomio generador muy conocido es el CRC-16 cuyo P(x) es:<br />
P(x) = x 16 + x 15 + x 12 + 1<br />
Con respecto al receptor, éste se implementa realizando la división de la información<br />
recibida por el mismo polinomio generador que el transmisor. Si el resto de la división es 0,<br />
entonces la información se recibió sin error, en caso contrario se asumirá que hubo un error<br />
en la transmisión.<br />
El efecto general que se observa en el chequeo por medio del CRC, es que cualquier bit<br />
se refleja en varios bits por un tiempo considerable después que éste fue transmitido. Esto es<br />
muy importante, ya que se ha comprobado que la mayoría de los problemas de errores en<br />
comunicación de datos se producen en pequeños grupos de bits ("burst").<br />
Características más significativas del CRC:<br />
Detecta todos los errores de 1 y 2 bits (errores simples y dobles).<br />
Detecta todos los errores de un “Burst” menor que el grado de P(x)<br />
Detecta el 99 % de los errores de un “Burst” mayor que el grado de P(x)<br />
7.2.5 Código corrector de errores por paridad vertical y horizontal<br />
Este código corrector de errores, emplea un método combinado de chequeo de errores,<br />
paridad horizontal y vertical. Si un error simple ocurre en una palabra de código, luego<br />
ambos chequeadores indican, en conjunto, la fila y la columna donde se halla el bit con error.<br />
Por lo tanto, este código, es capaz de detectar y corregir un error simple.
LCR<br />
1000 0<br />
1001 1<br />
0110 1<br />
0100 0<br />
0010 0<br />
0111 0<br />
VCR 1001 1<br />
7.2.6 Códigos Hamming<br />
El código Hamming es un código de distancia 3, capaz de detectar errores dobles y<br />
corregir si hay un error simple. El código Hamming se forma por n bits de información (Mn,<br />
Mn-1, ... M1) y k bits de chequeo (Ck, Ck-1, ..... C1) de paridad par o impar. El mensaje<br />
codificado está formado por n + k bits, siendo k el menor entero que cumple que:<br />
2 k ≥ n+k+1 [7]<br />
(por ejemplo, si n = 7, entonces k = 4).<br />
Hamming es un código capaz de corregir un error simple por lo tanto debe identificar un<br />
bit erróneo en una cadena de bits. Entonces la ecuación [7] nos dice que el número de<br />
combinaciones de los bits de chequeo (2 k ) debe ser al menos igual al número de bits del<br />
mensaje más los bits de redundancia más una combinación extra para identificar que no hubo<br />
errores.<br />
Los bits de chequeo ocupan posiciones específicas en el mensaje codificado. Esas<br />
posiciones son potencias enteras de 2, es decir 1,2,4,8, .... 2 k-1 , es decir que los bits de paridad<br />
se ubican en los posiciones que tienen un único bit a 1 en su ordinal.<br />
Los valores de cada Ci se calculan chequeando la paridad en lugares específicos del<br />
mensaje original M. Por ejemplo para un código de 6 bits de mensaje, el mensaje codificado<br />
será:<br />
M6 M5 C4 M4 M3 M2 C3 M1 C2 C1<br />
1010 1001 1000 0111 0110 0101 0100 0011 0010 0001<br />
C1 = M1 ⊕ M3 ⊕ M5 ⊕ M7 ⊕ M9 .......<br />
C2 = M2 ⊕ M3 ⊕ M6 ⊕ M7 ⊕ M10 .......<br />
C3 = M4 ⊕ M5 ⊕ M6 ⊕ M7 ............<br />
C4 = M8 ⊕ M9 ⊕ M10 . .............<br />
Para el cálculo de los coeficientes Ci´s, los valores de Mi´s empleados, se refieren a la<br />
posición que ocupan los elementos en el mensaje codificado, tomando a M1 igual a cero (ya<br />
que corresponde al valor de Ci del mensaje codificado) para el cálculo inicial. Luego se<br />
reemplazan los valores de los Ci calculados en las posiciones del mensaje codificado.<br />
En el receptor: se chequea la misma paridad aplicada al mensaje codificado. Es decir que<br />
se vuelven a calcular los coeficientes de la misma manera como fueron generados. Luego se<br />
calcula el número posicional P como:
P = pkpk-1....p2p1<br />
Si P = 0, el resultado es correcto.<br />
Si P ≠ 0, el número indica la posición (el bit) con error.<br />
Ejemplo error simple:<br />
Supongamos que se recibe un carácter ASCII “f” (1100110B) con un error simple en la<br />
posición M4:<br />
C1 = 0 ⊕ 0 ⊕ 1 ⊕ “1” ⊕ 0 ⊕ 1 = 1<br />
C2 = 1 ⊕ 0 ⊕ 1 ⊕ “1” ⊕ 1 ⊕ 1 = 1<br />
C3 = 0 ⊕ 1 ⊕ 1 ⊕ “1” = 1<br />
C4 = 0 ⊕ 1 ⊕ 1 ⊕ 0 = 0<br />
M7 M6 M5 C4 M4 M3 M2 C3 M1 C2 C1<br />
1 1 0 0 “1” 1 1 0 0 1 0<br />
Entonces la posición a corregir será: P = p4p3p2p1 = 0111 (o sea la 7).<br />
Ejemplo error doble:<br />
Supongamos que se recibe un carácter ASCII “f” (1100110B) con un error doble en las<br />
posiciones M2 y M4:<br />
C1 = 0 ⊕ 0 ⊕ “0” ⊕ “1” ⊕ 0 ⊕ 1 = 0<br />
C2 = 1 ⊕ 0 ⊕ 1 ⊕ “1” ⊕ 1 ⊕ 1 = 1<br />
C3 = 0 ⊕ “0” ⊕ 1 ⊕ “1” = 0<br />
C4 = 0 ⊕ 1 ⊕ 1 ⊕ 0 = 0<br />
M7 M6 M5 C4 M4 M3 M2 C3 M1 C2 C1<br />
1 1 0 0 “1” 1 “0” 0 0 1 0<br />
Si se asume que hay un único bit erróneo, se trata del que tiene el ordinal 2, es decir, C2<br />
que era un bit correcto. Por lo tanto se realiza una corrección errónea, ya que hay un error<br />
doble.<br />
Para distinguir el caso de error simple del de error doble, se puede añadir un bit de paridad<br />
transversal T, o LRC, a la cadena de bits enviados (que no se usa para calcular las paridades<br />
de Hamming), tal que:<br />
• Si no hay errores, P = 0 y T: correcto.<br />
• Si hay un error simple, P ≠ 0 y T: incorrecto. Es posible corregir el bit erróneo.<br />
• Si hay un error doble, P ≠ 0 y T: correcto. No es posible corregir el error.