CRC Prüfung

xX Dany Xx

Ja genau das habe ich auch schon gefunden.. da steht aber nur wie man das rechnet.. und das weiß ich ja.. aber wie programmiert man das in C?

Das mit dem XOR ist nur für die Bestimmung des Sendepolynoms, diesen Part macht mein anderer Kollege ich muss nur die Überprüfung des Sendepolynoms machen.. also ab der Stelle:

Diese Nachricht kann jetzt z. B. über ein Netzwerk übertragen werden. Wenn die Nachricht beim Empfänger eintrifft, kann dieser überprüfen, ob sie korrekt angekommen ist.

Und dann gibts nur 2 Fälle:
1. Der Rest der Division ist null und die Nachricht ist richtig!
2. Der Rest der Division ist ungleich null und die Nachricht ist fehlerhaft!

Aber wie soll ich die Modulo-Rechnung der Dualzahlen programmieren? Das ist halt die Frage...

volkard

xX Dany Xx schrieb:

Aber wie soll ich die Modulo-Rechnung der Dualzahlen programmieren? Das ist halt die Frage...

Mach mal ein Beispiel mit konkreten Zahlen. Und dann setzt das einer von hier nach C um.

xX Dany Xx

Hab ich doch schon! Also..

Eingabe p (Dualzahl) .. ist z.B. 101110011001
Eingabe q (Dualzahl) .. ist z.B. 10011

dann p modulo q = rest ... in unserem Beispiel 101110011001 modulo 10011 = 0

Das wars! Mehr will ich nicht...

Ich würde das ja so programmieren nur wenn ich es so hinschreibe, dann rechnet er logischerweise 101 milliarden 110 millionen 11 tausend 1 (MODULO) 10 tausend 11 = irgendetwas was ich nicht brauche ....

xX Dany Xx schrieb:

dann p modulo q = rest ... in unserem Beispiel 101110011001 modulo 10011 = 0

Da bin ich ausgestiegen. Du hast doch oben schon nachgewiesen, dass da 5 als Rest bleibt. Und der Rest beim Dividieren ist natürlich in jedem Zahlensystem der gleiche, wie kommst du auf 0?

xX Dany Xx

Ja offenbar nicht..

101110011001 : 10011 = irgendwas (unwichtig)
10011
-----
0010000
  10011
  -----
  00011110
     10011
     -----
     011010
      10011
      -----
      010011
       10011
       -----
       00000 <- Rest = 0

Aber 2969 : 19 = 156 Rest 5 bzw. 2969 modulo 19 = 5

Und jetzt?

xX Dany Xx schrieb:

Und jetzt?

irgendwas (unwichtig) bestimmen, die Probe machen, den Fehler finden, Weihnachten feiern.

xX Dany Xx

Was?

Da ist kein Fehler man... das ist richtig.. das ist en Beispiel von nem Prof .. also das mit den Dualzahlen, ich hab das dann in Dezimal umgerechnet, weil rüdiger gemeint hat ich soll das in ein anderes Zahlensystem umwandeln, aber wie ihr seht kommt nicht das gleiche raus..

Das Programm muss das so mit den Dualzahlen rechnen... vielleicht irgenwas mit shiften oder so???

Ich muss das bis Silvester abgeben..

xX Dany Xx schrieb:

Das Programm muss das so mit den Dualzahlen rechnen... vielleicht irgenwas mit shiften oder so???

More question marks than sanity dictates? Überleg mal: Prozessoren arbeiten mit Worten, die beim Zahlenrechnen sowieso schon als Binärzahlen interpretiert werden müssen. Ein Computer kann deshalb nur mit Dualzahlen rechnen. Alles andere ist eine Illusion, die durch Ein- und Ausgabe zustande kommt.

Wenn du eine Zahl aus einem String machen willst, der eine binäre Zahl darstellt, geht das btw am einfachsten so:

#include <stdlib.h>

long zahl;
zahl = strtol("1010101", NULL, 2);

xX Dany Xx schrieb:

das ist richtig.. das ist en Beispiel von nem Prof

Nego consequentiam.

Ich kann mich auch irren, aber solange du zu faul bist, auch nur die Probe zu machen, rechne ich das sicher nicht nach.

Genmutant

