3. Hilfe bei CRC Kalkulation

Hilfe bei CRC Kalkulation

  • ?

    Hallo Ihr Freunde des C++

    Ich bin eigentlich LabView Programmierer und muss ein Gerät über Rs232 ansteuern. In der Dokumentation der Schnittstellen Syntax steht jedoch zur CRC Prüfsummenbildung aber nur, dass das Polynom x16+x12+x^5+1 verwendet wird und dann ein Text in C/C++ (glaub ich jedenfalls)der zeigen soll wie das geht.
    Hier der Text:
    const byte crc_tab[]= /* CRC Look-Up Tabelle (4 Bit shift) fuer das Generator-Polynom 1 1000 0101 */
    {0x00, 0xcd,0xd9, 0x14,0xf1, 0x28, 0xe5, 0xa1, 0x6c, 0x78, 0xb5,0x50, 0x9d, 0x89, 0x44};

    unsigned char crc_ber (byte*anf_adr, byte*end_adr)
    byte crc,idx;
    byte *byte_ptr;

    for (byte_ptr=anf_adr,crc=0;byte_ptr<=end_adr;byte_ptr++)
    { idx=(crc^*byte_ptr)&0xf;
    crc=((crc>>4)&0xf)^crc_tab[idx];
    idx=(crc^(*byte_ptr>>4))&0xf;
    crc=((crc>>4)&0xf)^crc_tab[idx];}

    return(crc); /* Rueckgabewert ist berchneter crc-Wert */
    Kann mir irgendjemand sagen was dieser Programmcode rechnet, damit ich das in LabVIEW nachmachen kann?

    Im vorraus vielen Dank für die Hilfe.
    Fischfasch 😕

    0
  • D

    Der Code berechnet den CRC-Hash über den Puffer (anf_adr-end_adr) unter verwendung des Polynoms x16+x12+x^5+1... Was ist denn das eigentliche Problem?

    0
  • S

    Das sieht eher aus wie die Berechnung einer 8Bit CRC-Prüfsumme -- wahrscheinlich mit Generator-Polynom x^8 + x^7 + x^2 + 1 wenn man dem Kommentar glauben schenken kann.

    typedef unsigned char byte;

const byte crc_tab[]= /* CRC Look-Up Tabelle (4 Bit shift) fuer das Generator-Polynom 1 1000 0101 */
{0x00, 0xcd,0xd9, 0x14,0xf1, 0x28, 0xe5, 0xa1, 0x6c, 0x78, 0xb5,0x50, 0x9d, 0x89, 0x44};

