Funktion zum Berechnen einer CRC16-Prüfsumme

Dem ich arbeite, eine Bibliothek zu bieten einfache, zuverlässige Kommunikation über eine RS232-oder RS485-Verbindung. Ein Teil dieser code beinhaltet die Verwendung einer CRC16-Prüfsumme für die Daten zur Aufdeckung von Korruption von der Linie Lärm. Ich habe eine Funktion zum berechnen einer Prüfsumme CRC16, aber es scheint nicht zu sein, die richtigen Werte ausgeben.

Den relevanten code, den ich geschrieben habe, ist unten (es können auch gefunden werden hier).

#include <stdint.h>

#define CRC16 0x8005

uint16_t gen_crc16(const uint8_t *data, uint16_t size)
{
    uint16_t out = 0;
    int bits_read = 0, bit_flag;

    /* Sanity check: */
    if(data == NULL)
        return 0;

    while(size > 0)
    {
        bit_flag = out >> 15;

        /* Get next bit: */
        out <<= 1;
        out |= (*data >> (7 - bits_read)) & 1;

        /* Increment bit counter: */
        bits_read++;
        if(bits_read > 7)
        {
            bits_read = 0;
            data++;
            size--;
        }

        /* Cycle check: */
        if(bit_flag)
            out ^= CRC16;
    }

    return out;
}

Bin ich die überprüfung meiner Ausgabe gegen diese online-CRC-Rechner.

Ich bin zu dem Schluss gekommen, dass entweder mein Verständnis davon, wie die Berechnung einer CRC16 falsch ist, oder der online-Rechner falsch ist (ersteres wohl wahrscheinlicher ist). Kann mir jemand sagen, wo ich vielleicht falsch läuft?

InformationsquelleAutor der Frage Jonathan Lamothe | 2012-05-12

c crc crc16

47

Gibt es mehrere details, die Sie benötigen, um "match-up" für ein bestimmtes CRC-Umsetzung - sogar mit dem gleichen Polynom kann es unterschiedliche Ergebnisse, da kleinere Unterschiede darin, wie die Daten-bits behandelt werden, die mit einem bestimmten Startwert für die CRC (manchmal null, manchmal 0xffff), und/oder invertieren der bits des CRC. Manchmal ist zum Beispiel eine Umsetzung der Arbeit aus den niederwertigen bits von der Daten-bytes, während manchmal Sie arbeiten aus dem high-order bits unten (wie bei Ihnen derzeit der Fall ist).

Außerdem müssen Sie die 'push-out' - die letzten bits des CRC nach dem ausführen alle Daten-bits durch.

Beachten Sie, dass CRC-algorithmen wurden entwickelt, um in hardware implementiert werden, so dass einige, wie wenig die Bestellung abgewickelt wird, kann nicht so viel Sinn machen von einem software-Sicht.

Wenn Sie passen wollen, die mit CRC16-Polynom 0x8005 wie gezeigt auf die lammertbies.nl CRC-calculator-Seite, müssen Sie die folgenden änderungen vornehmen, um Ihre CRC-Funktion:
- a) führen Sie die Daten-bits durch den CRC-Schleife beginnend mit dem niederwertigsten bit anstelle der von den meisten signifikante bit
- b) drücken Sie auf die letzten 16 bits der CRC aus CRC-register, nachdem Sie fertig sind mit der Eingabe-Daten
- c) umkehren der CRC-bits (ich vermute, dass dieses bit ein übertrag von hardware-Implementierungen)
So, Ihre Funktion könnte wie folgt Aussehen:
```
#define CRC16 0x8005

uint16_t gen_crc16(const uint8_t *data, uint16_t size)
{
    uint16_t out = 0;
    int bits_read = 0, bit_flag;

    /* Sanity check: */
    if(data == NULL)
        return 0;

    while(size > 0)
    {
        bit_flag = out >> 15;

        /* Get next bit: */
        out <<= 1;
        out |= (*data >> bits_read) & 1; //item a) work from the least significant bits

        /* Increment bit counter: */
        bits_read++;
        if(bits_read > 7)
        {
            bits_read = 0;
            data++;
            size--;
        }

        /* Cycle check: */
        if(bit_flag)
            out ^= CRC16;

    }

    //item b) "push out" the last 16 bits
    int i;
    for (i = 0; i < 16; ++i) {
        bit_flag = out >> 15;
        out <<= 1;
        if(bit_flag)
            out ^= CRC16;
    }

    //item c) reverse the bits
    uint16_t crc = 0;
    i = 0x8000;
    int j = 0x0001;
    for (; i != 0; i >>=1, j <<= 1) {
        if (i & out) crc |= j;
    }

    return crc;
}
```
Die Funktion zurückgibt 0xbb3d für mich, wenn ich pass in "123456789".

InformationsquelleAutor der Antwort Michael Burr

Hier folgt einen funktionierenden code zur Berechnung der crc16 CCITT. Habe es getestet und die Ergebnisse abgeglichen mit denen von http://www.lammertbies.nl/comm/info/crc-calculation.html.

unsigned short crc16(const unsigned char* data_p, unsigned char length){
    unsigned char x;
    unsigned short crc = 0xFFFF;

    while (length--){
        x = crc >> 8 ^ *data_p++;
        x ^= x>>4;
        crc = (crc << 8) ^ ((unsigned short)(x << 12)) ^ ((unsigned short)(x <<5)) ^ ((unsigned short)x);
    }
    return crc;
}

InformationsquelleAutor der Antwort Antonio Pires

5

Gibt es mehrere verschiedene Sorten von CRC-16. Sehen wiki-Seite.

Jeder von diesen wird, unterschiedliche Ergebnisse zurückgeben, von der gleichen Eingabe.

So müssen Sie sorgfältig wählen Sie die richtigen für Ihr Programm.

InformationsquelleAutor der Antwort SKi

for (pos = 0; pos < len; pos++) {
    crc ^= (uint16_t)buf[pos];     //XOR byte into least sig. byte of crc

    for (i = 8; i != 0; i--) {     //Loop over each bit
        if ((crc & 0x0001) != 0) { //If the LSB is set
            crc >>= 1;             //Shift right and XOR 0xA001
            crc ^= CRC16;
        } else {                   //Else LSB is not set
            crc >>= 1;             //Just shift right
        }
     }
}

return crc;

InformationsquelleAutor der Antwort ygs

0

Verwendet habe ich das code Beispiel aus:
http://www.sunshine2k.de/articles/coding/crc/understanding_crc.html#ch5

Und auch dieses Dienstprogramm, um zu überprüfen:
http://www.sunshine2k.de/coding/javascript/crc/crc_js.html

InformationsquelleAutor der Antwort wrapperapps

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.