C++ Community

Hi,

Ich suche ne fertige CRC16 funktion! hat jemand da schon was gemacht? was ist mit dieser CRC table? wie viele bytes an ram braucht die?

bye

MFK

Ja. Was soll damit sein? 512.

MFK schrieb:

geht auch mit 32: http://www.geocities.com/malbrain/crc_c.html
übrigens wird nicht wirklich RAM gebraucht, weils konstanten sind, kann mans (je nach system) im ROM oder Flash unterbringen.

wie berechne ich eine checksumme von mehreren werten?
teilchecksummen berrechnen dann addieren?
was ist mit dem ~ bzw ~0U hier?

sowas suche ich:

uint16_t
    crc16_update(uint16_t crc, uint8_t a)
    {
        int i;

        crc ^= a;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0xA001;
            else
                crc = (crc >> 1);
        }

        return crc;
    }

nur wo ist hier die polynom tabelle? geht sowas auch für crc32?

hi

warum bekomme ich da 2 verschiedene checksummen raus?

/*
 * Build auxiliary table for parallel byte-at-a-time CRC-32.
 */
#define CRC32_POLY 0x04c11db7     /* AUTODIN II, Ethernet, & FDDI */

unsigned long crc32_table[256];

/* Initialized first time "crc32()" is called. If you prefer, you can
 * statically initialize it at compile time. [Another exercise.]
 */

unsigned long crc32_update(unsigned long crc, unsigned int a)
{
        unsigned long crc_new;

        crc_new = (crc << 8) ^ crc32_table[(crc >> 24) ^ a];
        return ~crc_new;            /* transmit complement, per CRC-32 spec */
}

void init_crc32()
{
        int i, j;
        unsigned long c;

        for (i = 0; i < 256; ++i) {
                for (c = i << 24, j = 8; j > 0; --j)
                        c = c & 0x80000000 ? (c << 1) ^ CRC32_POLY : (c << 1);
                crc32_table[i] = c;
        }
}

unsigned long crc32(unsigned char *buf, int len)
{
        unsigned char *p;
        unsigned long  crc;

        if (!crc32_table[1])    /* if not already done, */
                init_crc32();   /* build table */
        crc = 0xffffffff;       /* preload shift register, per CRC-32 spec */
        for (p = buf; len > 0; ++p, --len)
                crc = (crc << 8) ^ crc32_table[(crc >> 24) ^ *p];
        return ~crc;            /* transmit complement, per CRC-32 spec */
}

int main()
{
   unsigned long crc = 0xffffffff; // or 0x00000000 ??
   unsigned int var1 = 12;
   unsigned int var2 = 3;
   unsigned int var3 = 9;

   init_crc32();
   crc = crc32_update(crc, var1);
   crc = crc32_update(crc, var2);
   crc = crc32_update(crc, var3);
   cout << "crc: " << crc << endl;

   crc = 0;
   unsigned char varxx[] = {12, 3, 9};
   crc = crc32(varxx, sizeof(varxx));
   cout << "crc: " << crc << endl;

    cin.get();
    return 0;
}

Babbage

Muss der init_crc32(); vor der 2. Berechnung noch ausgeführt werden?

nö, verwendet ja das gleiche array!

für nur einen interger lieft der code gleiche ergenisse:

unsigned long crc = 0xffffffff; // or 0x00000000 ??
   unsigned int var1 = 12;

   init_crc32();
   crc = crc32_update(crc, var1);
   cout << "crc: " << crc << endl;

   crc = 0;
   unsigned char varxx[] = {12};
   crc = crc32(varxx, sizeof(varxx)); 
   cout << "crc: " << crc << endl;

Babbage

gelöscht

Babbage

Bei der Funktion
crc32_update
wird jedesmal mit : return ~crc_new; das Komplement zurückgegeben.

Bei crc32(unsigned char *buf, int len) nur einmal am Ende der Funktion

die crc32_update hat ja deswegen auch 3 aufrufe aber crc32 nur einen.

bye

aso weiss was du meinst...

sehr doof von mir;)

welchen datentyp hat eine übliche crc32 funktion als input unsigned char oder unsigned int? bei crc32 wird man wohl unsigned int nehmen wenn man bei crc16 schon unsinged char hat?

bye

BorisDieKlinge

nw. auch unsigned char, du errechnet ja ne checksume einer bytesquenz... das ergebniss ist bzw. der rückgabewert ist unterschiedlich groß

hm

ich will daraus die checksumme berechnen:
tInt16u geschwindigkeit;
tInt16u offset;
tInt8u bewegung;
tInt8u halten;

dann muss der input min unsigned int sein, ist das nicht ok?

bye

BorisDieKlinge

//DIE CRC FUNKTIOM
unsigned long crc32(unsigned char *buf, int len)
{
        unsigned char *p;
        unsigned long  crc;

        if (!crc32_table[1])    /* if not already done, */
                init_crc32();   /* build table */
        crc = 0xffffffff;       /* preload shift register, per CRC-32 spec */
        for (p = buf; len > 0; ++p, --len)
                crc = (crc << 8) ^ crc32_table[(crc >> 24) ^ *p];
        return ~crc;            /* transmit complement, per CRC-32 spec */
}

//DEINE DATEN
struct typedef{

tInt16u geschwindigkeit;
tInt16u offset;
tInt8u bewegung;
tInt8u halten;

} DATA;

//Daten anlegen
DATA x;

//CRC berechnen
unsigned long myCRC= crc32((unsigned char*)&x, sizeof(x));

so gehts natürlich auch!

kann man auch ne crc table verwenden die kleiner ist als 256? wär fein!

BorisDieKlinge

du kansnt auch ne CRC funktion ohne Table verwenden. Die ist halt bischen langsamer. Aber wenn dein code nicht zeitkritisch ist, ists egal. die version mit dem look-up table ist nur performancetechnisch relevant.

google mal

justint schrieb:

kann man auch ne crc table verwenden die kleiner ist als 256? wär fein!

klar, schau dir's dritte posting dieses threads an.

fricky: ok danke;) ist dann das ein anderes crc?

woher weiss ich ob ich crc16 oder crc32 brauche?

bye

Babbage

Das solltest Du selbst bestimmen.

Ein CRC32 ist halt weitaus sicherer. Der arbeitet mit 32 Bit und die Möglichkeit einer falschen Checksumme besteht rechnerisch bei 1 zu 2^32 (1:4294967296)

Ein CRC16 ist halt etwas schneller und braucht nur 16 Bit. Den verwende ich gerne mal in nem externem Controller wenn nicht soviele Resourcen zur Verfügung habe. Die Datensicherheit sinkt allerdings auf 1 zu 2^16 (1:65536).

Das kann bei häufigen Fehlern, beispielsweise bei einer fehlerbehafteten Datenübertragung schon zu viel sein.

Babbage