unsigned char crc_ber (byte*anf_adr, byte*end_adr)
{
    byte crc,idx;
    byte *byte_ptr;

    for (byte_ptr=anf_adr,crc=0;byte_ptr<=end_adr;byte_ptr++)
    {
       idx = (crc^*byte_ptr)&0xf;
       crc = ((crc>>4)&0xf)^crc_tab[idx];
       idx = (crc^(*byte_ptr>>4))&0xf;
       crc = ((crc>>4)&0xf)^crc_tab[idx];
    }
    return crc;                          
}

    Der interessante Teil ist die For-Schleife in der Mitte. Die Variable crc wird mit 0 initialisiert und die Schleife durchläuft alle Bytes der Sequenz, die über zwei Zeiger übergeben wird (Start und Ende). Innerhalb der Schleife steht der Ausdruck *byte_ptr für das aktuelle Byte. Die sonstigen Operatoren sind "normal". Zuweisung (=), Bit-Shifting (>>), Logisches XOR (^), Logisches Und (&) und der Zugriff auf das idx -te Element der Tabelle über crc_tab[idx] .

    Gruß,
    SP

    0
  • V

    Vielleicht hilft das
    http://www.iti.fh-flensburg.de/lang/algorithmen/code/crc/crc.htm
    http://www.labviewforum.de/index.php?showtopic=2465&hl=CRC

    0
  • ?

    Hallo und danke für die bisherigen Antworten.
    Vor allem der Beitrag von Sebastian Pizer hat mir weitergeholfen das ganze etwas zu verstehen.

    nur noch ein zwei Fragen sind unklar:
    0xf ist das ein Byte mit dem Hex-Wert f ?

    Und noch zum Bitshifting >> eine Frage
    Beim Bitshifting betrachte ich den Byte als Array aus Bits und schiebe die 1er und Nuller nach rechts (oder links??).

    Und fülle ich dann von links (oder rechts??) mit Nullen auf oder, wie beim Rotieren, mit den Bits die ich rausgeschoben habe?

    Und ist XOR, das logische Oder, ein "entweder Oder" d.h. 1^1=0 oder ein "normales oder" d.h. 1^1=1 ?
    Ich glaub wenn ich diese Fragen weiß kann ich das in LabView nachprogrammieren.
    Vielen Dank
    Füschfasch

    0
  • Z

    Füschfasch schrieb:

    0xf ist das ein Byte mit dem Hex-Wert f ?

    ja. 0xF ist äquivalent zu 0x0000000F (die Anzahl der nullen variiert je nach verwendetem Datentyp. Hier einer mit einem Byte Größe)

    Füschfasch schrieb:

    Und noch zum Bitshifting >> eine Frage
    Beim Bitshifting betrachte ich den Byte als Array aus Bits und schiebe die 1er und Nuller nach rechts (oder links??).

    Und fülle ich dann von links (oder rechts??) mit Nullen auf oder, wie beim Rotieren, mit den Bits die ich rausgeschoben habe?

    geschoben wird hier nach rechts. << schiebt nach Links
    der Rechtsshiftoperator füllt afaik das nach, was angebracht ist. Bei einen unsigned Datentyp (also nicht Vorzeichenbehaftet) 0, vorzeichenbehaftet eine 1 bei negativen, eine 0 bei positiven Werten. Der Linksshiftoperator füllt immer 0 nach

    Füschfasch schrieb:

    Und ist XOR, das logische Oder, ein "entweder Oder" d.h. 1^1=0 oder ein "normales oder" d.h. 1^1=1 ?

    XOR bedeutet: entweder das eine ODER das andere. Niemals beide.

    A  B  (A XOR B)
0  0      0
0  1      1
1  0      1
1  1      0
    0
  • ?

    Danke erstmal an zwutz, das ist super erklärt, so dass es auch ein noob wie ich versteht.

    Und nun die Frage:

    der Ausdruck crc>>4 bedeutet also ein Bitshifting nach rechts um 4 Positionen, also ein 1/2 Byte? Und stehen die höherwertigen Bits rechts oder links?

    Danke
    Füschfasch

    0
  • U

    Füschfasch schrieb:

    der Ausdruck crc>>4 bedeutet also ein Bitshifting nach rechts um 4 Positionen, also ein 1/2 Byte?

    Japp - man hätte auch um 4 Bit sagen können 😛

    Füschfasch schrieb:

    Und stehen die höherwertigen Bits rechts oder links?

    Die stehen üblicherweise links - das muss intern zwar nicht so sein, aber beim shift ist die Shift-Richtung mit Hilfe des MSB/LSB definiert:

    << zahl wird (idR) größer (shift in richtung des MSB)
    >> zahl wird kleiner (shift in richtung des LSB)

    bb

    PS:
    falls dir msb/lsb nix sagt:
    http://de.wikipedia.org/wiki/Bitwertigkeit#MSB

    0
  • ?

    Hallo
    Danke unskilled für die schnelle Antwort. Ich denke ich hab jetzt das Programm verstanden. Sobald ich etwas Zeit finde (morgen oder übermorgen)werde ich das mal in LabVIEW nachprogrammieren. Mal sehen obs klappt - bin gespannt. Wenn ja, ists super wenn nein wird kommen: "Eine Frage hätt ich noch^^"

    Grüße und Danke an alle die mir bei meinem Problem geholfen haben.
    Füschfasch 🙂

    0
Anmelden zum Antworten