Verificación de Errores en la Transmisión de Datos

I. Marco Teórico:
La codificación binaria es de gran utilidad práctica en dispositivos electrónicos como
ordenadores, donde la información se puede codificar basándose en la presencia o no de una señal
eléctrica.
Sin embargo, esta señal eléctrica puede sufrir alteraciones (como distorsiones o ruidos),
especialmente cuando se transportan datos a grandes distancias. Por este motivo, ser capaz de
verificar la autenticidad de estos datos es imprescindible para ciertos propósitos (incluido el uso
de información en entornos profesionales, bancarios, industriales, confidenciales o relacionados
con la seguridad).
Por este motivo existen algunos mecanismos que garantizan un nivel de integridad de los datos,
es decir, que el destinatario obtiene una confirmación de que los datos recibidos son, de hecho,
similares a los datos transmitidos. Existen dos maneras de proteger la transferencia de datos para
que no se produzcan errores:
 Instalando un medio de transmisión más seguro, es decir, una capa de protección física.
Una conexión convencional tiene, por lo general, un porcentaje de error entre 10-5 y 10-7.
 Implementando mecanismos lógicos para detectar y corregir errores.
Siendo el segundo punto el que nos compete, para esto se han perfeccionado mejores sistemas de
detección de errores mediante códigos denominados códigos de autocorrección y códigos de
autoverificación. En el presente informe se detallará 3 métodos de codificación para proteger la
información.
Verificación de paridad
La verificación de paridad es uno de los métodos de verificación más simples. Consiste en agregar
un bit adicional (denominado bit de paridad) a un cierto número de bits de datos. Este bit adicional
tomará un valor de ‘0’ lógico o ‘1’ lógico dependiendo de la cantidad de ‘1’s lógicos que posee
la palabra código. Existen dos tipos de paridad: paridad par y paridad impar.

 Paridad impar: El bit de paridad será un ‘1’ si el número total de 1s a transmitir es par.
La suma de los bits que son ‘1’ lógicos, contando datos y bit de paridad dará como
resultado un número impar de unos.
 Paridad par: El bit de paridad será un ‘0’ si el número total de 1s a transmitir es par. La
suma de los bits que son ‘1’ lógicos, contando datos y bit de paridad dará como resultado
un número par de unos.

Palabra código Paridad par Paridad impar

0101010 1 0
0111010 0 1
1101101 1 0

Verificación CRC (Cyclic Redundancy Check)

Es el principal método de detección de errores utilizado en las telecomunicaciones. La
verificación de redundancia cíclica consiste en la protección de los datos en bloques, denominados
tramas. A cada trama se le asigna un segmento de datos denominado código de control. Este
código de control determinará el vector a agregar para codificar el mensaje y la longitud de este,
siendo menor en una unidad a la cantidad de bits del código de control. Haciendo que la trama
resultante sea divisible por el código de control.
Ejemplo:
Sea el mensaje a transmitir: 11010111011 y el código de control 10011

1 1 0 1 0 1 1 1 0 1 1 0 0 0 0
1 0 0 1 1
0 1 0 0 1 1
1 0 0 1 1
0 0 0 0 0 1 1 0 1 1
1 0 0 1 1
0 1 0 0 0 0
1 0 0 1 1
0 0 0 1 1 0 0 0
1 0 0 1 1
0 1 0 1 1

M(x)= 11010111011 y G(x)=10011 dan como resultado:

T(x)= 110101110111011
Verificación Hamming
En informática, el código de Hamming es un código detector y corrector de errores que lleva el
nombre de su inventor, Richard Hamming. En los datos codificados en Hamming se pueden
detectar errores en un bit y corregirlos, sin embargo, no se distingue entre errores de dos bits y de
un bit (para lo que se usa Hamming extendido). Esto representa una mejora respecto a los códigos
con bit de paridad, que pueden detectar errores en sólo un bit, pero no pueden corregirlo.

