CRC Byteweise

[sim (Gast)]

Hallo zusammen.

Ich hätte da mal eine Frage bezüglich der CRC-Prüfung. Ich bekomme Daten 
Byteweise geliefert und schreibe sie Byte für Byte in meinen Ram auf dem 
FPGA. Die Daten Enden mit einem 16Bit CRC.
Wie kann ich nun sozusagen on the fly meinen CRC Prüfung machen, ohne 
die Daten bitweise durch ein Schieberegister zu schieben. Es muss doch 
die Möglichkeit geben, immer das aktuell angekommene Byte zu verrechnen 
und dann wenn alles im Ram steht bleibt Null übrig. Irgendwie so hatte 
ich mir das gedacht. Geht das?

Danke schonmal!

[guest (Gast)]

ja, das geht
mache ich auch so. ;-)

[sim (Gast)]

Und Wie (-:

[sim (Gast)]

guest schrieb:
> ja, das geht
>
> mache ich auch so. ;-)

Es würde mir sehr helfen wenn du mir sagen könntest wie du das machst. 
(-:
Bitte.

[... (Gast)]

Mit einer Tabelle.

[sim (Gast)]

Ok, könntest du es etwas ausführlicher beschreiben?

[Volker Z. (vza)]

Du könntest auch in diesem Forum nach CRC suchen.
Ja, Du bist nicht der Erste der das Fragt!

[Jan M. (mueschel)]

Ja, das funktioniert so wie du das beschrieben hast. Am einfachsten 
lässt du dir den benötigten VHDL-Code automatisch generieren, dafür gibt 
es mehrere Online-Tools. Google am besten mal nach "vhdl crc generator".

[sim (Gast)]

Jan M. schrieb:
> Ja, das funktioniert so wie du das beschrieben hast. Am einfachsten
>
> lässt du dir den benötigten VHDL-Code automatisch generieren, dafür gibt
>
> es mehrere Online-Tools. Google am besten mal nach "vhdl crc generator".

Bei google findet man viel. Aber nichts konkretes, leider. Ich will/muss 
das selber schreiben.
Wenn jemand einen Link hätte wie es funktioniert wäre ich ja schon 
zufrieden.

[sim (Gast)]

crc_c(0) <= data(0) XOR data(1) XOR crc_i(8) XOR crc_i(9); 
crc_c(1) <= data(0) XOR data(2) XOR crc_i(10) XOR crc_i(8); 
crc_c(2) <= data(0) XOR data(3) XOR crc_i(11) XOR crc_i(8); 
crc_c(3) <= data(0) XOR data(4) XOR crc_i(12) XOR crc_i(8); 
crc_c(4) <= data(0) XOR data(5) XOR crc_i(13) XOR crc_i(8); 
crc_c(5) <= data(0) XOR data(6) XOR crc_i(14) XOR crc_i(8); 
crc_c(6) <= data(0) XOR data(7) XOR crc_i(15) XOR crc_i(8); 
crc_c(7) <= data(0) XOR crc_i(8); 
crc_c(8) <= data(0) XOR crc_i(0) XOR crc_i(8); 
crc_c(9) <= data(0) XOR crc_i(1) XOR crc_i(8); 
crc_c(10) <= data(0) XOR crc_i(2) XOR crc_i(8); 
crc_c(11) <= data(0) XOR crc_i(3) XOR crc_i(8); 
crc_c(12) <= data(0) XOR crc_i(4) XOR crc_i(8); 
crc_c(13) <= data(0) XOR crc_i(5) XOR crc_i(8); 
crc_c(14) <= data(0) XOR crc_i(6) XOR crc_i(8); 
crc_c(15) <= data(0) XOR crc_i(7) XOR crc_i(8);

etwas in dieser Richtung finde ich öfter. ich weiß aber nicht sicher was 
es damit aufsich hat.

[cfgardiner (Gast)]

Hallo sim,

ich kann folgende Seite empfehlen:
http://www.easics.com/webtools/crctool

Grüße,
Charles

[sim (Gast)]

Die kenne ich schon. Aber Danke.
Wie komme ich auf oben genannte Verknüpfungen? Dazu muss es doch ein 
Vorgehen geben.

[cfgardiner (Gast)]

Hi Sim,

zu dem Ergebnis oben kommt man indem man die acht (für byteweise 
Operation) Einzelschritte aufschreibt und dann boolisch optimiert. Die 
Faktoren 1 bis 7 werden als Ableitung von Zustand 0 formuliert.

Es ist im Wesentlichen nur eine Fleissarbeit. In meinem Siemens Leben, 
vor ungefähr 10 Jahren, hatte ich einen pfiffigen Diplomand aus 
Frankreich, der das in ein Paar Tagen samt Simulation hingebracht hat. 
Sein Text habe ich aber leider nicht mehr.

Wenn Du es lieber direkt in VHDL schreibst, würde ich zunächst das 
Polymon für Bitweis als Funktion schreiben. Dann, pro Taktzyklus die 
Funktion in einer 'for i in 0 to 7 loop' Schleife aufrufen. Der 
Rückgabewert der Funktion aus Schritt 'n' ist der Eingabewert für 
Schritt 'n+1'.

Viel Erfolg.

[René D. (Firma: www.dossmatik.de) (dose)]

> Es ist im Wesentlichen nur eine Fleissarbeit. In meinem Siemens Leben,
> vor ungefähr 10 Jahren, hatte ich einen pfiffigen Diplomand aus
> Frankreich, der das in ein Paar Tagen samt Simulation hingebracht hat.
> Sein Text habe ich aber leider nicht mehr.

Man schreibt eine Funktion, die Optimierung macht die Fittersoftware. 
Dann ist es keine Fleißarbeit mehr und der Code wird kürzer und lesbarer 
als diese von Hand optimierten Logikgleichungen.

Hier ein Beispiel für CRC32

--------------------------------------------------------------------

function crc (data_in:std_logic_vector (7 downto 0); crc_value:std_logic_vector(31 downto 0))  return std_logic_vector is

--http://de.wikipedia.org/wiki/Zyklische_Redundanzpruefung
--sehr gutes C Beispiel!!!!!

--G(X)=x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1

variable crc_out: std_logic_vector(31 downto 0);


begin
   crc_out:=crc_value;

  for k in 0 to 7 loop 
    if crc_out(0) /=data_in(k) then
      crc_out:=('0'& crc_out(31 downto 1)) xor X"EDB88320";
    else
      crc_out:=('0'& crc_out(31 downto 1));
    end if;

  end loop;
  return crc_out;

end crc;




--Anwendung im Prozess

if clk'event and clk='1' then
.....
if wr='1' then 

    crc32<=crc(data_in,crc32);  

........

[sim (Gast)]

Ich habe es jetzt anders gelöst.

Wenn es noch jemanden interessiert, es ging um die implementierung des 
MODBUS CRC.
Ich habe jetzt den Implementierungsvorschlag aus "MODBUS over serial 
line specification and implementation guide V1.0" auf Seite 42 genommen 
und diesen in einer vhdl-Funktion umgesetzt. Etwas abgewandelt zwar, 
aber im Prinzip das gleiche. Die Tabellen sind in genanntem Dokument 
bereits gegeben und können direkt verwendet werden.

Vielen Dank für die vielen Vorschläge.
Gruß sim

[Jannulis T. (tembridis)]

Auch wenn du es schon gelöst hast, ich hatte mal ein ähnliches Problem 
und habe dazu diesen Artikel gefunden:

http://www.repairfaq.org/filipg/LINK/F_crc_v3.html

[Johann (Gast)]

Sim kannst Du nicht ein Link zu dem Dokument angeben.

[sim (Gast)]

Johann schrieb:
> Sim kannst Du nicht ein Link zu dem Dokument angeben.


Klar (-:

http://www.modbus.org/docs/Modbus_over_serial_line_V1.pdf