es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

crc-16 IBM, 0x00 no tomado en consideración

19 Jul, 2023 Programación

Probé una implementación de crc-16/ibm que encontré en la web. Cuando lo probé con una matriz de bytes hexadecimales, funcionó bien, pero si incluyo algunos valores 0x00, entonces no da el resultado correcto.
Aquí está su código:

unsigned short ComputeCRC16(const unsigned char* buf, unsigned int len) {
    unsigned short crc = 0;
    for (unsigned int j = 0; j < len; j++)
    {
        unsigned char b = buf[j];
        for (unsigned char i = 0; i < 8; i++)
        {
            crc = ((b ^ (unsigned char)crc) & 1) ? ((crc >> 1) ^ 0xA001) : (crc >> 1);
            b >>= 1;
        }
    }
    return crc;
}

Lo probé con este código:

int main() {

    //fe   b5     5f       f7
    unsigned char buf1[4096] = { 0xfe, 0xb5, 0x5f, 0xf7 };

    //fe   b5     00    5f     f7   00
    unsigned char buf2[4096] = { 0xfe, 0xb5, 0x00, 0x5f, 0xf7, 0x00 };

    int a = strlen(buf1);
    unsigned short res = ComputeCRC16(buf1, a);
    printf("res = %04x\n", res); //res : 7858, el resultado es correcto

    int b = strlen(buf2);
    unsigned short res = ComputeCRC16(buf2, b);
    printf("res = %04x\n", res); //res : d781, el resultado no es correcto
    return 0;                   //el resultado correcto : 26EE
}

Para verificar el resultado, utilizo este sitio web:

On-line CRC calculation and free library

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Problema con la implementación CRC-16/IBM

    Un experto en TI especializado en arreglos, c y crc16 compartió que probó una implementación CRC-16/IBM que encontró en la red usando un arreglo de bytes hexadecimal. Mencionó que la implementación funciona bien hasta que se incluyen algunos valores 0x00 en el arreglo de bytes. En este escenario, la implementación no da el resultado adecuado.

    El código de la implementación se muestra a continuación:

    unsigned short ComputeCRC16(const unsigned char* buf, unsigned int len) {
    unsigned short crc = 0;
    for (unsigned int j = 0; j < len; j++)
    {
        unsigned char b = buf[j];
        for (unsigned char i = 0; i < 8; i++)
        {
            crc = ((b ^ (unsigned char)crc) & 1) ? ((crc >> 1) ^ 0xA001) : (crc >> 1);
            b >>= 1;
        }
    }
    return crc;
}

    Para demostrar el problema, el experto en TI probó la implementación con dos arreglos de bytes, buf1 y buf2. El arreglo buf1 estaba compuesto por 0xfe, 0xb5, 0x5f, 0xf7, mientras que el arreglo buf2 consistía en 0xfe, 0xb5, 0x00, 0x5f, 0xf7, 0x00. Cuando aplicaron la implementación en buf1, el resultado fue correcto (es decir, 7858), mientras que para buf2, el resultado fue incorrecto (es decir, d781).

    Tras investigar, el experto en TI supuestamente encontró que el código de la implementación no maneja correctamente los valores 0x00. Por ejemplo, durante la ejecución, cuando el valor de b es 0x00, la declaración condicional relevante causa que el valor de crc se desplace hacia la derecha solo en uno, en lugar de dos. Esto provoca una manipulación incorrecta de bits y da como resultado un valor de CRC incorrecto.

Comments are closed.