CRC 8 berechnen ?

[Blamaster]

Hi,

In einem Microcontroller Projekt nutze ich ein Protokoll mit crc8 Checksumme. Nun würde ich gerne ein Delphi Programm schreiben, um mit dem Controller zu komunizieren.

Wie bekomme ich es nun in Delphi hin aus folgendem die Checksumme zu berechnen ?

Zahl1, Zahl2: integer;
Ausgabevariable:
crc: integer;

Ich hab mir schonmal auf Wikipedia einen Artikel zur Crc berechnung angesehen, komme da aber einfach nicht hinter wie ich das ganze in Delphi umsetzen kann. Es gibt ja scheinbar 2 Lösungsansätze einmal Schieberegister (langsam weniger Code) und Tabelle (schneller mehr Code).

Gibt es für die Bildung ggf. schon eine fertige function zum einbinden ?

Ich hoffe auf Eure Hilfe :)

[Mithrandir]

Es täte mich wundern (was ein Wortkonstrukt :shock: ), wenn im Delphi Encryption Compendium von negaH nix zu finden wäre... ;)

[himitsu]

Das Langsam oder Schnell sollte wurscht sein ... jedenfalls wird dein PC schneller die Prüfsumme berechntet haben (egal mit welchem Weg), als dein µP reagien kann :angel:

PS:

Zitat:

crc: integer;

Integer = aktuell 4 Byte aka 32 Bit
also würde das wohl einen CRC32 ergeben :zwinker:


und dann ist CRC8 nicht gleich CRC8, denn es gibt verschiedene Rechenweisen, bzw. unterschiedliche Verrechnungswerte (Polynom)

[Blamaster]

Hi,

Danke schonmal für die Antworten :)

Die DEC Units sind ja wirklich umfangreich.

Der µC Code ist mit bascom geschrieben. Ich kann nur leider nicht rausfinden welches Polynom dort genutzt wird, ich gehe allerdings davon aus das es einen durchgesetzten standard gibt ?

Das mit crc: integer; ist schon richtig. Ich möchte den Wert für weitere Verarbeitung in einer Integer Variable haben. Zum senden an den µC wandel ich diese dann als Ansi Char um und sende sie.

Wie müsste bei der DEC CRC Unit der Funktionsaufruf aussehen ? Da sind für eine einfache Crc 8 Berechnung recht viele Parameter dessen Wirkung mir nicht ganz klar ist.

[himitsu]

http://www.mikrocontroller.net/topic/9929

für CRC8 macht sich ein Byte doch eigentlich schon besser? :stupid:
jedenfalls wäre es vollkommen ausreichend

[add]
dort hast du ein Beispiel für's DEC und müßtest dann wohl CRC_8 oder was Ähnliches als Type verwenden
http://www.delphipraxis.net/internal...highlight=crc8

Delphi-Quellcode:

const
  CRC8Table: array[0..255] of Byte = (
    $00, $07, $0E, $09, $1C, $1B, $12, $15,
    $38, $3F, $36, $31, $24, $23, $2A, $2D,
    $70, $77, $7E, $79, $6C, $6B, $62, $65,
    $48, $4F, $46, $41, $54, $53, $5A, $5D,
    $E0, $E7, $EE, $E9, $FC, $FB, $F2, $F5,
    $D8, $DF, $D6, $D1, $C4, $C3, $CA, $CD,
    $90, $97, $9E, $99, $8C, $8B, $82, $85,
    $A8, $AF, $A6, $A1, $B4, $B3, $BA, $BD,
    $C7, $C0, $C9, $CE, $DB, $DC, $D5, $D2,
    $FF, $F8, $F1, $F6, $E3, $E4, $ED, $EA,
    $B7, $B0, $B9, $BE, $AB, $AC, $A5, $A2,
    $8F, $88, $81, $86, $93, $94, $9D, $9A,
    $27, $20, $29, $2E, $3B, $3C, $35, $32,
    $1F, $18, $11, $16, $03, $04, $0D, $0A,
    $57, $50, $59, $5E, $4B, $4C, $45, $42,
    $6F, $68, $61, $66, $73, $74, $7D, $7A,
    $89, $8E, $87, $80, $95, $92, $9B, $9C,
    $B1, $B6, $BF, $B8, $AD, $AA, $A3, $A4,
    $F9, $FE, $F7, $F0, $E5, $E2, $EB, $EC,
    $C1, $C6, $CF, $C8, $DD, $DA, $D3, $D4,
    $69, $6E, $67, $60, $75, $72, $7B, $7C,
    $51, $56, $5F, $58, $4D, $4A, $43, $44,
    $19, $1E, $17, $10, $05, $02, $0B, $0C,
    $21, $26, $2F, $28, $3D, $3A, $33, $34,
    $4E, $49, $40, $47, $52, $55, $5C, $5B,
    $76, $71, $78, $7F, $6A, $6D, $64, $63,
    $3E, $39, $30, $37, $22, $25, $2C, $2B,
    $06, $01, $08, $0F, $1A, $1D, $14, $13,
    $AE, $A9, $A0, $A7, $B2, $B5, $BC, $BB,
    $96, $91, $98, $9F, $8A, $8D, $84, $83,
    $DE, $D9, $D0, $D7, $C2, $C5, $CC, $CB,
    $E6, $E1, $E8, $EF, $FA, $FD, $F4, $F3);