La codificación consiste en añadir cierto número de bits los cuales dependerán de la

longitud de la trama a ser transmitida, los cuales indicarán la paridad de ciertos elementos
de la trama a ser transmitida.
Estos bits de paridad siempre ocupan las posiciones que sean potencias de dos mientras
que las otras son ocupadas por los datos.
2𝑝 ≥ 𝑝 + 𝑛 + 1
Donde p: número de bits de paridad a agregar
n: número de bits de la trama a transmitir
Ejemplo:
P1 P2 D1 P3 D2 D3 D4 P4 D5 D6 D7
Trama 0 1 1 0 1 0 1
P1 1 0 1 0 1 1
P2 0 0 1 0 0 1
P3 0 1 1 0
P4 0 1 0 1
Palabra 1 0 0 0 1 1 0 0 1 0 1
(Hamming)
II. Estrategia o algoritmo:

Verificación de paridad:
Para la realización de esta verificación se usó el siguiente algoritmo.

Figura 1. Código en Scilab para Verificación de Paridad par (Generación de la señal eléctrica a
transmitir, codificación de paridad y generación del vector a graficar)

Como podemos observar en la Fig. 1 para generar la señal a ser transmitida se usó el comando
rand de modo que cada vez que se ejecute el programa el mensaje sea distinto. Al rand ser una
función que tiene como resultado números aleatorios comprendidos entre 0 y 1 se usó un
detector de voltaje umbral para seleccionarlo como ‘0’ lógico o ‘1’ lógico. Para codificar la
señal y añadir un bit de paridad par, usaremos el concepto explicado anteriormente por lo que
hacemos la suma total de la señal eléctrica si este es un número par el bit de paridad a agregar
será ‘0’, caso contrario será ‘1’.
Para generar el vector que graficaremos tenemos que definir un tiempo igual a la cantidad de
elementos de la señal a transmitir, considerando que cada pulso tiene por duración 1 segundo.
A su vez definimos un valor “fs” el cual nos indicará la cantidad de puntos por segundo a
graficar. Teniendo lo anterior en cuenta se genera un vector tiempo cuyo valor máximo sea el
tiempo definido anteriormente.
Para generar el vector gráficamente se hizo uso de ventanas cada segundo y se multiplicó por
su valor correspondiente de la señal a ser transmitida. Para realizar esto se hizo uso de la
sentencia for=:.
 Figura 2. Código en Scilab para Verificación de Paridad par (Transmisión por un canal
ruidoso de la señal, recepción de la señal y verificación de la fidelidad de la señal)

Como podemos observar en la Fig. 2 para la transmisión de la señal por un canal ruidoso, se
emuló una señal de ruido del tipo gaussiano y se le añadió a la señal eléctrica que se graficará.
En la generación de este ruido se tuvo en cuenta el valor resultante al usar la señal
rand(‘normal’), esta función nos retorna una señal con desviación estándar igual a 1 y con
media igual a 0, como se estudió en capítulos anteriores este ruido presentaría en un 99% valores
entre -3 veces su desviación estándar y +3 veces su desviación estándar, pero esto distorsionaría
totalmente nuestra señal ya que esta tiene como valor pico un voltio, para solucionar esto se hizo
una conversión lineal a fin de no modificar su comportamiento gaussiano pero variar la
probabilidad de aparición de los valores, reduciendo su desviación estándar para que afecte a la
señal a ser transmitida en menor cantidad, pero lo suficiente para que pueda ocurrir algún error
para ser estudiado. Para saber que valores se registrarán al recibir la señal contaminada, esta se
muestrea cada cierto intervalo de tiempo de modo que obtengamos un valor que defina la
amplitud de la señal eléctrica en todo ese tiempo.
Para la verificación de paridad, teniendo en cuenta que el bit de paridad que se registra se ubica
en la última posición, se evalúa la paridad de la señal recibida obviando el último bit. Una vez
obtenido este bit de paridad de la señal recibida se compara con el bit de paridad recibido, si
estos son iguales significa que no se detectó un error caso contrario significa que se registró un
error.
Verificación CRC
Para la verificación por redundancia cíclica se usó el siguiente algoritmo

