CRC16 Problem mit Input ASCII/Hex

[Zer0ne]

Hallo zusammen,

ich habe noch nicht so viel Erfahrung mit programmierung und daher kommt die Frage/mein Problem hier vielleicht etwas trivial vor, aber ich beise mir daran schon länger die Zähne aus.
Ich soll für eine Kommunikation mit einem externen Gerät eine Checksumme mit CRC16 und dem Polynom $A001 berechnen.

Den CRC habe ich bereits implementiert für eine ASCII Eingabe:

Code:

function CalcCRC(Command: String; var Value: Int32): Integer; 
var i,j : Integer;
begin
  Result := 0;
  for i:=0 to Length(Command) do
  begin
    for j:=0 to 7 do
    begin
      if ((ord(Command[i]) and $01) XOR (Value And $0001) <> 0) then
        Value := (Value shr 1) XOR $A001
      else
        Value := Value shr 1;
      ord(Command[i]) := ord(Command[i]) shr 1;
    end;
  end;
end;

Aufrufen kann ich z.B. mit einer String Eingabe (Command):

Code:

command := '020D000A413068656C6C6F'; 
CalcCRC(command, crc);
Result := IntToHex(crc, 4);

Das Ergebnis, was ich hier erhalten ist 0xA3DA. Dies ist auch das richtige Ergebnis, auch mit der Berechnung diverser Calculatoren (z.B. https://www.lammertbies.nl/comm/info...lculation.html). Jetzt will ich das ganze aber als Hex eingeben, da ich das Ergebnis 0xFD9C brauche.

Ich habe mir schon diverse Seiten und diverse Posts durchgelesen, aber irgendwie stehe ich hier komplett auf dem Schlauch, wie meine Eingabe für den CRC Algorithmus aussehen muss. Welche Anpassungen muss ich denn vornehmen?

Ich wäre für Hilfe / Tipps sehr dankbar.

Gruß
Zero

[himitsu]

Wieso liefert deine Funktion immer Result als 0?
> Eine Prozedur oder den CRC als Result.

Wieso ist dein Wert 32 Bit (Int32) und keine 16 Bit?

Und vor allem: Warum wird Value bzw. crc nirgendwo initialisiert?

Zitat:

Delphi-Quellcode:

for i:=0 to Length(Command) do

Schalte in deinen Projektoptionen mal die Indexprüfung an und frage dich, ob die 0 wirklich stimmt.

Ich würde Command[i] vor der inneren Schleife in eine Variable (Byte) kopieren und dann damit arbeiten, anstatt Command zu verändern.

Und da es immer nur ASCII EASCII bzw. ANSI ist, würde ich auch einen AnsiString als Parameter verwenden.

Zitat:

Jetzt will ich das ganze aber als Hex eingeben, da ich das Ergebnis 0xFD9C

Dann mußt du eben vorher den String "020D000A413068656C6C6F" als HEX betrachten, also erstmal jeweils zwei Zeichen in ein Char konvertieren.
Manuell (selber Zeichen für zeichen)
oder z.B. HexToBin in einen AnsiString passender Länge.

Oder noch einen Parameter isHEX in deine Funktion/Prozedur
und dann statt ein Zeichen zu nehmen (Ord), jeweils zwei Zeichen nehmen, sie von Hex nach Byte umwandeln und dann damit den CRC berechnen.

[Sherlock]

Du mußt die Zeichen als Hex angeben. Und String ist nunmal etwas anderes. In Delphi kannst Du das zB tun, indem Du einfach die Anführungszeichen um den String entfernst und die Zeichen per Raute als Hex identifizierst. Dann noch per Plus-Zeichen konkatenieren. Also zB. so:

Delphi-Quellcode:

command := #02+#0D+#00+#0A+#41+#30+#68+#65+#6C+#6C+#6F;

Sherlock

[Zer0ne]

Danke für eure Rückmeldungen.

@Sherlock:
Ich hätte erwähnen sollen, dass ich mit Lazarus und FPC programmiere. Deine Variante funktioniert hier an der Stelle so leider nicht.

@himitsu:

Zitat:

Wieso ist dein Wert 32 Bit (Int32) und keine 16 Bit?

Puh gute Frage. Habe ich mir so keine Gedanken darüber gemacht.

Zitat:

Warum wird Value bzw. crc nirgendwo initialisiert?

Sorry, die Zeile mit der Initialisierung von crc hatte ich nicht hinzugefügt:

Code:

crc         := 0;

Zitat:

Oder noch einen Parameter isHEX in deine Funktion/Prozedur
und dann statt ein Zeichen zu nehmen (Ord), jeweils zwei Zeichen nehmen, sie von Hex nach Byte umwandeln und dann damit den CRC berechnen.

Meintest du das so in etwa?

Code:

function CalcCRC2(Command: String; var Value: Int32): Integer; 
var i,j : Integer;
  bytecrc : Byte;
begin
  Result := 0;
  for i:=Start to Length(Command) div 2 do
  begin
    bytecrc := HexInByte(MidStr(command, i*2, 2));
    for j:=0 to 7 do
    begin
      if ((bytecrc and $01) XOR (Value And $0001) <> 0) then
        Value := (Value shr 1) XOR $A001
      else
        Value := Value shr 1;
      bytecrc := bytecrc shr 1;
    end;
  end;
end;

Leider kommt so immer noch etwas falsches heraus ($4D14).

[himitsu]

Zitat:

Zitat von Sherlock (Beitrag 1398560)

Du mußt die Zeichen als Hex angeben.

Und dann bei Chars $A0, $A8 und paar Anderen ab $F0 könnte er sich wundern, wenn die wegen ANSI<>Unicode nicht das sind was sie sein sollten. -> konvertierte Codepage

UND

Delphi-Quellcode:

#$02+#$0D+...

Zitat:

Deine Variante funktioniert hier an der Stelle so leider nicht.

Keine Sorge, in Delphi geht das auch so nicht.

[himitsu]

Zitat:

Delphi-Quellcode:

MidStr(command, i*2

Das Selbe wie vorhin auch schon.

In Pascal/Delphi fangen Strings bei 1 an. (außer in den neueren Delphis, wo ARC mit reinpfuscht)

[gammatester]

Zitat:

Zitat von Zer0ne (Beitrag 1398562)

Code:

function CalcCRC2(Command: String; var Value: Int32): Integer; 
var i,j : Integer;
  bytecrc : Byte;
begin
  Result := 0;
  for i:=Start to Length(Command) div 2 do
...

Leider kommt so immer noch etwas falsches heraus ($4D14).

Wo ist denn Start deklariert/belegt?

[p80286]

Zunächst, warum nimmst Du nicht das Beispiel aus der Wikipedia?

Zitat:

CRC-16 Implementierung in der Programmiersprache Pascal/Delphi

Das folgende Pascal Programm berechnet einen CRC-16-Wert über ein Array of Byte und gibt diese aus:

const
Mask: Word = $A001;

var
CRC: Word;
N, I: Integer;
B: Byte;

begin
CRC := $FFFF;
for I := Low(Buffer) to High(Buffer) do
begin
B := Buffer[I];
CRC := CRC xor B;
for N := 1 to 8 do
if (CRC and 1) > 0 then
CRC := (CRC shr 1) xor Mask
else
CRC := (CRC shr 1);
end;
Showmessage(IntToHex(CRC, 4)); (* Ausgabe *)
end;

Und was verstehst Du unter HexEingabe?

Gruß
K-H

Wieso eigentlich ein String als Eingabe? der CRC-Wert wird über eine mehr oder weniger große Anzahl Bytes gebildet.

[Sherlock]

Zitat:

Zitat von himitsu (Beitrag 1398563)

Zitat:

Zitat von Sherlock (Beitrag 1398560)

Du mußt die Zeichen als Hex angeben.

Und dann bei Chars $A0, $A8 und paar Anderen ab $F0 könnte er sich wundern, wenn die wegen ANSI<>Unicode nicht das sind was sie sein sollten. -> konvertierte Codepage

UND

Delphi-Quellcode:

#$02+#$0D+...

Zitat:

Deine Variante funktioniert hier an der Stelle so leider nicht.

Keine Sorge, in Delphi geht das auch so nicht.

Ja, verdammt noch eins, ich sollte lieber ausprobieren, was ich so blubbere :oops:

Sherlock

[KodeZwerg]

Ich habe mal ein gebastelt, ausgehend von den vorliegenden Beispiel ist dies dabei rausgekommen:

Delphi-Quellcode:

unit uCRC16;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls;

type
  TForm1 = class(TForm)
    LabeledEdit1: TLabeledEdit;
    LabeledEdit2: TLabeledEdit;
    Button1: TButton;
    Button2: TButton;
    OpenDialog1: TOpenDialog;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

Function CalcCRC16(const Buffer: array of byte) : Word;
const
  Mask: Word = $A001;
var
  CRC: Word;
  N, I: Integer;
  B: Byte;
begin
  CRC := $FFFF;
  for I := Low(Buffer) to High(Buffer) do
  begin
    B := Buffer[I];
    CRC := CRC xor B;
    for N := 1 to 8 do
     if (CRC and 1) > 0 then
      CRC := (CRC shr 1) xor Mask
     else
      CRC := (CRC shr 1);
  end;
  Result := CRC;
  // Result := (IntToHex(CRC, 4)); (* Ausgabe *)
end;

function FileCRC16(const FileName: string; var CRC16: Word; StartPos: Int64 = 0;
  Len: Int64 = 0): Boolean;
const
  csBuff_Size = 4096;
type
  TBuff = array[0..csBuff_Size - 1] of Byte;
var
  Handle: THandle;
  ReadCount: Integer;
  Size: Int64;
  Count: Int64;
  Buff: TBuff;
begin
  Handle := CreateFile(PChar(FileName), GENERIC_READ,
    FILE_SHARE_READ, nil, OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL, 0);
  Result := Handle <> INVALID_HANDLE_VALUE;
  if Result then
  try
    Int64Rec(Size).Lo := GetFileSize(Handle, @Int64Rec(Size).Hi);
    if Size < StartPos + Len then
    begin
      Result := False;
      Exit;
    end;
    if Len > 0 then
      Count := Len
    else
      Count := Size - StartPos;
    CRC16 := not CRC16;
    SetFilePointer(Handle, Int64Rec(StartPos).Lo, @Int64Rec(StartPos).Hi, FILE_BEGIN);
    while Count > 0 do
    begin
      if Count > SizeOf(Buff) then
        ReadCount := SizeOf(Buff)
      else
        ReadCount := Count;
      ReadFile(Handle, Buff, ReadCount, LongWord(ReadCount), nil);
      CRC16 := CalcCRC16(Buff);
      Dec(Count, ReadCount);
    end;
    CRC16 := not CRC16;
  finally
    CloseHandle(Handle);
  end;
end;


// Hier wird CRC16 einer Datei Berechnet
procedure TForm1.Button1Click(Sender: TObject);
var
  CRC16: Word;
begin
  CRC16 := 0;
  if OpenDialog1.Execute then
   begin
    if FileCRC16(OpenDialog1.FileName, CRC16) then
    LabeledEdit2.Text := (IntToHex(CRC16, 4));
   end;
end;


// Hier wird CRC16 eines Strings Berechnet
procedure TForm1.Button2Click(Sender: TObject);
var
  s: String;
  buff: packed array of byte;
  i: Integer;
begin
  s := LabeledEdit1.Text;
  SetLength(buff, Length(s));
  for i := 0 to (Length(s))-1 do buff[i] := Byte(Ord(s[i+1]));
  LabeledEdit2.Text := (IntToHex(CalcCRC16(buff), 4));
end;

end.

Aber meine Datei-CRC Methode ist glaube ich fehlerhaft an dieser Stelle hier "CRC16 := CalcCRC16(Buff);"
Irgendwie hab ich da noch einen Logik-Fehler drinn, komm grad nur nicht drauf wie ich ihn behebe, momentan wird immer eine neue crc16 gegeben ohne die alte zu berücksichtigen.

[p80286]

Zitat:

Zitat von Sherlock (Beitrag 1398600)

Ja, verdammt noch eins, ich sollte lieber ausprobieren, was ich so blubbere :oops:

Mit einen Shortstring hätte es funktioniert, aber nur für 255 Byte :stupid:

Irgendjemand hat hier vor einiger Zeit geschrieben "Vergewaltigung eines Strings", recht hat er!

Gruß
K-H

[gammatester]

Zitat:

Zitat von KodeZwerg (Beitrag 1398606)

Aber meine Datei-CRC Methode ist glaube ich fehlerhaft an dieser Stelle hier "CRC16 := CalcCRC16(Buff);"
Irgendwie hab ich da noch einen Logik-Fehler drinn, komm grad nur nicht drauf wie ich ihn behebe, momentan wird immer eine neue crc16 gegeben ohne die alte zu berücksichtigen.

Du berechnest ja immer nur den CRC des letzten Blocks. Deine CRC-Routine braucht CRC als var parameter. Aufruf dann mit CRC16.
Initialisiert wird extern mit CRC16:=$FFFF.

[Zer0ne]

Zitat:

Zitat von Sherlock (Beitrag 1398600)

Zitat:

Zitat von himitsu (Beitrag 1398563)

Zitat:

Zitat von Sherlock (Beitrag 1398560)

Du mußt die Zeichen als Hex angeben.

Und dann bei Chars $A0, $A8 und paar Anderen ab $F0 könnte er sich wundern, wenn die wegen ANSI<>Unicode nicht das sind was sie sein sollten. -> konvertierte Codepage

UND

Delphi-Quellcode:

#$02+#$0D+...

Zitat:

Deine Variante funktioniert hier an der Stelle so leider nicht.

Keine Sorge, in Delphi geht das auch so nicht.

Ja, verdammt noch eins, ich sollte lieber ausprobieren, was ich so blubbere :oops:

Sherlock

Ich habe noch etwas herum probiert und, ja vermutlich mache ich noch mehr als genug falsch -.- aber mir der Variante

Zitat:

Delphi-Quellcode:

#$02+#$0D+...

funktioniert es! Da erhalte ich den richtigen CRC Wert heraus.

Jetzt habe ich aber z.B. durch vorhergehende Schritte z.B. einen String

Zitat:

command := '020D000A413068656C6C6F';

. Nur wie wandele ich den jetzt um, dass ich genau die oben beschriebene Form

Zitat:

Delphi-Quellcode:

#$02+#$0D+...

erhalte?

Ja, ich weiß es ist eine String-Vergewaltigung, aber es erscheint zur Zeit für mich die sinnvollste Lösung für mein Problem...

[KodeZwerg]

Ich habe mal die String-Nach-CRC16 überarbeitet aber bekomme dennoch andere Ergebnisse.

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  s: String;
  buff: packed array of byte;
  i: Integer;
begin
  case RadioGroup1.ItemIndex of
   0: begin // Input ist String
       s := LabeledEdit1.Text;
       SetLength(buff, Length(s));
       for i := 0 to (Length(s))-1 do buff[i] := Byte(Ord(s[i+1]));
       LabeledEdit2.Text := (IntToHex(CalcCRC16(buff), 4));
      end;
   1: begin // Input ist Hex-Kette als String (Beispiel 020D000A413068656C6C6F)
       s := LabeledEdit1.Text;
       SetLength(buff, Length(s) div 2);
       for i := 0 to (Length(s) div 2)-1 do
        buff[i] := Byte(StrToInt('$'+s[i*2+1]+s[i*2+2]));
       LabeledEdit2.Text := (IntToHex(CalcCRC16(buff), 4));
      end;
  end;
end;

für String "020D000A413068656C6C6F" erhalte ich "A881" und als Hex-Kette kommt "199A" raus.
Bestimmt mach ich irgendwo noch mehr falsch. :-(

[Edit]
Ob Hex-Kette überhaupt funktioniert hab ich so getestet
In meine String-Eingabe entweder Wert "1" oder "31", als String oder als Hex, beides resultiert in "947E"
[/Edit]

[Zer0ne]

Zitat:

Zitat von KodeZwerg (Beitrag 1398615)

für String "020D000A413068656C6C6F" erhalte ich "A881" und als Hex-Kette kommt "199A" raus.
Bestimmt mach ich irgendwo noch mehr falsch. :-(

Ich glaube an der Stelle ist der Fehler, dass die Zeichen einzeln betrachtet werden und nicht als Paare, wie sie gedacht sind -> #02#0D.... (hier aber #0#2#0#D...) oder irre ich mich?

[KodeZwerg]

Dafür ist doch das "Case" gedacht, entweder Zeichenweise oder Paarweise als Hex-Wert.

[Zer0ne]

Hast du den korrekten Start?

Zitat:

CRC := $0000;

Weil bei einem deiner vorherigen Posts stand noch

Zitat:

CRC := $FFFF;

Mit der 0 als Startwerte funktioniert es jetzt endlich :-D

[KodeZwerg]

Ich hatte mich da an das gepostete Beispiel für "So und nicht anders" gehalten, da stand's halt mit $FFFF definiert und ja Du hast recht, so bekomme ich in beiden Cases das korrekte Ergebniss, freut mich das nun alles klappt.
Das mit der Datei ist ja egal, war nur so ein Nebendingens.

[Zer0ne]

Auf jeden Fall, vielen Dank an alle, die versucht haben zu helfen.

Wer weiß, wie lange ich da sonst noch daran gehängt hätte. :-)

[KodeZwerg]

Ich sollte noch anmerken, der Code enthält keine Fehlerbehandlung, also auf Input-Korrektheit sollte entweder im Vorfeld oder in meinem Beispiel Code ergänzt werden, Ansätze hätte man ja, Code kann auch noch gekürzt werden, momentan alles ausführlich zum Testen.

[KodeZwerg]

Hier nochmal eine leicht abgeänderte Variante in der hoffentlich der Datei-Modus korrekt arbeitet aber irgendwie dennoch nicht. Ich komme da nicht weiter. Für die CalcCRC16() wird nun zum Puffer auch noch ein Startwert übergeben. Ob nun $0000 oder $FFFF korrekt ist kann ich noch nicht sagen, so kann jeder bei Laufzeit selbst bestimmen, ich brauch's Hauptsächlich wegen der Datei-Funktion.

Delphi-Quellcode:

unit uCRC16;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls;

type
  TForm1 = class(TForm)
    LabeledEdit1: TLabeledEdit;
    LabeledEdit2: TLabeledEdit;
    Button1: TButton;
    Button2: TButton;
    OpenDialog1: TOpenDialog;
    RadioGroup1: TRadioGroup;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

Function CalcCRC16(const Buffer: array of byte; inCRC16: Word) : Word;
const
  Mask: Word = $A001;
var
  N, I: Integer;
  B: Byte;
begin
  for I := Low(Buffer) to High(Buffer) do
  begin
    B := Buffer[I];
    inCRC16 := inCRC16 xor B;
    for N := 1 to 8 do
     if (inCRC16 and 1) > 0 then
      inCRC16 := (inCRC16 shr 1) xor Mask
     else
      inCRC16 := (inCRC16 shr 1);
  end;
  Result := inCRC16;
end;

function FileCRC16(const FileName: string; var CRC16: Word; StartPos: Int64 = 0;
  Len: Int64 = 0): Boolean;
const
  csBuff_Size = 4096;
type
  TBuff = array[0..csBuff_Size - 1] of Byte;
var
  Handle: THandle;
  ReadCount: Integer;
  Size: Int64;
  Count: Int64;
  Buff: TBuff;
begin
  Handle := CreateFile(PChar(FileName), GENERIC_READ,
    FILE_SHARE_READ, nil, OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL, 0);
  Result := Handle <> INVALID_HANDLE_VALUE;
  if Result then
  try
    Int64Rec(Size).Lo := GetFileSize(Handle, @Int64Rec(Size).Hi);
    if Size < StartPos + Len then
    begin
      Result := False;
      Exit;
    end;
    if Len > 0 then
      Count := Len
    else
      Count := Size - StartPos;
    CRC16 := not CRC16;
    SetFilePointer(Handle, Int64Rec(StartPos).Lo, @Int64Rec(StartPos).Hi, FILE_BEGIN);
    while Count > 0 do
    begin
      if Count > SizeOf(Buff) then
        ReadCount := SizeOf(Buff)
      else
        ReadCount := Count;
      ReadFile(Handle, Buff, ReadCount, LongWord(ReadCount), nil);
      CRC16 := CalcCRC16(Buff, CRC16);
      Dec(Count, ReadCount);
    end;
    CRC16 := not CRC16;
  finally
    CloseHandle(Handle);
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  CRC16: Word;
begin
  CRC16 := 0;
  if OpenDialog1.Execute then
   begin
    if FileCRC16(OpenDialog1.FileName, CRC16) then
    LabeledEdit2.Text := (IntToHex(CRC16, 4));
   end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  s: String;
  buff: packed array of byte;
  i: Integer;
begin
  case RadioGroup1.ItemIndex of
   0: begin
       s := LabeledEdit1.Text;
       SetLength(buff, Length(s));
       for i := 0 to (Length(s))-1 do buff[i] := Byte(Ord(s[i+1]));
       LabeledEdit2.Text := (IntToHex(CalcCRC16(buff, Word($0000)), 4));
      end;
   1: begin
       s := LabeledEdit1.Text;
       SetLength(buff, Length(s) div 2);
       for i := 0 to (Length(s) div 2)-1 do
        buff[i] := Byte(StrToInt('$'+s[i*2+1]+s[i*2+2]));
       LabeledEdit2.Text := (IntToHex(CalcCRC16(buff, Word($0000)), 4));
      end;
  end;
end;

end.