Rechnen und Ausgeben von Binärcodes

[kundesbanzler]

Moin,

ich will einem EPROM multiplizieren beibringen, und zwar je 8 Bit mit 8 Bit. Das Ergebnis soll wieder auf 8 Bit gekürzt werden (natürlich auf die 8 höherwertigen Bit). Hierfür brauche ich einfach nur eine Binärdatei(!! keine ASCII oder Hex-Datei!) mit allen möglichen Multiplikationen (sind 65536 mögliche Kombinationen..) und genau dafür will ich ein C-Programm schreiben. Nun programmiere ich im Allgemeinen eher µCs und habe null Plan, wie ich eine Binärdatei erzeugen kann. Auch wollen meine bisherigen Versuche die Binärzahlen nicht richtig multiplizieren (was vielmehr daran liegt, dass ich keine Ahnung habe, wie ich die richtig ausgeben muss.. :/).

Nun wäre ich sehr dankbar, wenn mir hier jemand ein Beispielprogramm zum Rechnen mit Binärzahlen schreiben würde und mir möglicherweise auch gleich erklären könnte, wie ich die Binärdatei erstellen könnte (wichtig dabei ist auch, dass die Datei nicht jedesmal überschrieben werden soll, sondern jeder Wert eine neue Zeile bekommen muss).

[SeeksTheMoon]

Die Multiplikation im Binärsystem läuft mit den Shiftoperatoren und wenn Du die ganzen Ergebnisse in einer Binärdatei speichern willst, dann musst Du zum Schreiben die Funktion fwrite benutzen anstatt fputc oder fprintf.

Am einfachsten ist es erstmal, die Zahlen alle dezimal zu multiplizieren und dann die Ergebnisse in Binärzahlen umzuwandeln.
Das geht mit einem Bitmaskenvergleich mit besagtem Shiftoperator:

Du nimmst die Dezimalzahl und die Zahl 1. Dann schiebst Du bei der 1 die 1 von der niedrigsten auf die höchste Stelle und dann machst Du in einer Schleife einen binären Vergleich der Maske mit der Zahl und shiftest die 1 wieder runter.

So könntest Du die Zahl binär ausgeben. Die Speicherung kannst Du z.B. in einem struct machen oder in einem Array und das dann in die Datei schreiben

[kundesbanzler]

Also wenn ich das richtig verstanden habe, schiebe ich einfach die 1 so lange, bis die dez-Zahl nicht mehr durch die bin-Zahl teilbar ist. Wenn ich das erreicht habe, schiebe ich die 1 wieder um eins nach rechts und füge eine neue 1 ein, durch die ich dann den Rest der ersten Division (wieder mit hin-und-her schieben) dividiere, bis der Rest 0 ist? Hmm.. Also wenn ich das jetzt nicht komplett falsch verstanden habe, verstehe ich zumindest mal das Prinzip.. Kann ich das hin-und-her-schieben nicht auch am einfachsten mit einem Array realisieren?

Die andere Frage wäre: wie definiere ich eine Binärzahl? Hab' darüber nichts gefunden, einfach mit 0x00100010 (als Bsp.)? die muss dann auch als unsigned char gespeichert werden, sonst wird mir das Binärfile zu groß, oder speichert fwrite sowieso alles im Binärformat ab, unabhängig vom Datentyp?

Aber danke erstmal, werde mich dann gleich morgen wieder dransetzen

[SeeksTheMoon]

fwrite speichert immer binär, die anderen immer Text.

Du machst keine Division durch die 1-Zahl (Bitmaske), sondern einen binärvergleich:

Du hast zuerst 0000 0001, das ist 1. Dann schiebst Du die 1 ganz nach links (<<), so dass Du 1000 0000 hast und dann benutzt Du einen Binärvergleich (&) mit Deiner Dezimalzahl (dem Rechenergebnis).
Im Rechner sieht das dann z.B. so aus:
erster Schritt:

   1001 0110      <- unbekanntes Ergebnis in interner Darstellung
&  1000 0000      <- unsere Bitmaske

Vergleich ist 1, also true, weil an beiden Stellen eine 1 steht. Die erste Zahl im Array wird eine 1.
Die Bitmaske einmal nach rechts shiften (>>) und wieder vergleichen:

   1001 0110
&  0100 0000

diesmal 0, false -> nächste Zahl im Array wird 0 usw.

Der & Operator funktioniert wie ein UND-Gatter: Sind zwei Einser da, kommt 1 raus, sonst nicht.

[kundesbanzler]