Figura 3. Código en Scilab para la Verificación CRC (Generador de señal eléctrica a

transmitir, Creación del vector con código CRC)

Como podemos apreciar en la Fig. 4 la generación del mensaje a ser transmitido es igual a la
usada anteriormente. En esta codificación se necesita una palabra código la cual es conocida
tanto por el emisor como el receptor de modo que pueda desencriptar el mensaje. A la señal se
le añadirá un residuo de longitud n-1, siendo n la longitud del vector generador.

Figura 4. Código en Scilab para la Verificación CRC (Divisiones simples usando la función
XOR, Añadido del residuo a la señal a ser transmitida)
A continuación, se realizó las divisiones sucesivas simples como se explica en el marco teórico
para esto se hizo uso de las sentencias bucle while y for=:, primero creamos un vector residuo
al que le metemos el valor de los n primeros bits de la señal a transmitir, procedemos a hacer la
división simple y sobre escribimos el valor del residuo, como se puede apreciar en la Fig. 4.
Este nuevo residuo será evaluado, si el primer bit de este nuevo residuo es cero se ignora estos
y se llena con los siguientes valores del mensaje. Si el valor cuenta ‘k’ que se utiliza para añadir
los bits del mensaje llegase a ser máximo se fuerza la salida del bucle de modo que si tenemos
un vector de ceros no intente llenar caracteres que no existen ya que la dimensión que pediría
evaluar sería mayor a la real, como el bucle que se usa solo se realiza si ‘k’ es menor a la cantidad
de bits del mensaje a enviar con la palabra código ya no se realiza una división.
Obtenido el residuo se analiza si su primer bit es 1, de ser el caso se realiza una división más,
caso contrario se ignora la división, ya que si el residuo es 10000 considerando n=5 entonces
faltaría una división adicional porque la palabra código a añadir presenta una longitud de n-1,
por lo tanto, el primer bit del último residuo debe ser 0.
Finalmente se reemplaza los ceros de dimensión n-1 que fueron añadidos por el residuo obtenido
finalmente como el residuo es de n elementos, pero podemos afirmar con seguridad que su
primer bit es 0 ignoramos su primer valor y reemplazamos los ceros añadidos por el residuo
ignorando su primer valor.

Figura 5. Código en Scilab para la Verificación CRC (Análisis de la señal recibida)

Para la decodificación se realiza el mismo método de divisiones sucesivas simples per evaluando
la señal recibida que ya se añadió la palabra código o vector generador. Si el residuo recibido es
cero significa que la señal no fue dañada caso contrario signifca que la señal ha sida alterada
por lo que se solicita el reenvio de la trama.
Para realizar las gráficas correspondientes se usó el mismo método que para la verificación de
paridad par.
Verificación por Hamming
Para la verificación por Hamming se usó el siguiente algoritmo:

Figura 6. Código en Scilab para la Verificación por Hamming (Función cod_bin)

Como se observa en la Fig. 6, esta función recibe como datos de entrada un número de elementos
n el cual determinará la cantidad de elementos de nuestro vector resultante por ejemplo si
queremos configurar 7 elementos necesitamos 3 bits, si queremos configurar 16 elementos
necesitamos 5 bits. Luego procedemos a realizar divisiones sucesivas y así obtenemos la
representación del número en sistema binario.

Figura 7. Código en Scilab para la Verificación por Hamming (Función bit_paridad)

 Como se observa en la Fig. 7, la función bit_paridad tiene como principal salida ‘vector’ el cual
