Clase 10

CLASE NUM 10
Códigos de protección.
¿Protección contra qué?
Contra errores.
¿En qué consisten los errores?
En que el receptor dice que la señal recibida es un uno lógico,
cuando en realidad es un cero lógico y viceversa.
¿A qué se deben los errores?
A las pérdidas, a la distorsión, a la interferencia y sobre todo, al
ruido que se agrega a la señal en el canal de comunicación. Todo
lo
anterior presupone que la señal binaria sale del transmisor
absolutamente sin errores; el que se equivoca es el receptor.
¿Cuántos tipos de códigos de protección hay?
Entre las muchas clasificaciones existentes, la fundamental es
esta: Códigos para detectar y códigos para corregir. (ARQ y FEC)
¿Qué cosa es "detectar"?
Para el propósito de este tema, detectar es determinar si hay o no
errores en el mensaje recibido, sin saber con precisión cuáles son los
bits erróneos.
¿Qué cosa es "corregir"?
Para el propósito de este tema, corregir es determinar con
certeza cuáles son los bits erróneos. Una vez que se sabe cuál bit es
erróneo, la corrección es trivial, pues basta con sustituir el bit con su
negado.
¿En qué consiste la protección?
Consiste en agregar cierta cantidad de bits al mensaje que se
desea transmitir. Hay algoritmos para determinar cuales y cuantos bits
se agregan y lo que se debe hacer en el receptor con tales bits.
Intuitivamente es comprensible que es más fácil decir si hay bits
erróneos que decir cuales son; o sea que, es más sencillo y más barato un
código para detectar que uno para corregir.
Procedimiento de detección por paridad par.
Considérese un mensaje binario en el que cada carácter
alfanumérico se codifica con 7 bits; por ejemplo, la palabra "botella". A
continuación se presenta su equivalente binario y después de cada 7 bits
el transmisor ha agregado un octavo bit de protección.
B
0
T
E
L
L
A
1
0
1
0
0
0
0
1
0
1
1
0
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
0
0
1
0
0
1
1
0
1
1
1
0
1
1
0
1
1
1
1
0
0
1
0
1
0
1
0
0
1
Se puede notar inmediatamente que el octavo bit es para que en
cada letra haya un número par de unos y de ceros; de modo que cuando
el receptor revise y encuentre que no se cumple esta regla, dará una
indicación de que ese byte tiene un error, pero no podrá decir cual es el
bit erróneo. Decimos entonces, que se ha detectado un error.
Hay diversas formas de corregir estos errores. Un ser humano
entrenado; esto es, que sabe gramática o que tiene idea de la
información que está recibiendo, puede corregir los errores; por
ejemplo, el siguiente texto es fácil de corregir:
El brexidente de la bepública sxlicibó permiso al bongreso para
viajar ad ebtranjero la regunda memana de amosto.
Cuando se transmiten mensajes con números, estos se pueden
escribir con letras; por ejemplo:
Envío chique búbero 2ab345z (dos, opho, cinco, tras, cuatro, cinpo,
mueve) por la cabtixad da $=39ª.00 (pecos, circo, tres, nueve, ochi,
punto, cebo, cero).
También se puede programar una máquina para que entienda y
corrija los mensajes; pero la forma más económica y segura es detectar
los errores y pedir una repetición del paquete.
Este procedimiento de detección fracasa si en un byte se
producen dos, o cuatro o seis bits erróneos, ya que entonces la paridad
se cumple y la máquina receptora no los detecta; pero si se produce un
número impar de errores, el receptor lo detecta.
En el ejemplo anterior, cada símbolo se codificó con 7 bits, pero se
puede usar un código de 5 bits o cualquier otra cantidad de bits por
símbolo; inclusive se puede hacer una variante con número par de bits
por símbolo.
Procedimiento de corrección por verificación cruzada.
En este caso, hay que dividir el mensaje en paquetes de un número
impar de caracteres, incluyendo los espacios entre palabras y darle
protección independiente a cada paquete; por ejemplo, el siguiente
mensaje ha sido fraccionado en bloques de 5 caracteres:
Aunqu
no es lo m
e tod
os so
mos d
ismo
bacín
que jarro
el mi
smo b
arro,
El siguiente paso consiste en que el transmisor agregue los bits de
paridad; lo haremos con el primer bloque de 5 caracteres; con los demás
bloques se procede en la misma forma.
A
U
N
Q
U
1
0
1
0
0
0
1
1
0
1
1
0
0
0
1
0
0
1
1
0
0
0
0
1
0
0
0
0
1
1
1
0
1
1
0
1
0
0
0
0
1
1
0
1
1
0
1
1
Como se puede ver, hay un renglón de paridad y una columna de
paridad. Supongamos ahora, que al receptor le llega el siguiente bloque:
1
0
1
0
0
0
1
1
0
1
1
0
0
0
1
0
0
1
1
0
0
0
0
1
0
0
0
0
1
1
1
0
1
1
1
1
0
0
0
0
1
1
0
1
1
0
1
1
Al hacer la verificación horizontalmente, vemos que el quinto
renglón no tiene paridad; del mismo modo, al verificar verticalmente
vemos que la sexta columna tampoco tiene paridad. Por todo lo anterior,
deducimos que hay un bit erróneo en el cruce del quinto renglón y la
sexta columna. En conclusión, si en el bloque de 48 bits se presenta un
solo bit erróneo, este se puede localizar; es decir, se puede corregir. Un
número impar de errores en un mismo renglón se puede corregir. Dos o
más errores en distintos renglones
generalmente se pueden detectar.
no
son
corregibles
pero
Si en el canal de comunicación hay poco ruido, probablemente
habrá pocos bits erróneos y si hay mucho ruido, probablemente habrá
muchos bits erróneos. Extrapolando el procedimiento indicado se puede
obtener la cantidad de protección requerida para la cantidad (o
probabilidad) esperada de errores. Esto se hace variando la cantidad de
caracteres en cada bloque; por ejemplo, si esperamos pocos errores, se
puede trabajar con bloques de 25 caracteres y si esperamos muchos
errores, se puede seccionar el mensaje en bloques de 5 o 3 caracteres y
en el caso límite, cada bloque puede contener un solo carácter. A
continuación se presenta la primera palabra del ejemplo anterior
dividida en bloques de 3 caracteres ya con su protección incluida:
A 1 1 0
U 0 1 0
N 1 0 1
0 0 1
Q 0 1 0
U 0 1 0
E 0 0 0
0 0 0
1
0
0
1
0
0
1
1
0
0
0
0
0
1
1
0
1
0
1
0
1
0
1
0
0
0
0
0
0
1
0
1
0
1
1
0
0
1
1
0
Ahora, la misma palabra dividida en bloques de 1 carácter:
A 1
1
U 0
0
N 1
1
Q 0
0
U 0
0
E 0
0
1
1
1
1
0
0
1
1
1
1
0
0
0
0
0
0
1
1
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
1
1
1
1
1
1
0
0
1
1
1
1
0
0
1
1
0
0
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
1
0
0
1
1
1
1
En este último caso, es notorio que el método consiste en repetir
el mensaje, procedimiento que usamos los seres humanos en la
conversación cuando queremos asegurarnos que se nos comprenda
perfectamente.
Analicemos ahora la capacidad de la protección:
En bloques de 5 letras, con 13 bits de protección se puede
corregir un error por cada 48 bits transmitidos.
En bloques de 3 letras, con 11 bits de protección, se puede
corregir un error por cada 32 bits transmitidos.
En bloques de 1 letra, con 9 bits de protección se puede corregir
un error por cada 16 bits transmitidos.
Como se puede ver, entre más pequeños son los bloques, es mas
fuerte la protección, pero se requieren relativamente mas bits
adicionales, lo que aumenta el costo monetario del proceso.
Procedimiento del síndrome para corrección de errores.
La palabra "síndrome" está tomada de la terminología médica y
significa: el conjunto de síntomas que caracterizan una enfermedad.
Se usa aquí esta palabra porque este método consiste en obtener
un conjunto de bits que nos van a decir cual es el bit erróneo en el
mensaje.
Veamos un ejemplo; sea un código en el que cada símbolo está
codificado con 5 bits, a los que hay que agregar un cierto número de
bits de protección, de forma que el símbolo X estará codificado de la
siguiente manera:
Xp = M1 M2 M3 M4 M5 P1 P2 P3 P4 P5--------En donde M son los bits de mensaje, que ya sabemos que son 5 y P
son los bits de protección, que no sabemos cuantos son.
Para determinar cuantos y cuales son los bits de protección, es
necesario construir una matriz binaria, llamada matriz de protección
MP, con las siguientes condiciones:
1.- Debe tener tantos renglones como bits de protección.
2.- Debe tener tantas columnas como bits de protección mas bits de
mensaje.
3.- No debe tener columnas repetidas.
4.- No debe tener columnas de puros ceros.
5.- En las columnas de la derecha debe haber puros ceros con una
diagonal de unos.
Esta matriz es independiente de la combinación de unos y ceros
del mensaje y se obtiene por tanteos. Se empieza por suponer que solo
hay un bit de protección y se intenta formar la matriz; si no se puede se
suponen dos bits de protección y se hace un nuevo intento; luego con 3
bits de protección y así sucesivamente hasta que se pueda formar la
matriz que cumpla las 5 reglas.
Para un mensaje de 4 bits y suponiendo un bit de protección, la
matriz tendría 1 renglón y 5 columnas, lo cual no permite cumplir las
otras tres condiciones. Si ponemos dos bits de protección, la matriz
tendría 2 renglones y 6 columnas y tampoco se puede. Con tres bits de
protección, la matriz debe tener 3 renglones y 7 columnas y ya se
pueden cumplir las 5 condiciones. Una de las 24 posibles matrices se
presenta a continuación:
1 0 1 1 1 0 0
MP= 1 1 0 1 0 1 0
1 1 1 0 0 0 1
Nótese que la 5ª regla especifica totalmente las tres últimas
columnas, pero la posición de las primeras 4 no está obligada y se
pueden intercambiar. Con esta matriz se calculan los bits de protección,
que ya sabemos que son 3; Se hará el cálculo para el mensaje A=1 0 1 0.
El mensaje protegido es: Ap=1 0 1 0 P1 P2 P3. Se hace ahora APMP
multiplicando columna por renglón:
1
0
1 1 0 1 1 1 0 0 1 0 1 0
0 1 1 0 1 0 1 0  1 0 0 0
p1 1 1 1 0 0 0 1 1 0 1 0
p2
p3
Enseguida, igualamos el producto a cero:
p1
0
0
0
p2
0
0
0
p3
1 0 1 0
1 0 0 0
1 0 1 0
p1
0
0
0
p2
0
0
0
0 0
p3 0
Para que se cumpla la igualdad, se requiere que en cada renglón
haya un número par de unos; por lo tanto:
P1 = 0
P2 = 1
P3 = 0
Entonces, el mensaje protegido es: Ap=1 0 1 0 0 1 0.
Supongamos que debido a las causas mencionadas, el receptor
comete un error y entonces: Ar= 1 0 1 1 0 1 0. Para encontrar el posible
error, el receptor debe tener en su memoria la misma matriz de
protección. Entonces, se hace el producto ArMP:
1
0
1 1 0 1 1 1 0 0 1 0 1 1 0 0 0
Ar MP  1  1 1 0 1 0 1 0  1 0 0 1 0 1 0
0 1 1 1 0 0 0 1 1 0 1 0 0 0 0
1
0
El siguiente paso consiste en sumar en módulo 2 los bits de cada
renglón del producto; esto es lo mismo que aplicar los bits de cada
renglón a una compuerta ex-or:
1 0 1 1 0 0 0 1
1 0 0 1 0 1 01
1 0 1 0 0 0 0 0
El resultado de la suma, que es una columna de tres bits se llama
síndrome; lo comparamos con las columnas de la matriz de protección y
vemos que es igual a la cuarta columna; por lo tanto, el error está en el
cuarto bit del mensaje recibido. Se ha concluido el proceso de
corrección.
Si el síndrome consta de tres ceros, significa que no hay error.
El procedimiento falla si el mensaje recibido tiene mas de un error
en cada carácter alfanumérico.
Cuando el mensaje se codifica con mas de cuatro bits por símbolo,
es necesario usar una matriz más grande, que de cualquier forma, se
establece por tanteos, hasta que se cumplan las cinco reglas antes
enunciadas. Como un ejemplo, para mensajes de 8 bits se requieren
cuatro de protección, de modo que la matriz será de 4 renglones y 12
columnas, como se ve a continuación:
0
1
MP 
1
1
1
1
1
1
0
1
0
1
1
0
1
0
1
1
0
0
0
0
1
1
1
1
1
0
0
1
1
1
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
Esta no es la única matriz para mensajes de 8 bits; existen
6'652,800 matrices diferentes.
Procedimiento de detección con chequeo de redundancia cíclica.
Este método se conoce en el idioma inglés como "cyclic redundance
check" y usualmente solo se dice: "código C R C". La razón de este
nombre está en la estructura del circuito lógico requerido para llevar a
cabo el procedimiento.
Para aplicar este sistema de detección de errores, se requiere
disponer de unos ciertos polinomios (que alguien obtuvo vendiéndole su
alma al diablo) conocidos como CRC(m,n), en donde m es el número de
bits del mensaje mas los bits de protección y n es el número de bits de
mensaje.
Ejemplo: C R C (13,8) = X5 + X4 + X1 + X0 es un polinomio que agrega
5 bits de protección a un mensaje de 8 bits, para dar un total de 13
bits. Veamos como trabaja esto: Sea el mensaje que se quiere enviar A =
1 0 1 1 0 1 1 1; como va a llevar 5 bits de protección, inicialmente le
agregamos 5 ceros, quedando:
A' = 1 0 1 1 0 1 1 1 0 0 0 0 0. Estos ceros adicionales serán sustituidos
por los bits de protección. Enseguida escribimos:
C R C (13,8) = X5 + X4 + X1 + X0 = 1 1 0 0 1 1. Ahora vamos a dividir A'/C
R C(13,8) en módulo 2; esto se anota a continuación:
Los 5 bits al extremo derecho del residuo son los bits de
protección; de modo que el mensaje protegido queda:
Ap = 1 0 1 1 0 1 1 1 0 1 0 0 1
Este es el paquete que se transmite. Para explicar como es el
proceso de detección de error en el extremo receptor, introduzcamos
un bit erróneo, con lo que el mensaje recibido es:
Ar = 1 0 1 1 1 1 1 1 0 1 0 0 1
El proceso consiste en hacer la división Ar/CRC(13,8) y examinar el
residuo:
Cuando el residuo es igual a cero, el mensaje ha sido identificado
sin error por el receptor. Un residuo diferente de cero implica que el
receptor ha cometido errores de identificación. El valor numérico del
residuo no indica donde está el bit erróneo.
Existen códigos CRC para mensajes de diferentes longitudes; por
ejemplo:
C R C (24,8)=X16+X12+X5+X0=1 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 utiliza 16
bits para proteger un mensaje de 8 bits.
Se ha dicho que los códigos de paridad par, de verificación
cruzada y del síndrome tienen la limitación de que solo aceptan un error
en cada paquete de bits. Los códigos C R C no tienen esta desventaja, ya
que pueden detectar varios errores en un mismo paquete; debido a esto,
gozan de gran estima.
Los procedimientos aquí explicados, indudablemente no son los
únicos que existen. Se han desarrollado muchísimas técnicas de
detección y corrección de errores, cada una para remediar situaciones
particulares. Para seleccionar un código de protección, es necesario
tomar en cuenta:
a) Si se desea detectar o corregir los errores.
b) Si se presentan errores aislados uno de otro o varios errores juntos;
esto último se conoce como "errores en ráfaga".
c) La frecuencia de los errores; o sea, la probabilidad de que ocurran los
errores.
El inciso a) se decide por consideraciones económicas. El inciso b)
se determina por inspección de los mensajes recibidos. El inciso c) se
analizará en el tema de la clase número 11
TAREA NÚMERO 10.
Problema 1.-Codificar la frase "mexicanos al grito de guerra" en
binario usando el código Baudot y agregarle los bits necesarios para
detectar un error en cada símbolo alfanumérico con el procedimiento de
paridad par. (El código Baudot está en el resumen de la clase número 1.
El espacio entre palabras se codifica con 0 0 1 0 0 ).
Problema 2.-Se quiere enviar la palabra REPENTINAMENTE
codificada en A S C I I. Mostrar como queda el código y su protección,
si se pretende corregir un error cada 64 bits. (Buscar el código A S C I
I en el resumen de la clase número 1).
Problema 3.-Desarrollar una matriz para proteger caracteres que
se codifican con 10 bits y calcular los bits de protección para el
mensaje: A = 1 1 1 1 0 0 0 0 1 0.
Problema 4.-Se tiene el polinomio CRC(15,10)=X5+X4+X2+X0.
Proponer un mensaje con el número adecuado de bits y para este,
calcular los bits de protección. Comprobar que si no hay error, el
proceso de detección da un residuo nulo.
Problema 5.- Se tiene un alfabeto codificado con 9 bits por
símbolo y se le quiere dar protección por el método de verificación
cruzada. Determinar cuantos símbolos tiene cada bloque si se espera un
máximo de 0.625% de probabilidad de error. Sugerencia: El método de
verificación cruzada corrige un error cada x bits; así mismo:
Probabilidad de error=0.625%=0.00625=1 error/xbits.