Nachdem es völlig egal ist, in welchem Zahlensystem man rechnet, solange man es *richtig* macht, stimmt als Ergebnis für den Rest natürlich 5. Dein schriftliches Teilen ist einfach völlig falsch. Hast du schonmal schriftlich geteilt...?

denke das sind xor ops und dann ist da beim flüchtigen überlesen kein fehler?

Ich kann mich auch irren, aber solange du zu faul bist, auch nur die Probe zu machen, rechne ich das sicher nicht nach.

Ach was soll's, es ist Weihnachten:

10011100 * 10011
        ---------
   10011100
    10011100
-----------------
101110010100

Das Ergebnis der Probe ist 101110010100, also 2964, das sind genau 5 zuwenig, und 5 ist der Rest. Was zu beweisen war.

Glaubst du uns jetzt?

also so komm ich auch auf 0

#include <stdio.h>
#include <stdlib.h>

int findFirstBitSet(int i){
	int x = 32;
	while(x--){
		if(i & 1<<x)
			return x;
	}
	return -1;
}

int main(void) {
	unsigned int a = 0xB99;//101110011001
	unsigned int b = 0x13;//10011
	unsigned int firstBit = 0x80000000;
	int dataBits = 12;
	unsigned int c = 0;

	a<<=31-findFirstBitSet(a);
	b<<=31-findFirstBitSet(b);

	c=a^b;
	while(dataBits--){
		if(c&firstBit){
			c^=b;
		}else
			c<<=1;
	}
	printf("%x",c);

	return 0;
}

endlich mal was ums durch den compiler zu jagen...

lg lolo

noobLolo schrieb:

endlich mal was ums durch den compiler zu jagen...

Ich bin ein schwacher Hacker, weil mir manche Dinge mit Stift und Papier am leichtesten fallen. Nachdem ich aber im Vorraus bewiesen habe, dass dein Programm fehlerhaft ist, wirst du mir wohl verzeihen, dass ich den Fehler nicht suche, oder?

wäre also laut deiner rechnung

869%53=21

richtig?

xX Dany Xx

Cool cool noobLolo

Also ich hab das noch mit nem anderen Beispiel probiert mit 1010011 modulo 1011 = 0 ... also ich hab für a = 0x53; b = 0xB; dataBits = 7 ... und es kam auch 0 raus

Das war die Gute Nachricht... dann wollte ich 1010111 modulo 1011 = 100 rechnen..
also habe ich für a = 0x57; b = 0xB; dataBits = 7 und da kommt dann aber raus 60000000 .. okay gut das scheint falsch zu sein, aber das ist mir egal..

Es geht nur darum kannst du mir garantieren, dass wenn 0 rauskommen soll, kommt auch 0 raus? Weil sonst wenn was falsches rauskommt, ich mach eh if (rest!=0) return (0) .. weißt du was ich mein?

Aber du hast auf jeden schon Mal begriffen was ich will..

noopLolo schrieb:

wäre also laut deiner rechnung

869%53=21

richtig?

Wenn du mir die Operationen sagst, für die die Striche stehen, kann ich mal drüber nachdenken.

xX Dany Xx

XOR

z. 17

int dataBits = findFirstBitSet(a)-1;
statt
int dataBits = 12;

machts etwas besser... ob das dann save ist kann ich nicht sagen...

xX Dany Xx

Ich glaube wenn du nicht int dataBits = findFirstBitSet(a)-1 machst,
sonder int dataBits = findFirstBitSet(a)-2 dann stimmts .. dann kommt nämlich auch die 4 raus bzw. 100 (binär)

Bei dem Beispiel 1010111 modulo 1011 = 100 ... a = 0x57; b = 0xB;

Kann das sein?

Edit 1:
Ne aber egal... kannst du das nun irgendwie auch so schreiben, dass der Benutzer das a und b als Dualzahl eingibt?

nee das ergebnis ist eigentlich immer "falsch" also wenn normal ne 0x1 rauskommt bekommst ne 0x80000000 oder so ähnlich

normal 0b0000000000000000000000000000001
anders 0b1000000000000000000000000000000

das sind so viele nullen aber ich denke das passt scho weiteres beispiel

normal 0b0000000000000000000000000001101
anders 0b1101000000000000000000000000000

denk ich zumindest kannst es ja mal checken und uns bescheid geben obs so ist.