Super hat alles geklappt

Jetzt habe ich aber eine weitere Frage:

Wie schaffe ich es ein char in ein binäres Format umzuwandeln danach die binäre Zeichen zusammenhängen?

Gibt es dazu irgendwelche Funktionen?

Mfg
Rambodischien

Zitat :

Wie schaffe ich es ein char in ein binäres Format umzuwandeln danach die binäre Zeichen zusammenhängen?

Wie meinst du das? Auch hier scheitert eine prompte Antwort an der Ungenauigkeit der Fragestellung .

Ein Char (signiertes Byte) wird permanent binär behandelt... Oder willst du wirklich eine Zeichenkette bekommen, in der man die Bitkombination einer vorzeichenbehafteten (char eben...) 8-Bit-Zahl sieht?

Ich glaub eher weniger...

Schildere bitte genau, was du meinst und was du unter "binärem Zeichen" verstehst.

_________________

Ich meinte damit, dass ich aus z.B.: Dem Wort "Hallo" die Bits erhalte z.B.: 0010001010101010101010 usw.

Mfg
Rambodischien

Habe im Netz gerade was gefunden nur leider weiß ich nicht wie das ganze von statten geht:

Code :

std::cout << std::bitset<CHAR_BIT>( 'K' ) << std::endl;

Ich habe keine Ahnung wo ich was eingeben muss.

Mfg
Rambodischien

[ Diese Nachricht wurde geändert von: Rambodischien am 17 Jun 2008 21:21 ]

Nenene,

Das, was du da hast, sind Teile der Standardbibliothek von C++. Das geht in C so überhaupt nicht.

---

Das geht in C manuell sogar ziemlich einfach.



Geh doch mal systematisch ans Problem:
1. Es soll ein nullterminierter String in seine Einzelbytes zerlegt werden
2. jedes dieser Einzelbytes soll in seine zugrundeliegende Bitkombination zerlegt werden
3. Es erfolgt eine Ausgabe in einen Zielstring, also einen Speicherbereich.

Jetzt die Rahmenbedingungen aufschreiben:
1. Aufteilung entweder mit indirekter Adressierung über die []-Referenzierung und einen Iterator oder aber direkt über Inkrementieren des Quellstrings
2. Ein Char packt 8 Bits, das sind 8 Bytes, die für '0' oder '1' reserviert werden müssen. Weiterhin muss eine Funktion her, die das umrechnet. Dazu empfielt sich das "verunden" mit 1 und das 8-fache Schieben nach rechts, dann hat man das Ergebnis
3. Der Zielstring muss wie groß sein, damit der String als Binärzahl ausgegeben werden kann?

---
Dann definiert man einen Funktionsprototypen. Du kannst ja mal hier hinschreiben, wie der aussehen würde.
Bedenke, welche Argumente und Rückgabewerte der sinnigerweise haben sollte .

Ich helfe dir weiter, aber jetzt sollst du mal ein bischen mitdenken .

_________________

Zitat : DonComi hat am 17 Jun 2008 22:03 geschrieben :

Ich helfe dir weiter, aber jetzt sollst du mal ein bischen mitdenken .

Also gut ich versuche es:

Code :

char Text[]="Das ist ein Test""[1code] char Text[]="Das ist ein Test""\0"; char Ausgabe[(Text.length)*8] int i=0; int x=0; while(Text[i]!='\0') { for(x=0;x<8;x++) { Ausgabe[x]=(Text[i]& 1)>>x; } i++; } [/code1]"; char Ausgabe[(Text.length)*8] int i=0; int x=0; while(Text[i]!='[1code] char Text[]="Das ist ein Test""\0"; char Ausgabe[(Text.length)*8] int i=0; int x=0; while(Text[i]!='\0') { for(x=0;x<8;x++) { Ausgabe[x]=(Text[i]& 1)>>x; } i++; } [/code1]') { for(x=0;x<8;x++) { Ausgabe[x]=(Text[i]& 1)>>x; } i++; }

So in etwas?

Mfg
Rambodischien

Zitat :

So in etwas?

Geht es denn so bei dir?

Zitat :

char Ausgabe[(Text.length)*8]

