CRC Prüfung

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.

xX Dany Xx

Ne is beides falsch.. also weder -1 oder -2 weil... mit dem ursprünglichen beispiel funzt es dann nicht....

Bei a = 0xB99; b = 0x13; int dataBits = findFirstBitSet(a)-1

kommt dann raus 98000000 ... müsste ja aber 0 sein ..

Edit 1
Dass die Reste umgedreht waren war mir schon klar... aber wie gesagt, das ist eigentlich auch egal. WICHTIG ist nur, dass 0 rauskommt, wenn sie rauskommen soll...

Edit 2
Wieso eigentlich -1? Es muss einfach nur int dataBits = findFirstBitSet(a) heißen und dann kommt in beiden Fällen wieder richtigerweise 0 als Rest raus...
Dann kommt sogar bei dem Beispiel a = 0xB90; b = 0x13 als Rest 48000000 das ist doch ne Hexzahl oder? Wenn man nun 48 (Hex) in binär umrechnet erhält man 1001000, richtig wäre aber 1001 also ohne die letzten bzw. ersten 3 Nullen. Ist das nur Zufall?

also bei mir stimmen die zwischen ergebnisse schon nur dass die schleife entweder zu früh oder zu spät abbricht und damit das end ergebnis verfälscht wird such da noch nach ner lösung wenn ich sie hab kommt sie natürlich wo sonst hier rein;)

Dann kommt sogar bei dem Beispiel a = 0xB90; b = 0x13 als Rest 48000000 das ist doch ne Hexzahl oder? Wenn man nun 48 (Hex) in binär umrechnet erhält man 1001000, richtig wäre aber 1001 also ohne die letzten bzw. ersten 3 Nullen. Ist das nur Zufall?

naja das hab ich im vorletzten post beschrieben und sollte normal sein allerdings steht da nicht umsonst ein noop bzw noob vor dem lolo

xX Dany Xx schrieb:

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?

die rechnung da oben^^ sieht richtig aus. CRC basiert ja auf polynomdivision, die bitmuster sind keine zahlen, bilder oder mp3s, sondern polynome. mit polynomen kann man auch ein bisschen rechnen, z.b. multiplizieren und teilen mit rest. z.b. dieses '10011' da ist nicht 0x13, sondern ein polynom 1*x^4 + 0*x^3 + 0*x^2 + 1*x^1 + 1x^0*. polynomdivision auf dem papier geht ähnlich wie wie schriftliche division mit zahlen, aber nur so ähnlich und das ergebnis ist eben ein rest-polynom und keine zahl.

xX Dany Xx

Ah ja genau.. das stimmt ...

@noobLolo

LoL ^^ ... klar wir machen das schon irgendwie.. Wie gesagt, mir sind die Ergebnisse eigentlich auch egal... Wenn 0 rauskommen soll, kommt sie auch raus und das ist das wichtigste für mich... Jetzt nur noch die Eingabe..

Wie mach ich das mit dem strtol? Z.B. zahl = strtol("10011", NULL, 2);
Wie mach ich das aber, dass der Wert in den Anführungsstrichen (10011) vom Benutzer eingegeben wird? Geht das ganz normal mit scanf? Z.B. scanf ("%d", &wert); ? Wie muss ich dann aber das strtol umändern?

kann mich leider erst wieder bischen später aktiv beteiligen

unsigned int readBinaryNumber(){
	char buffer[40];
	scanf("%32s",buffer);//32 oder 31 bin mir da nicht so sicher
	getchar();
	return strtol(buffer, 0, 2);
}

xX Dany Xx

Ja ich muss jetzt langsam auch los Bald ist Bescherung..

noobLol hast mir wirklich geholfen! Nochmal fettes Dankeschön!!! Ohne Dich wär ich verloren... Ich poste hie rnochmal den Code, dass du das auch siehst, wie ich das benutze...

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

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

int check (int) 
{
    unsigned int a = 0xB99;                   //Sendepolynom
    unsigned int b = 0x13;                    //Generatorpolynom
    unsigned int firstBit = 0x80000000;
    int dataBits = findFirstBitSet(a);
	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;
    }
	if (c==0)
		return 1;
	else
	return 0;
	getch ();
}

