Hi alle zusammen, ich sitzt nun schon seit ein paar Tagen dabei aber komm einfach nicht dahinter ( dezente Programmierschwächen meinerseits ;) ). Ich soll für die Uni ein Programm schreiben, das eine Zahl z.B. 101 übernimmt und diese in Binary und BCD ausgibt und so darstellt: Input: 101 - 0000 0000 | 0000 0000 | 0000 0000 | 0110 0101 BCD: 257 - 0000 0000 | 0000 0000 | 0000 0001 | 0000 0001 Binary: 65 - 0000 0000 | 0000 0000 | 0000 0000 | 0100 0001 Die Binary Darstellung ist kein Problem nur wie bekomme ich den BCD Code dazu und vor allem mit dieser Formatierung??? Bisher gibt er mir immer nur die 1 aus aber nicht 101 Vielen Dank schon mal Till
Dann zeig mal dein Programm. Allgemein: Du teilst die Zahl durch 10. Der Rest ist deine hinterste Ziffer. Das Ergebnis teilst du wieder durch zehn, der Rest gibt die nächste Ziffer, solange bis das Ergebnis kleiner zehn ist. Das ist dann deine vorderste Ziffer. Was du allerdings zeigst ist gepacktes BCD, da 2 Ziffern in einem Byte sind: 101 = 0001 0000 0001 Aber ein bischen was darfst du auch selbst machen :-)
T.R schrieb: > Input: 101 > Binary: 65 ??? In welchem Format ist denn Input? Was du binary nennst ist wohl hexadezimal gemeint. Gib lieber mal die gesamte Aufgabe an, und zeige was du schon selbst gemacht hast. Wir sind kein Abschreibeverein hier.
Bis jetzt hab ich das hier:
void bcdcode (unsigned int number)
{
unsigned int bitmask = 2147483648;
int count = 0;
int j = 0;
unsigned int bcd;
count = number % 10;
while (bitmask > 0)
{
bcd = count & bitmask;
if (j == 4 || j == 12 ||j == 20 || j == 28)
{
printf(" ");
}
if (j == 8 || j == 16 ||j== 24)
{
printf(" | ");
}
if (bcd)
{
printf("1");
}
else
{
printf("0");
}
bitmask = bitmask >> 1;
j++;
}
printf("\n");
}
Ich weiß ist ein sehr umständlicher Code aber wenigstns läufts einmal.
Das heißt ich muss meine Zahl dann einfach nur wieder %10 damit ich auf
die nächste komme?
T.R schrieb: > count = number % 10; Das machst du genau ein mal, also erzeugst du nur die letzte Ziffer der BCD Zahl. T.R schrieb: > Binary: 65 - 0000 0000 | 0000 0000 | 0000 0000 | 0100 0001 Das ist falsch. Was willst du erreichen? Was ist die exakte Aufgabenstellung? Tipp: Nimm Papier und Bleistift. Mach dir klar wie eine Zahl abgespeichert wird, und was eine BCD codierte Zahl überhaupt ist. Wenn du das auf dem Papier umwandeln kannst dann machs als Software. Noch ein Tipp Mache für jede Konvertierung eine eigene Funktion. Lagere die Ausgabe dann in eine eigene Funktion aus. Oder habt ihr noch keine Funktionen/Prozeduren mit Parameterübergabe gemacht?
Funktionen und übergaben haben wir schon "gelernt". Ich hab auch für jede Konvertierung und die Ausgabe eine eigene Fkt, ich habs nur mit rein gepackt damit ich besser seh was das programm macht, bzw was es ausgibt. In der Angabe steht: Der Input ist einmal als Dualcode betrachtet in den BCD-Code zu konvertieren (BCD) und einmal als BCD-Code betrachtet in den Dualcode zu konvertieren (Binary). Udo Schmitt schrieb: >> Binary: 65 - 0000 0000 | 0000 0000 | 0000 0000 | 0100 0001 > > Das ist falsch. > Was willst du erreichen? > Was ist die exakte Aufgabenstellung? Input) ist einmal als Dualcode betrachtet in den BCD-Code zu konvertieren (BCD) und einmal als BCD-Code betrachtet in den Dualcode zu konvertieren (Binary). Die 65 steht auch so in der Angabe. Wenn ich für jede Zahl die BCD ausgabe mache muss ich aber noch zusätzlich die vorige Darstellung verschieben oder, ansonsten legt er mir ja immer alles übereinander und die Werte von den vorigen gehen verloren. bcd = bcd << (i * 4); output = output | bcd; i++;
T.R schrieb: > Input) ist einmal als Dualcode betrachtet in den BCD-Code zu > konvertieren (BCD) und einmal als BCD-Code betrachtet in den Dualcode zu > konvertieren (Binary) Moment das ist aber was anderes als das was du am Anfang schreibst. Eine Zahl vom Dualcode (ich nehme an das ist das gleiche wie "binär codiert") besteht nur aus '0' und '1' Das heisst doch du sollst 2 Funktionen schreiben: Funktion 1 wandelt eine Binärzahl in eine BCD Zahl um Funktion 2 wandelt eine BCD Zahl in eine Binärzahl um. Jetzt ist erst mal zu klären in welcher Form die Zahlen vorliegen, bzw vorliegen sollen. Ich würde einfach sagen als String also z.B. "10010110" <-> "96" Sonst macht das eigentlich keinen Sinn oder wir reden aneinander vorbei.
Und ich würde auf jeden Fall die Sache 2-teilen.
Das eine ist die Berechnung der Zahlen, das andere die entsprechende
Ausgabe. Die Ausgabe ist immer gleich
..... 101 - 0000 0000 | 0000 0000 | 0000 0000 | 0110 0101
^ | |
| +-------------------------------------------+
| .... und hier die enstprechende
| Binärdarstellung dazu
|
+---- hier steht eine Dezimalzahl
der Teil ist immer derselbe: von einer Zahl die Dezimalform hinschreiben
und dann die entsprechende Aufdröselung in Bits.
Das hat aber nicht mit BCD oder Binäry zu tun.
Die Frage lautet daher nicht: wie muss die Ausgabe in der Funktion
bcdcode gemacht werden
sondern sie lautet: wie muss die gegebene Zahl auseinander genommen und
statt dessen wieder eine andere Zahl zusammengebaut werden, damit diese
Zahl den entsprechenden BCD Code realisiert.
deine Funktion bcdcode bekommt eine Zahl und sie liefert eine Zahl.
Nämlich zb dann, wenn du 101 in die Funktion hineingibst, dann liefert
sie 257 zurück.
Dass du dann beide Zahlen, 101 und 257, mit derselben Ausgabefunktion
ausgeben kannst, wobei du die Ausgabezeile mit einem anderen Wort
beginnen lässt, ist ein ganz andere Sache, und hat nichts mit Dezimal,
BCD oder Binär zu tun.
Ich grübel schon seit Stunden, wie die Aufgabe lautet. Ich vermute mal, unterschiedliches Ausgabeformat:
1 | void ausgabe( unsigned int num ) |
2 | {
|
3 | char buf[17]; |
4 | |
5 | utoa( num, buf, 10 ); |
6 | printf( "dezimal: %s\n", buf ); |
7 | utoa( num, buf, 2 ); |
8 | printf( "binär: %s\n", buf ); |
9 | utoa( num, buf, 16 ); |
10 | printf( "hex: %s\n", buf ); |
11 | }
|
Peter
auch wenns der TE vielleicht nicht verstehen wird:
static inline uint8_t bcd2bin(uint8_t val) { return val - 6 * (val >>
4); }
static inline uint8_t bin2bcd(uint8_t val) { return val + 6 * (val /
10); }
Peter Dannegger schrieb: > Ich grübel schon seit Stunden, wie die Aufgabe lautet. Da ich anscheinend nicht einmal die Angabe richtig verstanden habe. Das ist alles was wir bekommen haben ( Errorhandling lass ich jetzt weg): Einleitung Lernziel des ersten Übungsbeispiels (Einzelarbeit) ist es, das Prinzip von Bitmasken und Bitoperationen verstanden zu haben und diese für einfache Operationen einsetzen zu können. Aufgabenstellung Erstellen Sie ein Programm, das als Parameter eine positive Zahl übernimmt und im Anschluss falls möglich die Zahl vom Dualcode in den BCD-Code und umgekehrt zu konvertieren. Das Programm soll dabei logisch in Funktionen gegliedert sein und alle Berechnungen soweit möglich mit Bitoperationen und Bitmasken errechnen. Der BCD-Code (Binary Coded Decimal) stellt eine Zahl so dar, dass er für jede Ziffer (0-9) ein Nibble (4 Bit, ein halbes Byte) verwendet. Input Das Programm erwartet als (einzigen) Parameter eine positive Ganzzahl (unsigned int) im Wertebereich 1 - UINT_MAX (definiert in limits.h), der erste Werte ist inklusive, der zweite exklusive. Zur Konvertierung des Parameters soll die Funktion strtoul (aus stdlib.h) verwendet werden, wobei der zweite Parameter auf NULL und der dritte auf 0 gesetzt werden muss. Dadurch ist bis auf den Wertebereich keine weitere Eingabeüberprüfung notwendig. Berechnung Die eingegebene Zahl (Input) ist einmal als Dualcode betrachtet in den BCD-Code zu konvertieren (BCD) und einmal als BCD-Code betrachtet in den Dualcode zu konvertieren (Binary). Zur Hin- und Rückkonvertierung des BCD-Codes müssen Sie Bitoperationen und Bitmasken verwenden, um die unterschiedlichen Bits der Zahl zu berechnen und das Ergebnis bitweise auszugeben. Nur für die Berechnung von 10er Potenzen und Ziffern im Dezimalsystem dürfen sie den Multiplikations-, Divisions- und den Modulo-Operator verwenden. Output Das Programm gibt im Anschluss folgenden Text aus: Input: [Input] - [Bits of Input]\n BCD: [BCD] - [Bits of BCD]\n Binary: [Binary] - [Bits of Binary]\n Hierbei werden die Begriffe in eckigen Klammern durch die entsprechenden Werte ersetzt: Für die Werte selbst ([Input], [BCD], [Binary]) ist folgender Format String zu verwenden: "%10u". Die Bitweise Ausgabe soll jedes Nibble mit einem Leerzeichen trennen und jedes Byte zusätzlich mit einem vertikalen Strich |, der ebenfalls von Leerzeichen umgeben ist.
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.