CRC32 vom STM32F4 auf dem PC zurück rechnen?

Deepdiver99 Gast #3708488
Lesenswert?
• ▲
▼ 
Hi!

Versuche schon seit Tagen die CRC32 Prüfsumme von einem STM32F4 auf dem 
PC in C++ nach zu vollziehen. Weiss jetzt leider nicht mehr weiter.
Auf dem STM32F4 werden mit der CRC_Block Berechnung ein Array mit 2 
32Bit Werten berechnet. Leider schaffe ich es nicht auf das gleiche 
Ergebniss in C++ dem PC zu kommen. Habe schon einigen Beispielcode 
versucht.
Bei nur einem 32Bit Werte klappt es im übrigen.

Polynom = 0x4C11DB7
CRC initial value = 0XFFFFFFFF
Datenbits = 32

Kann mir jemand dabei helfen?

Viele Grüße
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Detlef K. #3709428
Lesenswert?
• ▲
▼ 
1
void initCRC32_STM(uint32_t* crc)

2
{

3
  *crc = 0xFFFFFFFF;

4
}

5


6
void calcCRC32_STM(uint32_t* crc, uint32_t data)

7
{

8
  uint32_t cnt;

9


10
  for(cnt=0;cnt<32;cnt++)

11
  {

12
    if((int32_t)(*crc ^ data)<0)

13
      *crc = (*crc << 1) ^ 0x04C11DB7;

14
    else

15
      *crc <<= 1;

16
    data <<=1;

17
  }

18
}


Oder so anders geschrieben. ;)
1
void calcCRC32_STM(uint32_t* crc, uint32_t data)

2
{

3
  uint32_t cnt;

4


5
  for(cnt=0;cnt<32;cnt++)

6
  {

7
    *crc = ((int32_t)(*crc ^ data))<0 ? (*crc << 1) ^ 0x04C11DB7 : *crc << 1;

8
    data <<=1;

9
  }

10
}

Viel Spaß.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Deepdiver99 Gast #3709532
Lesenswert?
• ▲
▼ 
Komme leider immer noch nicht klar.

Bei dem Beispiel aus dem Link von YALU kommt nix gescheites raus.
1
#include "stdafx.h"

2
#include <string.h>

3
#include <stdio.h>

4


5
unsigned int CRC32WideFast(unsigned int Crc, unsigned int Size, char *Buffer)

6
{

7
  Size = Size >> 2; // /4

8


9
  while(Size--)

10
  {

11
    static const unsigned int CrcTable[16] = { // Nibble lookup table for 0x04C11DB7 polynomial

12
    0x00000000,0x04C11DB7,0x09823B6E,0x0D4326D9,0x130476DC,0x17C56B6B,0x1A864DB2,0x1E475005,

13
    0x2608EDB8,0x22C9F00F,0x2F8AD6D6,0x2B4BCB61,0x350C9B64,0x31CD86D3,0x3C8EA00A,0x384FBDBD };

14


15
    Crc = Crc ^ *((unsigned int *)Buffer); // Apply all 32-bits

16


17
    Buffer += 4;

18


19
    // Process 32-bits, 4 at a time, or 8 rounds

20


21
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28]; // Assumes 32-bit reg, masking index to 4-bits

22
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28]; //  0x04C11DB7 Polynomial used in STM32

23
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28];

24
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28];

25
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28];

26
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28];

27
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28];

28
    Crc = (Crc << 4) ^ CrcTable[Crc >> 28];

29
  }

30


31
  return(Crc);

32
}

33


34
char Buffer[] = {0x33,0x55};

35


36
int _tmain(int argc, _TCHAR* argv[])

37
{

38
  printf("CRC  :  0x%x\n", CRC32WideFast(0xffffffff, 2, Buffer));

39
  return(0);

40
}




Konnte jetzt aber nach langen probieren auf der Seite 
http://zorc.breitbandkatze.de/crc.html die CRC32 Prüfsumme vom STM32F4 
nach voll ziehen.
Der Anfangswert ist 0xffffffff. Daraus wird mit dem Datenbyte die 
Prüfsumme gebildet. Diese Prüfsumme nehmen ich dann als neuen 
Anfangswert für das nächste Datenbyte.
Wie aber geht sie Sache "rückwärts" mit der letzten Prüfsumme?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Detlef K. #3709545
Lesenswert?
• ▲
▼ 
Deepdiver99 schrieb:
> char Buffer[] = {0x33,0x55};

Das kann ja nix werden. Ein Array mit der Größe von zwei Byte, aus dem 
vier Byte gelesen werden sollen.
Im Code steht aber zu Glück:
>  Size = Size >> 2; // /4
Also wird 2/4 geteilt, ergibt hier 0. (ich hoffe jetzt kommt hier 
niemand mit halben Adressen ;) )
Und damit wird hier:
> while(Size--)
nie was ausgeführt, weil Size NULL ist.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Deepdiver99 Gast #3709669
Lesenswert?
• ▲
▼ 
Stimmt aber immer noch nicht mit dem Ergebniss vom STM32F4

1
  /* Enable CRC clock */

2
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_CRC, ENABLE);

3


4
  /* Reset CRC generator */

5
  CRC_ResetDR();

6


7
  uint32_t buffer[2];

8
  buffer[0] = 0x33;

9
  buffer[1] = 0x55;

10
  uint32_t CRCValue = CRC_CalcBlockCRC((uint32_t *)buffer, 2);


Da kommt dann beim STM32F4 = 0x5df6dc01  raus.

Auf dem PC mit:
1
  char Buffer[] = {0x00,0x00,0x00,0x33,0x00,0x00,0x00,0x55};

2


3
  printf("CRC  :  0x%x\n", CRC32WideFast(0xffffffff, 8, Buffer));


kommt = 0xf1d140a9 raus.

Eigentlich müsste das jetzt doch gleich sein?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt. Bitte hier nur auf die ursprüngliche Frage antworten, für neue Fragen einen neuen Beitrag erstellen.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Dein Name und deine E-Mail-Adresse

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.