CRC Funktion übersetzen (so das diese auf GCC läuft)

[Jens Meisen (Gast)]

Hallo Zusammen,

ich möchte gerne einen Maxon Motor via UART Ansteuern
(EPOS2 Motion Controller), alle Befehle bekommen hier
eine Prüfsumme (siehe Seite 23-24 im
Anhang, falls es jemanden interessiert).

Diese Beispiel müßte ich jedenfalls zum laufen kriegen.

WORD CalcFieldCRC(WORD* pDataArray, WORD numberOfWords) {

  WORD shifter, c;
  WORD carry;
  WORD CRC = 0;

  //Calculate pDataArray Word by Word
  while(numberOfWords--) {

    shifter = 0x8000;   //Initialize BitX to Bit15
    c = *pDataArray++;   //Copy next DataWord to c

    do {
      carry = CRC & 0x8000;     //Check if Bit15 of CRC is set
      CRC <<= 1;           //CRC = CRC * 2
      if(c & shifter) CRC++;     //CRC = CRC + 1, if BitX is set in c
      if(carry) CRC ^= 0x1021;   //CRC = CRC XOR G(x), if carry is true
      shifter >>= 1;         //Set BitX to next lower Bit, shifter = shifter/2
    } while(shifter);
  }
  return CRC
}

habe ich soweit für GCC "übersetzt" :)

uint16_t CalcFieldCRC(volatile uint16_t *pDataArray, uint16_t numberOfWords) {

  uint16_t shifter;
  uint16_t c;
  uint16_t carry;
  uint16_t _CRC = 0;

  //Calculate pDataArray Word by Word
  while(numberOfWords--) {

    shifter = 0x8000;   //Initialize BitX to Bit15
    c = *pDataArray++;   //Copy next DataWord to c

    do {
      carry = _CRC & 0x8000;     //Check if Bit15 of _CRC is set
      _CRC <<= 1;           //_CRC = _CRC * 2
      if(c & shifter) _CRC++;     //_CRC = _CRC + 1, if BitX is set in c
      if(carry) _CRC ^= 0x1021;  //_CRC = _CRC XOR G(x), if carry is true
      shifter >>= 1;         //Set BitX to next lower Bit, shifter = shifter/2
    } while(shifter);
  }
  return _CRC;
}

als genanntes Beispiel müßte der
Datensatz 0x10 0x01 0x03 0x20 0x01 0x02 0x00 0x00
0xA888 ergeben, ich komme so aber auf 0x497E

Weiß jemand vielleicht von Euch, ob man die Bitshift
Anweisungen in GGC so auch übernehmen kann?
(Ich kenne mich mit Bitshift leider nicht aus, habe ich
alles soweit übernommen)

Über Hilfe würde ich mich sehr freuen.

Vielen Dank & Viele Grüße
Jens

[Dr. Sommer (Gast)]

Typedef kennst du?

typedef uint16_t WORD;

und deine "Übersetzung" wäre fertig. Oder einfach die Header einbinden, 
die vom Original-Code eingebunden werden, dann hast du auch die "WORD" 
Definition, denn die hat nichts mit dem Compiler zu tun... Die findet 
sich zB in der <windows.h>

[Stefan E. (sternst)]

Jens Meisen schrieb:
> als genanntes Beispiel müßte der
> Datensatz 0x10 0x01 0x03 0x20 0x01 0x02 0x00 0x00
> 0xA888 ergeben, ich komme so aber auf 0x497E

Bist du denn auch sicher, die Funktion überhaupt richtig zu "füttern"? 
Mich macht es z.B. stutzig, dass du hier deinen Datensatz in Form von 
Bytes präsentierst, die Funktion aber offensichtlich einen Datensatz aus 
Words erwartet.

[TestX .. (xaos)]

@jens
nächstes mal die anleitung lesen... unter 5.1.8 siehst du wie die frame 
aufgebaut werden müssen...hier so gehts:

zum einen erwartet die funktion wie schon erwähnt 16bit werte, zum 
anderen musst du aufpassen wie die werte zusammengestezt werden 
(high/low byte)

#include <unistd.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

uint16_t CalcFieldCRC(volatile uint16_t *pDataArray, uint16_t numberOfWords) {

  uint16_t shifter;
  uint16_t c;
  uint16_t carry;
  uint16_t _CRC = 0;

  //Calculate pDataArray Word by Word
  while(numberOfWords--) {

    shifter = 0x8000;   //Initialize BitX to Bit15
    c = *pDataArray;   //Copy next DataWord to c
    pDataArray++;

    do {
      carry = _CRC & 0x8000;     //Check if Bit15 of _CRC is set
      _CRC <<= 1;           //_CRC = _CRC * 2
      if(c & shifter) _CRC++;     //_CRC = _CRC + 1, if BitX is set in c
      if(carry) _CRC ^= 0x1021;  //_CRC = _CRC XOR G(x), if carry is true
      shifter >>= 1;         //Set BitX to next lower Bit, shifter = shifter/2
    } while(shifter);
  }
  return _CRC;
}



int main(){

   uint16_t data[] = {0x1001, 0x2003, 0x0201, 0x0000};

   uint16_t crc = CalcFieldCRC(data, 4);

   printf("%x \n", crc);

return 0;
}

[Jens Meisen (Gast)]

Ganz herzlichen Dank!!!

Die Zusammensetzung von den vier uint16_t ist ja tückisch.
- Erster Wert wird normal zusammengesetzt aus zwei uint8_t
- Zweiter Wert ist uint16_t, bleibt alles wie es ist
- Dritter Wert high/low vertauscht, aus zwei uint8_t

und dann stimmt die Prüfsumme :)

und alles wird dann wieder auseinander genommen und mit
in uint8_t (uint16_t high/low getauscht, jetzt aber nur der
zweite Wert und die Prüfsumme) an die Motoren geschickt...

ohgottogott, zum Glück gibt das Forum :)