es una matriz que contiene las posiciones a evaluar de cada bit de paridad, siendo ‘vector’ una
matriz de orden [cantidad de bit de paridad, cantidad de bit de la señal a transmitir]. Para realizar
esto se usó el resultado de la función anterior y esta dividió cada cadena en partes creando una
matriz binaria. Por ejemplo:
′0′ ′1′
Si vector_binario es:’01 10 11’ entonces vector_bin sería:[′1′ ′0′].
′1′ ′1′

Para este cometido se usó la función strsplit la cual nos permite separar los valores de cadena,
posteriormente haciendo uso de dos ciclos de for=: escribiremos en ‘vector’ las posiciones que
deben ser analizadas por los bits de paridad, para encontrar las coincidencias correspondientes
evaluamos si el valor de las cadenas es igual a ‘1’. Posteriormente pasamos a retirar las
posiciones que incluyen a los bits de paridad para que en el momento de ser decodificados estos
no intervengan.

Figura 8. Código en Scilab para la Verificación por Hamming (Hallar el número de bits a
agregar, Escritura del mensaje en los bits de datos correspondientes)
Como se observa en la Fig. 8 primero obtenemos el valor de la cantidad de bits a agregar haciendo
uso de la propiedad correspondiente, para esto usamos un ciclo while el cual hará aumentar la
cantidad de bit necesario hasta que se deje de cumplir la condición. Una vez hallada la cantidad
de bits a adicionar al mensaje. Luego procedemos a hallar las posiciones que sean potencia de 2
las cuales serán ocupadas por los bits de paridad y las posiciones que no lo sean las cuales serán
ocupadas por los bits de datos. Con estos dos vectores podremos ir llenando los datos dentro de
la rama codificada.
Para esto usamos la sentencia for=: la cual nos permite llenar el valor del vector a transmitir en
la posición que indica el vector posición de datos y llenarlo con el mensaje correspondiente como
se observa en el código.
Figura 9. Código en Scilab para la Verificación por Hamming (Cálculo de los bits de paridad y
escritura en el vector Hamming codificado)
Como podemos observar en la Fig. 9, hacemos uso de las funciones explicadas con anterioridad
en las Figs. 6 y 7 con el fin de obtener el ‘vector_paridad’ el cual es una matriz que como se
mencionó posee las posiciones a ser evaluadas por cada bit de paridad. Para lograr esto hacemos
uso de dos bucles for=:, el primer ciclo recorre las filas de la matriz ‘vector_paridad’, el segundo
for:=, el cual se realiza para incremento del contador que recorrerá las filas, recorre todas las
posiciones a evaluar del bit de paridad; pero como el ‘vector_paridad’ es una matriz contiene
términos con valor 0 que se usaron para completar y obtener filas con el mismo número de
columnas y poder expresarlo como una matriz, debido a esto usamos la condicional if para
obviar estos valores y solo evaluar cuando el número sea distinto de 0. Para encontrar la paridad
nos basaremos en contar los ‘1’s lógicos para lo cual usaremos una cuenta ‘acumulada’, la cual
reiniciamos cada vez que cambiamos de fila, y analizaremos su módulo respecto a 2 para ver si
el número total de ‘1’s es par o impar y añadir el bit de paridad correspondiente.

Usando el ‘vector_pp’, el cual es un vector que contiene las posiciones potencias de dos las
cuales son las posiciones que contienen los bits de paridad. Por lo que teniendo las posiciones y
los bits de paridad podemos terminar de codificar en Hamming nuestra señal a transmitir.

Para realizar la gráfica de la señal eléctrica que represente al vector codificado en Hamming
usamos el mismo método usado en los códigos anteriores el cual consiste en usar ventanas cada
segundo y multiplicarle el valor correspondiente de la señal a ser transmitida.
 Figura 10. Código en Scilab para la Verificación por Hamming (Verificación por Hamming)

