En este compilado de información se muestra cómo funciona el detector de errores CRC.

1. TECNOLÓGICO NACIONAL DE MÉXICO
INSTITUTO TECNOLÓGICO DE AGUASCALIENTES
DEPARTAMENTO DE INGENIERÍA ELÉCTRICA - ELECTRÓNICA
Ingeniería Electrónica
Comunicaciones digitales
Unidad I
TAREA 1
CRC como método de detección de errores
Alumno: Héctor Alexis Reyes Martínez
8vo Semestre Ingeniería electrónica
Profesora: Ing. Yessica Rodríguez Estrada
Aguascalientes, Ags, a 05 de febrero de 2018

2. 2
ÍNDICE
1 INTRODUCCIÓN.........................................................................................................................................3
2 MÉTODO DE DETECCIÓN DE ERRORES CRC................................................................................................4
2.1 FUNDAMENTO MATEMÁTICO........................................................................................................................... 5
2.2.1 Ejemplo 1: división en el emisor ....................................................................................................... 6
2.2.2 Ejemplo 2: división en el receptor (dos casos).................................................................................. 7
3 IMPLEMENTACIÓN DIGITAL ......................................................................................................................8
4 APLICACIONES...........................................................................................................................................9
5 ARQ: ESTRATEGIAS DE RETRANSMISIÓN................................................................................................. 10
5.1 STOP-AND-WAIT ARQ................................................................................................................................. 10
6 OBSERVACIONES..................................................................................................................................... 12
7 CONCLUSIONES....................................................................................................................................... 13
8 FUENTES DE INFORMACIÓN.................................................................................................................... 14

3. 3
1 Introducción
El presente trabajo explica de manera detallada el funcionamiento de la verificación
por redundancia cíclica (CRC – Cyclic Redundancy Check), el cual consiste en un
método de detección de errores usado frecuentemente en redes digitales y en
dispositivos de almacenamiento para detectar cambios accidentales en los datos.
En redes y comunicaciones digitales, el CRC es utilizado para el control del flujo de
datos. Los desarrolladores e investigadores de tecnología de la información
procuran crear y desarrollar métodos de detección de transmisión de errores,
asumiendo que inicialmente el control de recepción de datos (DLC) sabe dónde
empieza la estructura de datos y dónde termina. El problema es cómo determinar
cuál de todas las estructuras de datos contiene el error. Desde el punto de vista del
empaquetamiento de bytes, los paquetes que entran al DLC son cadenas de bits
arbitrarias. Así, en el receptor del DLC, cualquier cadena de bits es aceptable como
un paquete y los errores no pueden ser detectados por el análisis del paquete en sí
mismo. Cabe señalar que una transformación en los paquetes de K bits en alguna
otra representación de longitud K no puede ayudar, ya que hay 2K paquetes posibles
y todas las posibles cadenas de bits de longitud K deben ser usadas para
representar todos los posibles paquetes. La conclusión obtenida por los
investigadores fue que se debía agregar algunos bits extra a los paquetes para
detectar los errores.
Un bit transmitido puede convertirse en un error debido al ruido que existe en el
canal de transmisión. Si estamos procesando una señal de voz o de video, la
ocurrencia de errores en un bajo porcentaje es tolerable, pero en muchos otros
casos es muy importante que todos los bits sean correctos. Por ejemplo, cuando se
descarga alguna aplicación de internet, el código binario del programa no podrá
ejecutarse si alguno de los bits es incorrecto. Si el destinatario o la dirección de
emisión de un paquete tiene un bit incorrecto, la comunicación es imposible.

4. 4
2 Método de detección de errores CRC
El CRC fue inventado por W. Wesley Peterson, y publicado en un artículo en 1961.
Deriva de un código cíclico, pero generalmente se comporta de forma no cíclica,
basado en un tipo de código de bloques lineales. Los bloques de datos ingresados
en estos sistemas contienen un valor de verificación adjunto, basado en el residuo
de una división de polinomios, el cálculo es repetido y la acción de corrección puede
tomarse en contra de los datos presuntamente corruptos en caso de que el valor de
verificación no concuerde.
El CRC no puede detectar todos los posibles errores, pero el rango de errores que
puede detectar es impresionantemente grande. Autores de libros de redes como
Larry Peterson y Bruce Davie han señalado que es bastante notable como un CRC
de 32 bits es suficiente para proporcionar una protección adecuada contra los
errores en los mensajes de 12000 bits que el Ethernet puede enviar.
Figura 1. Diagrama de bloques del CRC.