int main (void)
{
	int a, b;

	printf ("Cyclic Redundancy Check");

	do
	{
		printf ("\n\nWollen Sie Sendepolynom bestimmen oder \x81 \bberpr\x81 \bfen?");
		printf ("\n1: Bestimmen\n2: \x9A \bberpr\x81 \bfen\n\n");
		scanf ("%d", &a);

		if (a==1 || a==2)
		{
			b=1;
			printf ("\nGut\n");
			if (a==1)
				printf ("Die rechnerische Bestimmung des Sendepolynoms wird nun gestartet...");
			else
				printf ("Die rechnerische \x9A \bberpr\x81 \bfung des Sendepolynoms wird nun gestartet...");
			if (check(1))
				printf ("\n\nDie Information wurde RICHTIG \x81 \bbertragen!");
			else
				printf ("\n\nDie Information wurde FEHLERHAFT \x81 \bbertragen!");
		}
		else
		{
			printf ("\nKeine g\x81 \bltige Eingabe!\nBitte tippen Sie eine 1 oder 2 ein!");
			b=0;
		}
	}
	while (b==0);

	getch();
}

Die Option 1 also die Bestimmung funzt natürlich nicht richtig, da kommt dann die Funktion von meinem Kollegen rein. Und dann muss ich nur noch in den nächsten Tagen das reinarbeiten, was du mir eben geschrieben hast, wie der Benutzer die Zahlen da eingeben kann und dann bin ich fertig...

DANKE !!!

Ich hab's verstanden! Sagt mal: wenn man das mathematisch formuliert, kann man dann sagen, daß man bei solchen Polynom-Dingen ein Zahlensystem mit variabler, nichtnatürlicher Basis verwendet?

µngbd schrieb:

...kann man dann sagen, daß man bei solchen Polynom-Dingen ein Zahlensystem mit variabler, nichtnatürlicher Basis verwendet?

polynome sind exemplare der mathematischen struktur der sogenannten 'ringe'. diese ringe (hat mit 'rund sein' übrigens nix zu tun, der name ist wohl rein willkürlich) haben gewisse eigenschaften und es sind bestimmte rechenoperationen damit möglich. die operationen gelten pro 'ring-klasse' und haben mit solchen anderer ringe nicht viel zu tun (z.b. + und * mit matrizen gehen auch anders, als + und * mit zahlen).
btw, die ganzen zahlen z.b. sind auch ein 'ring' (aber ich glaub nicht nur, mathematische strukturen überlappen sich teilweise). just my 2 cents, aber frag mal besser im matheforum oder schau hier: http://www-groups.dcs.st-and.ac.uk/~history/HistTopics/Ring_theory.html

xX Dany Xx

Ja ich hab das jetzt so geamcht:

char a[40];
	char b[40];

	scanf("%32s", &a);
    getchar();
    strtol(a, 0, 2);

	scanf("%32s", &b);
    getchar();
    strtol(b, 0, 2);

Aber der kann damit dann nicht rechnen, weil das vom Typ char [40] ist. Also das c=a^b und c^=b .

xX Dany Xx schrieb:

Aber der kann damit dann nicht rechnen, weil das vom Typ char [40] ist. Also das c=a^b und c^=b .

bau dir doch 'ne kleine library, die mit bit-strings umgehen kann bzw. such mal hier im C-forum, an ein oder zwei solcher codes kann ich mich dunkel erinnern.
oder du macht das mit chars, ist zwar speicherverschwendung, aber nicht so schlimm, z.b.

#define XOR(a,b) ((b)==(a) ? 0 : 1)

xX Dany Xx

Ja ich habs noch bissi geändert:

char buffera[40], bufferb[40];
	unsigned int a=0, b=0;

printf ("\nsende: ");
	scanf("%32s", &buffera);
    getchar();
	a=strtol (buffera, NULL, 16);
	printf ("\nsende ist: %x", a);

	printf ("\ngen: ");
	scanf("%32s", &bufferb);
    getchar();
	b=strtol (bufferb, NULL, 16);
	printf ("\gen ist: %x", b);

Aber der spuckt mir da iwelche komische Werte aus... wenn ich 101110011001 eingebe, dann kommt 7fffffff raus und wenn ich 10011 eingebe kommt 10011 raus. Was ist falsch?