Detección de errores de código Hamming

Tengo este código como se indica a continuación para la verificación de errores mediante el uso de códigos Hamming. Revisé el algoritmo en Wikipedia y también entendí que funciona como se describe en el hilo. ¿Cómo funciona el código Hamming?

Pero el siguiente código usa algún tipo de suma de los bits de paridad para detectar qué bit es el error.

¿Alguien puede explicar cómo se puede usar exactamente la suma para detectar el bit de error?

código:

#include<stdio.h>
#include<math.h>
void main()
{
    int i,a[4],c[3],r[7],clk[3],n,sum=0;
    printf("Enter data bits\n");

    for(i=3;i>=0;i--)
        scanf("%d",&a[i]);
    printf("\n");

    c[0]=(a[0]+a[1]+a[2])%2;
    c[1]=(a[1]+a[2]+a[3])%2;
    c[2]=(a[1]+a[0]+a[3])%2;

    printf("data bits after hamming code is\n");

    for(i=3;i>=0;i--)
        printf("%d",a[i]);
    for(i=2;i>=0;i--)
        printf("%d",c[i]);
    printf("Enter recieved code\n");
    for(i=0;i<7;i++)
        scanf("%d",&r[i]);

    clk[0]=(r[3]+r[1]+r[2]+r[6])%2;
    clk[1]=(r[0]+r[2]+r[1]+r[5])%2;
    clk[2]=(r[0]+r[2]+r[3]+r[4])%2;

    sum=4*clk[2]+2*clk[1]+1*clk[0];

    if(sum==0)
        printf("\n u have recived coorrect code\n");
    if(sum==1)
    {   printf("Error in check bit 2\n");
        printf("The correct code is");
        r[6]=(r[6]+1)%2;
        for(i=0;i<7;i++)
        printf("%d",r[i]);
    }
    if(sum==2)
    {
        printf("Error in check bit 1\n");
        printf("The correct code is");
        r[5]=(r[5]+1)%2;
        for(i=0;i<7;i++)
        printf("%d",r[i]);
    }
    if(sum==3)
    {
        printf("\nError in data bit 1");
        printf("The correct code is");
        r[1]=(r[1]+1)%2;
        for(i=0;i<7;i++)
        printf("%d",r[i]);
    }
    if(sum==4)
    {
        printf("\n Error in chect bit 0");
        printf("The correct code is");
        r[4]=(r[4]+1)%2;
        for(i=0;i<7;i++)
        printf("%d",r[i]);
    }
    if(sum==5)
    {
        printf("\n Error in data bits 3");
        printf("The correct code is");
        r[3]=(r[3]+1)%2;
        for(i=0;i<7;i++)
        printf("%d",r[i]);
    }
    if(sum==6)
    {
        printf("Error in data bits 0");
        printf("The correct code");
        r[0]=(r[0]+1)%2;
        for(i=0;i<7;i++);
        printf("%d",r[i]);
    }
    if(sum==7)
    {
        printf("Error in data bits 2");
        printf("The correct code is");
        r[2]=(r[2]+1)%2;
        for(i=0;i<7;i++)
        printf("%d",r[i]);
    }
}

preguntado el 22 de mayo de 12 a las 15:05

Evitando for(i=3;i>=0;i--) bucles, no funcionan con números sin signo, que a menudo se usan para índices de matriz. -

ah, OK ! pero ¿podría decirme por qué el sum corresponde a los bits de error correspondientes. -

El ejercicio de hoy en mi blog ofrece una implementación de un código Hamming (7,4), con una explicación: programacionpraxis.com/2012/05/22/hamming-codes. -

Este artículo no explica lo que pide el OP. -

3 Respuestas

Aquí hay una forma alternativa de pensar sobre el código de Hamming en particular y los códigos lineales en general. Una forma de codificar el código Hamming es pasar los datos originales y luego agregarle una suma de verificación. Esa suma de verificación es una función lineal de los datos originales (calculados con aritmética mod 2).

Cuando reciba los datos, puede calcular la suma de verificación a partir de ellos y agregarlos, mod 2, a la suma de verificación recibida. Si el resultado es cero, entonces las dos sumas de verificación fueron idénticas y también podría aceptar los datos.

Si el resultado no es cero, tiene alguna función lineal de los datos transmitidos y el patrón de errores que los corrompió. Cuando agregó las dos sumas de verificación, agregó una función lineal de los datos originales y una función lineal de (los datos originales con el patrón de error agregado en el mod 2). Dado que esta es la adición del mod 2, cuando agregó las dos sumas de verificación, las dos contribuciones de los datos originales se cancelaron entre sí y terminó con algo que depende solo del patrón de error, y no en absoluto de los datos codificados. Este resultado se llama el síndrome (o al menos es equivalente al síndrome).

Por lo tanto, una forma de averiguar cuál es el patrón de error es calcular los síndromes para cada patrón de error posible (o al menos los patrones de error que le interesan) y almacenar sus síndromes en una tabla. Para un código de Hamming, normalmente considerará todos los patrones de error de un solo bit. Esta es la decodificación del síndrome.

Entonces, cuando recibe los datos, calcula el síndrome (suma de las sumas de verificación esperadas y recibidas). Si es cero, todo está bien. Si no es así, lo busca en la tabla de síndromes y, si está allí, agrega el patrón de error resultante a los datos recibidos para corregir el error. Si no está allí, ha detectado algo más que un error de un solo bit, probablemente un error de dos bits.

Una razón para analizar esto en detalle es mostrar que podría usar la misma idea (suponiendo que pueda crear tablas lo suficientemente grandes) para corregir patrones de error más complicados, o para corregir diferentes opciones de errores, si sabe que algunos errores de un solo bit son muy poco probables (así que no los ponga en la tabla), pero es probable que se produzcan algunos errores de doble bit (así que póngalos en la tabla si hay espacio para ellos).

Para códigos de error más poderosos, la cantidad de errores corregibles se vuelve inmanejable y debe usar ideas más inteligentes que aprovechen la estructura del código.

contestado el 22 de mayo de 12 a las 19:05

Sí, la tabla de síndromes crece exponencialmente. Incluso para un código de 3 bits como este, el uso de un patrón regular hace que el proceso de retroceso (descodificación del síndrome) sea más intuitivo. Ver las ilustraciones en el artículo de Wikipedia. - Patataswatter

Los bits se suman de tal manera que cada posible error de un solo bit produce una firma única en sum. Por ejemplo, todos los bits impares se suman en el bit cero, por lo que si el error está en un bit impar, la firma será impar. (Bueno, el esquema de numeración en el programa de ejemplo confunde los bits, pero esa es la forma en que lo implementaría y la forma en que se muestra en el artículo de Wikipedia).

Hay más de un código de Hamming, así que asegúrese de leer el artículo de Wikipedia sobre el Hamming (7,4) código.

contestado el 22 de mayo de 12 a las 15:05

Ver entenderlo poniendo errores en el código.

  1. Supongamos que cambiamos el r[3] bit en el código hamming recibido, así que cambie en r[3] dar como resultado un cambio en 2 bits de síndrome inidividual que es clk[0] y clk[2] entonces la suma correspondiente generada es 5 (1*1+0*2+1*4).
  2. Del mismo modo, puede poner otro error en cualquier otra ubicación de bit para obtener otra suma, por lo tanto, puede diferenciar entre suma y bits de error.
  3. Si desea preguntar más sobre este correo electrónico, Sambhav goel es mi nombre y goelsambhav9@gmail.com es mi identificación.

Respondido 24 Abr '17, 05:04

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.