Como observamos en la Fig. 10 tras haber introducido la señal eléctrica por un canal ruidoso y
haber muestreado cada cierto intervalo un valor que identifique a un segmento determinado,
obtenemos una señal ‘vector_hr’ el cual representa el vector receptado tras la transmisión de la
señal. Para verificar la fidelidad hacia la señal original analizamos los bits de paridad recibidos
con los bits de paridad de la señal recibida, es decir analizamos la paridad de los datos recibidos
y el resultado obtenido lo analizamos con la paridad recibida. El método a usar es similar al
anterior. En este caso almacenamos los bits de paridad de la señal recibida en un vector ‘pr’ el
cual será comparado con los bits de paridad recibidos, de encontrarse una diferencia entre estos
bits significa que hubo al menos un error, el cual se podrá ubicar sumando las posiciones en las
que se encontró una discrepancia entre los bits de paridad.

Figura 11. Código en Scilab para la Verificación por Hamming (Detección del bit de error)
 Como se observa en la Fig. 10, se estudia el comportamiento del bit de error hallado si este tiene
un valor mayor a la longitud del vector enviado significa que se encontró más de un error. Si el
bit de error es cero significa que no se encontró un error y la señal recibida es igual a la señal
transmitida. De no cumplirse ni uno de esos casos significa que la decodificación solo encontró
un error y este lo puede corregir.

III. Resultados:

Verificación por Paridad:

Simulación #1:

Figura 12. Simulación de Verificación por Paridad (2 errores)

Figura 13. Simulación de Verificación por Paridad (2 errores)

Simulación #2:

Figura 14. Simulación por Verificación de Paridad (1 error)

 Figura 15. Simulación por Verificación de Paridad (1 error)

Simulación #3:

Figura 16. Simulación por Verificación de Paridad (0 errores)

Figura 17. Simulación por Verificación de Paridad (0 errores)

Verificación por CRC

Simulación #1:

Figura 18. Simulación por Verificación CRC (1 error)

 Figura 19. Simulación por Verificación CRC (1 error)

Simulación #2:

Figura 20. Simulación por Verificación CRC (0 errores)

Figura 21. Simulación por Verificación CRC (0 errores)

Simulación #3:

Figura 22. Simulación por Verificación CRC (3 errores)

Figura 23. Simulación por Verificación CRC (3 errores)

Verificación por Hamming

Simulación #1:

Figura 24. Simulación por Verificación de Hamming (0 errores)

 Figura 25. Simulación por Verificación de Hamming (0 errores)

Simulación #2:

Figura 26. Simulación por Verificación de Hamming (1 error)

Figura 27. Simulación por Verificación Hamming (1 error)

Figura 28. Simulación por Verificación de Hamming (1 error, corrección)

Simulación #3:

Figuración 29. Simulación por Verificación de Hamming (2 errores)

Figura 30. Simulación por Verificación de Hamming (2 errores)

Figura 31. Simulación por Verificación de Hamming (2 errores, corrección errónea)

 Simulación #4:

Figura 32. Simulación por Verificación de Hamming (2 errores)

Figura 33. Simulación por Verificación de Hamming (2 errores)

IV. Conclusiones y Observaciones:

Observaciones:
Verificación de Paridad:
 En la simulación #1 como podemos observar la señal llega contaminada y dos valores
fueron alterados; sin embargo, al usar la codificación de paridad este error no fue
registrado.
 En la simulación #2 como podemos observar la señal llega contaminada, pero en este
caso solo un valor es alterado y el error si es detectado.
 En la simulación #3 como podemos observar la señal llega sin ser alterada y como se
esperaba no se registra ningún error.
Verificación CRC:

 En la simulación #1 como podemos observar la señal receptada fue alterada en un bit y

al momento de decodificarla usando el método CRC este registró un error ya que su
residuo es distinto de 0 y solicita el reenvío de la trama.
 En la simulación #2 como podemos observar la señal receptada no sufre alteraciones en
el canal ruidoso y al ser evaluada por decodificación CRC no se registró ningún error, ya
que como se esperaba el residuo es cero.
  En la simulación #3 como podemos observar la señal que se observa en el receptor ha
