CRC berechnet + Problem

Also mit einem einem Generatorpolynom mit 12 Bits bekommt man 11 Bits 
raus.
Ich habe:

1100'0000'0001'1000'1010'   011'1001'0101'

Die letzen 11 Bits sind der Rest der Polynomdivision.

Also ausführlicher:

Ein CRC Polynom mit 12 Stellen (x^11 ... x^0) lässt im Worst-Case (also 
x^10 : 1^11) ein x^10 stehen (Rest) Somit hat ein Generatorpolynom mit 
12 Bits einen Rest von maximal 11 Bits. Falls weniger wird mit nullen 
aufgefuellt.

Eine Probe kannst du machen indem du die Polynomdivison machst und dann 
0 rauskommt.

Deine CRC ist m.E. jedoch falsch da das MSB bei dir gesetzt ist. (Wie 
schon oben erwaehnt wird im "Worst-Case" das MSB (11 Bit) zu 1)

Irgendwas scheine ich falsch zu machen. Hier mal das Wiki Beispiel:
Ich verstehe nicht wie man auf die 0 0 0 0 0 kommt (mit Pfeil markiert).
Ich dachte es wird immer durch das Generator Polynom dividiert.

Frame:          1 1 0 1 0 1 1 0 1 1
Generator:      1 0 0 1 1
Frame 0-Bits:   1 1 0 1 0 1 1 0 1 1 0 0 0 0

Division:

    1 1 0 1 0 1 1 0 1 1 0 0 0 0  /  1 0 0 1 1  =  1 1 0 0 0 0 1 0 1 0
    1 0 0 1 1 ------------------------------------+ | |             |
    ---------                                       | |             |
      1 0 0 1 1                                     | |             |
      1 0 0 1 1 ------------------------------------+ |             |
      ---------                                       |             |
        0 0 0 0 1                                     |             |
->      0 0 0 0 0 ------------------------------------+    . . .    |
        ---------                                                   |
          0 0 0 1 0                                                 |
          0 0 0 0 0                                                 |
          ---------                                                 |
            0 0 1 0 1                                               |
            0 0 0 0 0                                               |
            ---------                                               |
              0 1 0 1 1                                             |
              0 0 0 0 0                                             |
              ---------                                             |
                1 0 1 1 0                                           |
                1 0 0 1 1                                           |
                ---------                                           |
                  0 1 0 1 0                                         |
                  0 0 0 0 0                                         |
                  ---------                                         |
                    1 0 1 0 0                                       |
                    1 0 0 1 1                                       |
                    ---------                                       |
                      0 1 1 1 0                                     |
                      0 0 0 0 0 ------------------------------------+
                      ---------
                        1 1 1 0  =  Rest

Diese Methode ist IMO kompliziert und unnoetig umstaendlich. Diese 0000 
Die die jedes mal drunterschreiben ist sinnlos. Schneller und einfach 
zeigt das erste Beispiel auf Wikipedia.

Generell kann man es so sagen:

- Man will die 'linkeste' 1 wegbekommen.
-> Dazu stellt man das generatorpolynom unter diese eins und mittels 
eines XOR wird dann die zu 0.
-> nun geht man wieder zur 'linkesten' 1 usw...
- So lange bis man das generatorpolynom nicht mehr drunterschreiben kann 
(es fehlen die bits) und man hat den rest...

Ich habe vorher was falsch gemacht. Jetzt nochmal berechnet..aber stimmt 
immernoch nicht mit deinem überein.
Kannst du mal gucken? (Anhang)

Danke!

Jop kann kein Fehler erkennen. Dann is meins wohl falsch.. ;)

offensichtlich machen wir beide was falsch.

Die Musterlösung sagt 101'1111'1011 als CRC.

Es soll auch falsche Musterlösungen geben.

wie lautet denn die genaue aufgaben? Nicht das da noch ein 
"descending/ascending order" Fehler drin ist. Muss man Endianess 
beachten, etc?

Also ich hatte da auch immer meine Qual mit dem CRC.
Aber bei RENESAS RC8 ist ein pdf .
Mit C-Source u.
Das hat mir sehr geholfen.

Hallo!
da Ganze gehört dem Header-CRC vom Flexray Frame (siehe Anhang).
Es sind also folgende Daten CRC geschützt:
Sync Bit + Startup Bit + Frame ID + Payload Länge

Im aktuellen Beispiel:
Sync Bit=1
Startup Bit=1
Frame ID=3
Payload Länge=10

Header CRC: 0x5FB = 101.1111.1011 (so soll er sein, damit läuft das 
System auch)

Mehr darüber sagt mir nichtmal die Flexray Spezifikation.

Ist es nich beim CAN ähnlich, eine CRC ..aber die wird ja wohl vom 
Controller berechnet.

Ja müsst alles passen. Hab auch grad mein Flexray Reference Chart 
angeguckt und stimm dir zu.

Jetzt ist nur die Frage ob man nicht die Header Bits alle umdrehen muss 
und darüber den CRC laufen lässt. Das ist nur geraten, könnte es mir 
aber evtl. vorstellen da CRC normal über ein Schieberegister realisiert 
wird und die "linken" Bits ja zuerst auf den Bus kommen.

Bin jetzt zu faul auszurechnen was da für ein CRC-Rest rauskommt.

Wie gesagt, ist nur geraten...

wa smir noch aufgefallen ist:
In der Spez.2.1 steht das CRCPolynom so:
x^11 + x^9 + x^8 + x^7 + x^2 + 1 = 101110000101

mit diesem habe ich auch gerechnet (siehe oben).

Aber dann steht weiter im Text:
Header CRC Polynom (hexadecimal) = 0x385 = 1110000101
was einem ganz anderen Polynom entspricht.
Bin etwas verwirrt... (habe auch mit diesem Polynom gerechnet..ebenso 
Mist rausgekommen)

in der Doku steht noch dies:
The initialization vector of the register used to generate the header 
CRC shall be 0x01A.

Weis jemand damit was anzufangen?

Lies dir doch nochmal den Wikipedia Artikel ganz durch. Da steht was 
davon. Bzw. mach dich auch mit den Links schlau... Ich weis es grad auch 
net, aber dazu findest du bestimmt was im Netz.

Hat vielleicht jemand den Quelcode zu dem CRC-11 Algorithmus?
Hab jetzt Stundenlang aufm Blatt Papier rumgerechnet. Hab auch 0x01A als 
Initialisierung für den Register verwendet, es kommt aber trotzdem nicht 
der Sollwert raus.