CÓDIGO DE REDUNDANCIA CÍCLICA - CRC

Tambien conocido como código polinómico detector de errores. El método de

redundancia cíclica (CRC Cyclic Redundancy Check) es otra técnica muy usada para
detección de errores. Trabaja al nivel de mensaje, agregando varios caracteres de
control al final.

Los códigos polinómicos se basan en el tratamiento de series de bits como si fueran

representaciones de polinomios, con coeficientes de valor 0 y 1 únicamente. Una trama
de k bits se ve como una lista de coeficientes de un polinomio con k términos,
cubriendo un rango desde xk-1 hasta x0. A este tipo de polinomio se le conoce como
polinomio de grado k-1. El bit de orden más alto (el más a la izquierda) es el
coeficiente del término xk-1; el siguiente bit es el coeficiente del término xk-2, y así
sucesivamente.

Código: 110001 Polinomio: x5 +x4 + x0.

Cuando se emplea el método del código polinómico, el emisor y el receptor deberán

estar de acuerdo respecto a un polinomio generador, G(x), en forma anticipada. Los
bits de orden superior e inferior del generador deben ser 1. Para calcular el código de
redundancia de alguna trama con m bits, correspondiente al polinomio M(x), la trama
deberá ser más grande que el polinomio generador. La idea básica consiste en incluir
un código de redundancia al final de la trama, de tal manera que, el polinomio
representado por la trama con el código de redundancia sea divisible por G(x). Cuando
el receptor recibe la trama de suma comprobada, intenta dividirla entre G(x). Si existe
un resto, habrá ocurrido un error de transmisión.

Los utilizados como polinomio generador deben cumplir con tres condiciones
importantes:
1. El polinomio debe tener un 1 en su bit de mayor y de menor peso
2. No debe ser divisible por x, es decir 10
3. Debe ser divisible por x+1, es decir 11

Existen unos polinomios estándar que cumplen con las características y que han sido
utilizados en los estándares internacionales para la transmisión de datos:

CRC – 4 = x4 + x + 1

CRC – 8 = x8 + x2 + x + 1
x8 + x5 + x4 + 1

CRC – 12 = x12 + x11 + x3 + x2 + x + 1

CRC – 16 = x16 + x15 + x2 + 1

x16 + x12 + x5 + 1

CRC – 32 = x32 +x26 +x23 +x22 +x16 +x12 +x11 +x10 +x8 +x7 +x5 +x4 +x2 +x+ 1
Para determinar el código de redundancia cíclica se deben seguir los siguientes pasos:

1. Sea r el grado de G(x). Agregar r bits a cero al extremo de orden inferior de la

trama, de tal manera que ahora contenga m + r bits, y corresponda al
polinomio xrM(x).
2. Divida la secuencia de bits a enviar o el polinomio de información x’M(x), en un
polinomio específico llamado polinomio generador G(x), usando la división en
módulo 2.
3. El resto de la división se llama CRC y se agrega al final del mensaje como
secuencia de control, esa es la trama lista para trasmitir. Llámese T(x) a este
polinomio
4. El receptor realiza la misma división con el mismo polinomio generador, y
compara el resultado obtenido con la secuencia de control recibida. Si obtiene
un residuo de la división, significa que hay un error, si el resto es igual a cero

GENERACIÓN DE CRC
1 0 1 1 0 1 0 1 1 0 0 0 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0
1 0 1 1 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0
1 0 1 1 1
1 0 0 1 1
0 1 0 0 0
0 0 0 0 0
1 0 0 0 0
1 0 0 1 1
0 0 1 1 0
0 0 0 0 0
0 1 1 0 0
0 0 0 0 0
1 1 0 0 CRC
 CHEQUEO DE CRC
1 0 1 1 0 1 0 1 1 1 1 0 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0
1 0 1 1 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0
1 0 1 1 1
1 0 0 1 1
0 1 0 0 1
0 0 0 0 0
1 0 0 1 1
1 0 0 1 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 SIN ERROR