sido alterada en 3 bits, y al ser decodificada en CRC esta presenta un residuo distinto a
cero por lo que detecta que existe un error y solicita el reenvío de la trama.
Verificación Hamming:

 En la simulación #1 como podemos observar el mensaje recibido no presenta alteraciones

respecto al mensaje enviado y al ser analizado por la decodificación de Hamming
notamos que no es registrado ni un error.
 En la simulación #2 como podemos observar el mensaje recibido presenta alteración un
bit respecto al mensaje enviado, este mensaje receptado al ser analizado por la
decodificación de Hamming detecta que existe un error y a su vez la posición de este, así
pidiéndolo corregir.
 En la simulación #3 como se puede observar el mensaje recibido presenta dos alteraciones
en bits consecutivos, al realizar la decodificación por Hamming detecta un solo error y lo
corrige sin ser ese bit uno de los dos alterados, por lo que esa corrección es errónea.

P1 P2 D1 P3 D2 D3 D4 P4 D5 D6 D7 D8
1 1 1 1 0 1 1 0 1 1 1 1
Mensaje 1 0 1 1 1 1 1 1
P1 0 1 0 1 1 1
P2 1 1 1 1 1 1
P3 1 0 1 1 1
P4 0 1 1 1 1
Error Error No No No
Paridad error error error

Existiendo discordancia en el bit de posición uno el bit de error sería aparentemente ese.

 En la simulación #4 como podemos observar el mensaje presenta tres alteraciones y el bit

de error calculado por la decodificación de Hamming desborda la longitud del mensaje
receptado por lo que se llega a la conclusión de presentar 2 o más errores.

P1 P2 D1 P3 D2 D3 D4 P4 D5 D6 D7 D8
1 0 1 1 1 0 0 1 1 0 0 1
Mensaje 1 1 0 0 1 0 0 1
P1 1 1 1 0 1 0
P2 1 1 0 0 0 0
P3 0 1 0 0 1
P4 0 1 0 0 1
Error No Error Error Error
Paridad error

Existiendo discordancia en el bit de posición dos, cuatro y ocho, el bit de error sería la
suma de todas las discrepancias siendo esta 14, superando la longitud de la trama recibida
13.
Conclusiones:

 La codificación por paridad es el más simple de realizar sin embargo al solo contar ‘1’s
y asignar un bit por la cantidad par o impar de ‘1’s que contiene el mensaje a ser enviado
es el menos fiable. Ya que de existir dos errores en el mensaje o un número par de
errores no es detectado por la decodificación de paridad y la señal es recibida como libre
de errores sin serlo.
 La codificación por paridad no puede detectar la ubicación ya que se limita a contar
‘1’s.
 La codificación por CRC es muy confiable ya que en todas las simulaciones en las
cuales la señal recibida había sufrido alguna alteración la codificación por CRC logró
detectar el error, por este motivo esta codificación es de las más usadas en las
telecomunicaciones para la transmisión de datos.
 La codificación por CRC si bien es muy confiable al momento de detectar la presencia
o no de errores en la trama, no nos permite la corrección de este debido a que no puede
ubicar el error.
 La codificación por el método de Hamming puede detectar un error en la trama y ubicar
su posición, pero si la trama presenta más errores el resultado es variado. Ya que se
mostró que para más de un error hubo casos en los que la codificación solo detectó un
error y lo corrigió siendo esa posición corregida no necesariamente el bit incorrecto
teniendo como resultado una trama alterada en lugar de una trama corregida; sin
embargo, también hubo casos en los que la codificación pudo detectar más de un error,
pero no corregirlo, esto se dio cuando el bit de error concluido por la codificación
Hamming supera la longitud de la trama. Por ejemplo, si la trama a ser enviada tiene 8
bits y la codificación Hamming nos muestra un error en el 10 bit.