Dass man die Größe des Zielpuffers 8 mal so groß wählt wie die Eingabedaten ist, sinnigerweise, richtig.
Aber so wird das nicht klappen, was soll das lenght? Wenn dann eher so:

uint8_t Text[]="Dies ist ein Text.";
uint8_t Ausgabe[sizeof(Text)*8];

Oder anstelle von uint8_t unsigned char.
I.d.R. fügt der C-Compiler ein 0x0 hinten dran, das musst du nicht tun. Was mich ärgert, ist, dass diese Escapesequenzen hier von der Software verhunzt werden; schau dir mal deinen hochgeladenen Quelltext an..
---

Zitat :

for(x=0;x<8;x++) { Ausgabe[x]=(Text[i]& 1)>>x; }

Nein, so gehts nicht. Der Ansatz war ok, aber zwei Sachen passieren hier falsch:
1. x ändert sich immer wieder von 0 bis 7, du überschreibst also die ersten 8 Byte im Puffer immer wieder.
2. Welche Ergebnisse können denn bei dieser Operation herauskommen: entweder 1, wenn das Ergebnis 1 ist oder eben 0. Das sind aber keine darstellbaren Zeichen! Da muss noch ein Offset mit drauf, z.b '0'.
3. >>x ist ineffizient, da der Assembler dort kein rol einsetzen kann, sondern eine Variable Anzahl nach links schieben muss.

So würde ich das machen:

void dual(unsigned char arg, unsigned char *buffer)
{
unsigned char i;
for(i=0;i<8;i++, buffer++, arg<<=1)
*buffer = (arg&0x80) ? '1' : '0';
};

Klar?

weiter:


unsigned char *strtobin(unsigned char *strin, unsigned char *strout)
{
unsigned char *strret=strout;
while(*strout){
dual(*strin, strout);
strin++;
};
*strout=0; /* terminieren */
return strret;
};

Auch klar?

---
Man könnte bzw. sollte, worauf ich jetzt verzichtet habe, die Zeiger sichern, bevor man sie verändert. Dadurch wird kein Fehlverhalten durch falsche Zeige im Programm verursacht.

Noch was:
Auf µCs hat man nicht immer soviel Platz. Sollten die Daten direkt ausgegeben werden (Display, Uart, etc.), dann kann man das direkt dort machen, wo man sonst in den Ausgabepuffer schreiben würde.

void dual(unsigned char arg, void (*output)(unsigned char))
{
unsigned char i;
for(i=0;i<8;i++,arg<<=1)
output( ( arg&0x80 ? '1' : '0' ) );
};

Aufgerufen wirds dann so:
dual(value, lcdChar);
(in value steht der Wert, lcdChar ist eine denkbare Funktion, die man übergeben kann, um je ein Byte auszugeben, denkbar wäre auch sowas wie terminlaChar oder so. Halt eine Funktion, die ein Zeichen irgendwo ausgibt.)

Es gibt viele denkbare Möglichkeiten.

P.S.: Das habe ich hier schnell hingekritzelt, kann sein, dass es noch nicht zu 100% läuft. Aber das ist ja auch nicht meine Aufgabe.



_________________


[ Diese Nachricht wurde ge&auml;ndert von: DonComi am 17 Jun 2008 23:04 ]

[ Diese Nachricht wurde ge&auml;ndert von: DonComi am 17 Jun 2008 23:06 ]

[ Diese Nachricht wurde ge&auml;ndert von: DonComi am 17 Jun 2008 23:09 ]

[ Diese Nachricht wurde ge&auml;ndert von: DonComi am 17 Jun 2008 23:12 ]

[ Diese Nachricht wurde geändert von: DonComi am 17 Jun 2008 23:18 ]

So, da ich irgendwie noch dazugekommen bin; hier eine funktionierende Version.

Code :

static unsigned char *dual(unsigned char arg, unsigned char *puffer) { unsigned char i; for(i=0;i<8;i++, puffer++, arg <<= 1) *puffer = (arg&0x80 ? '1' : '0'); return puffer; }; unsigned char *tobin(unsigned char *strin, unsigned char *strout) { unsigned char *strret=strout; while(*strin){ strout=dual(*strin, strout); strin++; }; *strout=0; return strret; };