Das mit fwrite ist schonmal gut zu wissen, danke

Und ich kann eine Dezimalzahl wirklich mit dieser Bitmaske UND-verknüpfen? Hab ich das richtig verstanden? (sry, hab's normalerweise mehr mit µCs, da hab' ich selten solche Probleme..).

[SeeksTheMoon]

sicher, dafür ist der Operator ja da. Die Dezimalzahl und die 1 haben auch den gleichen Datentyp, da ist das eh kein Problem.
Falls Du float-Zahlen binär umwandeln willst, dann wird es etwas wilder, weil deren interner Aufbau ja etwas wilder ist.

[Joghurt]

ich will einem EPROM multiplizieren beibringen, und zwar je 8 Bit mit 8 Bit. Das Ergebnis soll wieder auf 8 Bit gekürzt werden (natürlich auf die 8 höherwertigen Bit).

Wieso auf die 8 höherwertigen bits?

Falls es auch die 8 niederwertigen Bits sein dürfen, nimm doch diese Funktion (dachte erst, dass du einem miniprozzi multiplizieren beibrigen wolltest, deshalb das register)

unsigned char mul(unsigned char a, unsigned char b)
{
    register unsigned char c;
    if (a>b) {
	c = a;
        a = b;
        b = c;
    }
    c=0;
    for( ; a ; a>>=1,b<<=1) {
	if (a&1)
	    c += b;
    }
    return c;
}

[kundesbanzler]

Also das, was du da jetzt gerechnet hast, verstehe ich überhaupt nicht, sry

Naja, die 8 höherwertigen Bit deshalb, weil das Ergebnis ansich ja eine 16Bit-Zahl ist. Wenn ich diese 16 Bit auf 8 Bit kürze, sind es die 8 höherwertigen, die signifikant sind, nicht die 8 niederwertigen.
Und das, was ich brauche, ist einfach nur eine Binärdatei mit 65k*8 0en und 1en, die exakt (auf den Bit genau) 512kBit groß sein muss. Da ich mir die Mühe nicht machen will, alles extra in einen Hex Editor einzugeben, will ich das eben durch ein kleines Programm für mich erledigen lassen

[Joghurt]

Also das, was du da jetzt gerechnet hast, verstehe ich überhaupt nicht, sry

Ich dachte zuerst, du brauchst dieses Array, weil du mit einem Mikroprozessor multiplizieren willst; ich wollte einfach nur zeigen, wie du die Binäre Multiplikation implementierst.

Wenn ich diese 16 Bit auf 8 Bit kürze, sind es die 8 höherwertigen, die signifikant sind, nicht die 8 niederwertigen.

2*128 = 1... Nagut

Und das, was ich brauche, ist einfach nur eine Binärdatei mit 65k*8 0en und 1en, die exakt (auf den Bit genau) 512kBit groß sein muss.

Willst du jedes Bit einzeln als Byte gespeichert haben? Oder wie oder was?
Eine 512kBit große Datei mit dem gewünschten Ergebnis bekommst du so:

#include <stdio.h>
int main()
{
  FILE* f;
  char mul[256][256];
  int a,b,c;
  char d;
  f = fopen("multable","wb");
  for (a=0;a<256;a++) for (b=0;b<256;b++) mul[a][b] = (a*b)/256; // so? Dann wäre 1*1 = 0, da das höherwertige Byte 0 ist.
  // Ansonsten mul[a][b] = a*b;
  fwrite(mul,sizeof(mul),1,f);
  fclose(f);
}

Falls du möchtest, dass in der Datei jedes Bit einzeln ein Byte einnimmt, also in der Art

00 01 00 01 01 01 00

, dann ersetze den fwrite durch

for(a=0;a<256;a++) for(b=0;b<256;b++) for(c=7;c>=0;c--) {d = (mul[a][b]>>c)&1;fwrite(d,1,1,f);}

[kundesbanzler]

Verdammt, ich hab ganz vergessen, dass fwrite ja sowieso alles im Binärformat speichert o.O

Danke jedenfalls, die Datei passt exakt (und ist genau 65536Byte (=512kBit) groß), danke vielmals

Das Programm hab ich übrigens gleich 1:1 übernehmen können, hat auch alles gepasst..
Danke an alle für die Einführung in fwrite, ich glaube, ich hab's jetzt endlich kapiert..

Und wegen der Datei, naja, das EPROM legt für jede Zeile eine Adresse an, dh. man kann durch geeignete Wahl der Adressleitungen direkt die zwei 8bit-Zahlen an den Adressport liefern.