5. 5
2.1 Fundamento matemático
El CRC comúnmente utiliza vectores de cierta longitud para detectar los errores.
Para obtener una notación matemática conveniente, las posiciones en el bloque de
datos pueden ser expresadas como un polinomio de x. Establecemos “L” como la
longitud del CRC y “k” como la longitud de la cadena de bits de datos.
Representando la cadena de datos de forma polinomial:
𝑠(𝑥) = 𝑠 𝑘−1 𝑥 𝑘−1
+ 𝑠 𝑘−2 𝑥 𝑘−2
+ ⋯ + 𝑠0 = ∑ 𝑠𝑖 𝑥 𝑖
𝑘−1
𝑖 = 0
La potencia de la x indeterminada puede ser pensada como un seguimiento sobre
cual posición tiene cada bit; los términos de alto orden (MSB) son vistos como los
primeros en trasmitir. El CRC es representado como otro polinomial:
𝑐(𝑥) = 𝐶𝐿−1 𝑥 𝐿−1
+ ⋯ + 𝐶1 𝑥 + 𝐶0 = ∑ 𝐶𝑖 𝑥 𝑖
𝐿−1
𝑖=0
El paquete de datos entero de la información transmitida y el CRC pueden ser
representado como una suma de polinomios: 𝑋(𝑥) = 𝑠(𝑥)𝑥 𝐿
+ 𝑐(𝑥) , que sería:
𝑋(𝑥) = 𝑠 𝑘−1 𝑥 𝐿+𝐾−1
+ ⋯ + 𝑠0 𝑥 𝐿
+ 𝑐 𝐿−1 𝑥 𝐿−1
+ ⋯ + 𝑐0
El vector polinomial de CRC “c(x)” es una función de la información polinomial s(x),
definida en términos del generador polinomial g(x); este es un polinomio de grado L
con coeficiente binarios que especifican el código particular CRC a ser utilizado:
𝑔(𝑥) = 𝑥 𝐿
+ 𝑔 𝐿−1 𝑥 𝐿−1
+ ⋯ + 𝑔1 𝑥 + 1
Para un g(x) dado, el mapeo desde el polinomio de información hacia el polinomio
del CRC c(x) está dado por:
𝑐(𝑥) = 𝑟𝑒𝑠𝑖𝑑𝑢𝑜 (
𝑠(𝑥)𝑥 𝐿
𝑔(𝑥)
)

6. 6
La división polinomial de arriba es sólo una ordinaria división larga de un polinomio
entre otro, excepto que los coeficientes están restringidos a ser binarios y la
aritmética en los coeficientes se realiza con módulo 2 (%2).
2.2.1 Ejemplo 1: división en el emisor
Figura 2. Ejemplo 2 de la división polinomial.
En este ejemplo, se envía un dato = 1001 y un CRC de 3 bits
• k = número de bits del dato = 4.
• L = #bits CRC deseados=3. Por lo tanto, el polinomio de generación g(x) es
de grado 3. Se escoge g(x) = 𝑥3
+ 𝑥 + 1.
• El grado del dato aumentado es de L+K-1 = 6. Por lo tanto, el dato cambia
su polinomio a 𝑋(𝑥) = 𝑥6
+ 𝑥3
.
• Al resolver la división de polinomios, queda un residuo de x2+x , que es el
equivalente a CRC = 110.
• El dato que es enviado por el emisor es: Dato = 1001110. Este dato ya incluye
el CRC de 3 bits para la detección de errores.

7. 7
2.2.2 Ejemplo 2: división en el receptor (dos casos)
Figura 3. Dato en receptor.
Se puede observar que el receptor recibe el dato con los bits CRC incluidos.
• Primero el receptor divide el polinomio de la información recibida (incluyendo
el CRC) entre el polinomio de generación g(x) (ambos dispositivos deben
conocer el mismo polinomio de generación).
• Si el residuo de dicha división binaria es cero, el dato es aceptado, quitando
los bits de CRC.
• Si el residuo es diferente a cero, se descarta el dato.