Wie gesagt, auf µC, die diese Ausgabe direkt auf ein Display schreiben, sollte man nicht unnötig große Pufferbereiche anlegen, sondern gleich die Zeichen schreiben. Das hat den Vorteil, dass es schneller und SRAM-sparender geht. Denn SRAM ist knapp und man muss immer achtmal soviel reservieren, wie die Strings maximal lang sind! In Rechnern, wo wesentlich mehr Speicher verfügbar ist, holt man sich einfach dynamisch Speicher, schreibt den voll, gibt ihn aus und gibt ihn wieder frei. Aber bei µCs, vergiss es .

_________________


[ Diese Nachricht wurde geändert von: DonComi am 17 Jun 2008 23:53 ]

Vielen vielen vielen Dank für die Bemühung. Ich weiß es ist nicht immer leicht mit einem verständnislosen und einem Begriffsstutzigen wie mir zu helfen.



Manchmal könnte ich mir selber

So nun zu deinem Code. Ich möchte nicht irgendwie diesen Code kopieren und einfach vergessen wenn es funktionert, ich will den Code verstehen, darum die nächsten (dämlichen) Fragen:

Was ist der unterschied zwischen signed char und unsigned char?

Mit der folgenden Zeile komme ich noch nicht klar:

Code :

for(i=0;i<8;i++, puffer++, arg <<= 1) *puffer = (arg&0x80 ? '1' : '0');

puffer++ der Pointer wird um eins erhöht oder?

arg <<= das char arg wird um eins nach links geschoben?

? '1' : '0' was macht dieser Programmteil?

und dann ist da noch etwas:

Code :

*strout=0;

Wieso wird der Pointer für die Ausgabe auf 0 gesetzt?

Nun zur aller letzten Frage (im Moment):

Soweit ich weiß gibt es kein bool in C. Was verwendet man hier am Besten?

Danke

Mfg
Rambodischien

OK, auch wenn ich einen hinter der Binde habe grade (gute Kumpels verabschiedet für die nächsten Jahre ), versuche ich mal, die Fragen zu beantworten .

Zitat :

So nun zu deinem Code. Ich möchte nicht irgendwie diesen Code kopieren und einfach vergessen wenn es funktionert, ich will den Code verstehen, darum die nächsten (dämlichen) Fragen:

Gute Einstellung; da hilft man gern

----

Zitat :

Was ist der unterschied zwischen signed char und unsigned char?

Signed (signiert) sind vorzeichenbehaftete Ganzzahlen, dazu wird das 7. Bit benutzt: ist es 1, so ist die Zahl negativ (Vorzeichen -), andernfalls positiv. Ist im Programm die Notwendigkeit nach vorzeichenbehafteten Zahlen nicht gegeben (z.B. sind Zeichen i.d.R. vorzeichenlos ), dann fügt man vorne ein unsigned an. Standardmäßig, also wenn signed oder unsigned weggelassen wird, nimmt der Compiler nämlich signed! (kann man ausschalten).
Normalerweise benutzt man einfach char* als Zeiger für Strings, auf µCs würde ich da wie gesagt eher unsigned nehmen, da es sonst zu Klimmzügen kommen könnte.

Zitat :

Mit der folgenden Zeile komme ich noch nicht klar: Code : for(i=0;i<8;i++, puffer++, arg <<= 1) *puffer = (arg&0x80 ? '1' : '0'); puffer++ der Pointer wird um eins erhöht oder?

Korrekt.

Zitat :

arg <<= das char arg wird um eins nach links geschoben?

Ja, uns der geänderte Wert wird nach arg zurückgeschrieben. Man könnte auch schreiben

arg = arg << 1;

Zitat :

? '1' : '0' was macht dieser Programmteil?

Das ist ein Operator, der den Ausdruck anfangs auf Gültigkeit (wahr oder falsch / true / false; siehe unten) auswertet. Wenn er wahr ist, dann wird der Teil nach dem ? ausfgeführt, andernfalls der Wert hinter dem Kolon : . In diesem Fall steht dort nur eine Konstante, also wird diese genommen. Dort kann aber auch Programmkode stehen. Er entspricht etwa der Konstruktion


if(arg)
... = '1';
else
... = '0';