function CRC8(const s: ansistring): Byte;
var
  i, iLen, iStep: Integer;
begin
  Result := 0;
  iLen := Length(s);
  if iLen < 32 then
  begin
    for i := 1 to iLen do
    begin
      Result := CRC8Table[Result xor Byte(s[i])];
    end;
  end
  else
  begin
    iStep := iLen div 32 + 1;
    i := 1;
    while i < iLen do
    begin
      Result := CRC8Table[Result xor Byte(s[i])];
      Inc(i, iStep);
    end;
  end;
end;

wobei mir die Berechnung, bei 32 und mehr Zeichen, eigenartig vorkommt
und ich es daher auch mal nur so probieren würde

Delphi-Quellcode:

function CRC8(const s: ansistring): Byte;
var
  i: Integer;
begin
  Result := 0;
  for i := 1 to Length(s) do
    Result := CRC8Table[Result xor Byte(s[i])];
end;

[Blamaster]

@ himitsu

Stimmt die oberste funktion scheint etwas aufweniger gestaltet zu sein wieso auch immer.

Ich bin jetzt etwas weitergekommen.

Ich weiß nun schonmal soviel.

A: array[0..2] of byte;

A[0] := 1
A[1] := 2
A[2] := 3

Die Crc8 der 3 Bytes müsste 216 ergeben.

Außerdem habe ich noch folgendes VB beispiel dazu gefunden:

Delphi-Quellcode:

Function Docrc8(s As String) As Byte
Dim j As Byte
Dim k As Byte
Dim crc8 As Byte
crc8 = 0
For m = 1 To Len(s)
x = Asc(Mid(s, m, 1))
For k = 0 To 7
j = 1 And (x Xor crc8)
crc8 = Fix(crc8 / 2) And &HFF
x = Fix(x / 2) And &HFF
If j <> 0 Then
crc8 = crc8 Xor &H8C
End If
Next k
Next
Docrc8 = crc8
End Function

Lässt das Rückschlüsse auf das verwendete Polynom zu ?

[himitsu]

ich würde es so übersetzen ... und hoff' es stimmt.

Delphi-Quellcode:

function CRC8(const s: AnsiString): Byte;
var j, k, x: Byte;
  m: Integer;
begin
  Result := 0;
  for m := 1 to Length(s) do begin
    x := Ord(s[m]);
    for k := 0 to 7 do begin
      j := 1 and (x xor Result);
      Result := Result div 2;
      x := x div 2;
      if j <> 0 then Result := Result xor $8C;
    end;
  end;
end;

[gammatester]

Zitat:

Zitat von Blamaster

@ himitsu
Ich weiß nun schonmal soviel.

A: array[0..2] of byte;

A[0] := 1
A[1] := 2
A[2] := 3

Die Crc8 der 3 Bytes müsste 216 ergeben.
...

Lässt das Rückschlüsse auf das verwendete Polynom zu ?

Aber sicher, das Poly ist $8C. Hier ein Programm für Deinen Fall

Delphi-Quellcode:

program crc8blam;

{$ifdef win32}
{$apptype console}
{$endif}
const
  test: array[0..2] of byte = (1,2,3);

{---------------------------------------------------------------------------}
function crc8_blamaster(const b: array of byte): byte;
  {-CRC8 für Blamaster}
const
  Poly = $8C;
  {Rocksoft parameter:
   (poly   : $31;  // $8C reflected
    init   : $00;
    xorout : $00;
    check  : $F4;
    width  : 8;
    refin  : true;
    refout : true;)
  }
var
  crc: byte;
  i,j: integer;
begin
   crc := 0;
   for i:=low(b) to high(b) do begin
     crc := crc xor b[i];
     for j:=1 to 8 do begin
       if odd(crc) then  crc := (crc shr 1) xor Poly
       else crc := crc shr 1;
     end;
   end;
   crc8_blamaster := crc;
end;


begin
  writeln('Test:',crc8_blamaster(test));
end.

Kannst Du mit beliebigem array of byte aufrufen. Info zum Rocksoftmodel auf meiner CRC-Seite

Ausgabe des Programms:

Code:

D:\BP_WE\WORK\CRC_HASH>D:\DMX\M10\DCC32 -b crc8blam.pas
Borland Delphi for Win32 compiler version 18.0
Copyright (c) 1983,2005 Borland Software Corporation
crc8blam.pas(42)
43 lines, 0.10 seconds, 12152 bytes code, 12168 bytes data.

D:\BP_WE\WORK\CRC_HASH>crc8blam.exe
Test:216

Gruß Gammatester

[Blamaster]

Hi,

Vielen Dank, damit funktioniert es perfekt :)