8. 8
3 Implementación digital
Como se puede observar, los algoritmos CRC pueden ser fácilmente codificados en
software, pero pueden ser algo lentos. Podrían ser mucho más rápidos si son
implementados en hardware lógico digital (como procesadores dsp), y sería más
simple la codificación -decodificación de información.
Si denotamos el número de bits del divisor polinomial C(x) como C, así el grado del
polinomio es C-1. Entonces configuramos de izquierda a derecha el registro de
desplazamiento el cual almacena C-1 bits. A la vez, los coeficientes denotan de
izquierda a derecha: 𝑆0, 𝑆1, … , 𝑆𝑐−2 … . Así, cada registro queda reemplazado por Si
en cada pulso de reloj.
La figura 2 muestra como configurar en el caso de 𝐶(𝑥) = 𝑥3
+ 𝑥 + 1 C=1011.
Figura 4. Diseño digital del filtro-bit CRC.

9. 9
4 Aplicaciones
La idea de la codificación CRC puede ser vista como una generalización de la
detección del bit de paridad. Los bits de paridad funcionan bien en vectores cortos
de información donde pueden ser usados para detectar un bit de error. Sin embargo,
si hay errores en dos posiciones, el vector resultante tendrá aún un número par de
unos, y el error no será detectado. Para lograr una mejor protección se pueden
agregar varios bits de paridad, derivados sobre otro arreglo de bits de datos.
• Se usa como patrón de prefijos de bit para comprobar su autenticidad.
• Funciona para hacer convenios entre dispositivos para saber en qué orden
están los bits enviados (desde el menos significativo hasta el más
significativo).
En muchos protocolos de comunicación es utilizado el CRC para detectar errores,
tanto en módulos de comunicación, así como en equipos de cliente. Uno de los
aspectos más importantes en el CRC es el vector de generación polinomial, ya que
éste define qué tan robusto será el sistema de detección de errores, y entre más
bits, más eficiente será el sistema. A continuación, se muestra una lista de los
generadores polinomiales CRC más utilizados:
Como puede observarse, el número de bits del CRC define el grado del polinomio
de generación. Entre más bits de CRC, más rápido debe ser el procesamiento de
las señales digitales, para poder encontrar los errores de una manera eficiente,
rápida y segura.

10. 10
5 ARQ: Estrategias de retransmisión
El concepto general de solicitud automática de repetición (ARQ – Automatic Repeat
Request) consiste en detectar bloques de información con errores en el módulo
receptor DLC y después enviar una solicitud al transmisor DLC para repetir la
información de aquellos bloques con errores. Hay dos diferentes formas de
algoritmos o protocolos de retransmisión. El primero es sobre la exactitud: ¿El
protocolo tuvo éxito en la emisión de cada paquete sin errores en el receptor DLC?
El segundo es sobre la eficiencia: ¿Cuánto de la capacidad de transmisión se
desperdicia por la espera innecesaria y por el re-envío de retransmisiones
innecesarias?
Primeramente, muchas clases de protocolos son desarrolladas y mostradas para
ser correctas. Después, el efecto de varios parámetros en la eficiencia de estas
clases.
Cuando un error es detectado en un bloque de información, un nuevo bloque que
contiene el viejo paquete es transmitido. En consecuencia, el primer bloque
transmitido podría contener el primer paquete, el siguiente bloque el segundo
paquete, el tercer paquete una repetición del primer paquete, etc.
Cuando un paquete es repetido, el bloque de cabecera y el trailer podrían o no
podrían ser el mismo como en la versión anterior.
5.1 Stop-and-wait ARQ
El tipo de protocolo de retransmisión más simple es llamado stop-and-wait. La idea
básica es asegurar que cada paquete que ha sido recibido correctamente antes de
transmitir el siguiente paquete. En consecuencia, en los paquetes transmitidos de
un punto A a un punto B, el primer paquete es transmitido en el primer bloque, y
después el emisor DLC espera. Si el bloque no tiene errores, B envía un mensaje
de reconocimiento (acknowledgment), también llamado ack, de regreso a A; si el
bloque tiene un error, B envía un reconocimiento negativo (también llamado nack)
de regreso a A. Dado que los errores pueden ocurrir desde B a A o de A a B, el ack
o nack están protegidos con CRC.