Er sorgt hier auch dafür, dass darstellbare Zeichen für gesetze/gelöschte Bits im String auftauchen, eben die Zeichen '0' oder '1' als ASCII-Kode.

Zitat :

--- *strout=0; --- Wieso wird der Pointer für die Ausgabe auf 0 gesetzt?

Wird er ja nicht. Das *-Zeichen dereferenziert den Zeiger, es wird also der Wert, auf den strout zeigt, auf 0 gesetzt. Das ist eben u.a. das Zeichen für die Terminierung des Strings .
Ich weiß ja vorher nicht, wie groß evtl. der Puffer ist. Hiermit setze ich explizit das Ende des Strings.

Würde ich den Zeiger auf 0 setzen, sähe das so aus:
strout=0;

Zitat :

Soweit ich weiß gibt es kein bool in C. Was verwendet man hier am Besten?

C wertet Ausdrücke wie folgt aus:
Ist eine Zahl / Ausdruck gleich 0 (NULL), dann entspricht das dem logischen false, andernfalls, also alles andere ungleich 0 entspricht true.
Der Standard von C kennt keine boolschen Ausdrücke wie true und false, jedoch stehen diese mit dem Einbinden von stdbool.h zur Verfügung.

Man kann das auch als Enumeration verstehen:

typedef enum bool__ { false=0, true} bool;

Das heißt: alles ungleich 0 ist true, 0 ist false.
So einfach ist das .


_________________

Hi

Es hat geklappt vielen herzlichen Dank für die Erklärung.

Jetzt habe ich zwei weitere Fragen:

Zur ersten Frage:

Zitat :

Man kann das auch als Enumeration verstehen: typedef enum bool__ { false=0, true} bool;

Ich denke hier wird ein bool definiert.

Zur zweiten Frage:

Wie mache ich jetzt von diesem binärem char[] einen hex char[].

Also wenn ich z.B.: T eingeben wird daraus 01010100 und danach soll das ganze in ein Hex umgewandelt werden also 54.

Im Internet habe ich nichts brauchbares gefunden.

Mfg
Rambodischien

Das ist doch einfach, jetzt leiste du mal was; ich gebe dir eine Hilfestellung:

1. Wieviel Speicher wird für den Zielstring benötigt?
2. Die Basis vom Hexadezimalsystem ist?
3. und nochmal richtig nett von mir: ein Nibble entspricht genau einem Zeichen im Hexadezimalkode! Was ist also naheliegend zu tun?
4. wenn die Zahl größer als 0x9 ist, dann werden andere ASCII-Zeichen benötigt, nämlich a, b, c oder A, B, C. Welche Prüfung mus also stattfinden?

Edit:

Zitat :

[...] wird daraus 01010100 und danach soll das ganze in ein Hex umgewandelt werden [...]

Bitte nicht vom String der einzelnen Bits ausgehen. Das wäre zwar möglich, aber blödsinnig .

Der Prototyp sollte so etwa aussehen:
unsigned char *hex8(unsigned char arg, unsigned char *buffer);

Oder, etwas schöner:

uint8_t *hex8(uint8_t number, uint8_t *dest);

Zitat :

Ich denke hier wird ein bool definiert.

Gönau.
Das tut aber der Header stdbool.h auch.



_________________


[ Diese Nachricht wurde geändert von: DonComi am 25 Jun 2008  0:00 ]

Ich habe mal versucht das ganze zu machen:

Code :

#include <math.h> unsigned char* tohex(unsigned char *bin, unsigned char *hex) { unsigned char y; unsigned int buffer; while(*bin) { for (y=0;y<4;y++,bin++) { if(*bin==1) { buffer=buffer + pow(2,y); } } if(buffer < 10) { *hex=buffer; *hex++; } else { if(buffer==10) { *hex='A'; *hex++; } if(buffer==11) { *hex='B'; *hex++; } if(buffer==12) { *hex='C'; *hex++; } if(buffer==13) { *hex='D'; *hex++; } if(buffer==14) { *hex='E'; *hex++; } if(buffer==15) { *hex='F'; *hex++; } } } *hex=0; return hex; }

Ich werde erst später den Code ausprobieren können.

Mfg
Rambodischien

[ Diese Nachricht wurde geändert von: Rambodischien am 25 Jun 2008 15:04 ]