11. 11
Si B recibe un paquete libre de errores, el ack que recibe A por parte B hace que
comience a emitir el siguiente paquete de datos. Por el contrario, si A recibe un nak,
comienza a retransmitir el paquete de datos enviado previamente. Finalmente, si
alguno de los ack o nak se pierde, A debe eventualmente detenerse y re-enviar el
paquete previo. Lo único que queda por hacer es que tanto el emisor como el
receptor sepan cuándo se está retransmitiendo un dato, y que significa cada ack y
nack que se envían al transmisor, para que de esta forma la transmisión de datos
sea efectiva y correcta.
Figura 5. Ejemplo de uso de una secuencia y solicitud de paquetes.

12. 12
6 Observaciones
• Las cadenas de bits que son enviadas por algún protocolo de comunicación
es posible representarlas mediante polinomios, aunque es de matemática
binaria.
• El CRC es un método muy efectivo para la detección de errores, pero no
asegura al 100% que la transmisión sea efectiva.
• El número de bits que se desea de CRC son los bits que se agregan al dato
original.
• Al realizar la división de polinomios, esta división es algo diferente, ya que es
en lógica binaria, y por lo tanto, no se restan o suman los distintos residuos
que van saliendo, sino que simplemente se ignora el carry.
• El vector de generación de polinomios g(x) puede ser cualquier vector de
potencia L, pero existen algunos vectores pre-hechos que son de los más
eficientes.
• El CRC, entre más bits se agregan, más seguro es el envío de datos.
• El vector de información ACK o NACK sirven para hacer una retransmisión
de datos efectiva en caso de pérdida de información o datos modificados.
• El transmisor y receptor deben estar en sincronía para saber qué número de
paquetes de datos está siendo emitido, o si hubo una retransmisión, para
evitar un mal acomodo de los bytes de información.

13. 13
7 Conclusiones
La implementación de métodos de detección de errores en las comunicaciones
digitales permitió que éstas fueran más eficientes, correctas y que cada vez más el
número de datos enviados aumentara exponencialmente. El método analizado en
este trabajo fue el CRC: Verificación por redundancia cíclica. Básicamente se
compone de ciertos polinomios hechos por los datos a enviar y el número de bits
deseados en el CRC. Esto a su vez tiene la consecuencia de que el número de bits
por paquete de datos emitido aumente, dependiendo del número de bits del CRC.
Por ejemplo, si tengo un paquete de datos de 8 bits y deseo 4 bits de CRC, el dato
a enviar ya transformado será de 12 bits. Cabe señalar que, entre un mayor número
de bits de CRC, mayor es la protección de la información.
Por otra parte, el desarrollo de los procesadores de información debe ser orientado
hacia la rapidez y exactitud, ya que, debido a la emisión de un mayor número de
bits, los distintos procesadores y módulos de comunicación deben
enviarlos/recibirlos y codificarlos/decodificarlos de forma correcta y rápida, por lo
que procesadores más avanzados permiten tener una protección de alta fiabilidad
y rapidez.
Si el objetivo final del CRC es mejorar la protección de los datos, es necesario
implementar algunos protocolos de repetición/recuperación de datos, como el stop-
and-wait ARQ, el cual se basa en mecanismos de reconocimiento de paquetes. Esto
hace más robusta la protección, pero no tiene una fiabilidad del 100%. Deben existir
algunos otros protocolos que aseguren el buen funcionamiento y transmisión de los
datos, tal como lo hace el protocolo TCP/IP o el protocolo CAN.

14. 14
8 Fuentes de información
1. Dr Ma,D. & Dr Yuk, T.I. Digital Communications III: Cyclic redundancy check
(CRC) codes. University of Hong Kong, China, 2010.
2. Höst, Stefan. Error detection by CRC. Lund University: Electrical and
Information Technology, Suecia.
3. Kowalk, W. CRC Cyclic Redundancy Check Analysing and correcting errors.
Universität Oldenburg, Alemania, 2006.
4. Matloff, Norman. Cyclic Redundancy Checking. University of California at
Davis, USA, 2001.
5. Bertsekas, Dimitri & Gallager, Robert. Data Networks. Massachusetts
Institute of Technology, USA, 1992.