Zeichen (hex) binär ausgeben

[P. Dammerow (Gast)]

Hallo liebe Forum Gemeinde.

Als erstes wünsche ich allen ein frohes und vorallem gesundes neues 
Jahr.
Zweitens : ich komme gleich auf den Punkt.

Ich habe ein char (Zeichen zwischen 0...F)
Nun möchte ich das Zeichen in binärcode ausgeben.

Folgendes habe ich bisher geschafft:

char Buffer[4];
int i;
char Wert;

Wert=botschaft[7];  // botschaft[7] enthält die Zeichen von 0 bis F...

for (i = 0; i < 4; i++)
{
   Buffer[i] = (Wert & (1 << (3 - i)) ? '1' : '0');
}
Buffer[4] = '\0';
set_cursor(0,3);lcd_string(Buffer);

Es klappt nur bei Zeichen von 0 bis 9...
Wie kann ich den Code ergänzen um auch A bis F auszugeben.

Liebe Grüße

[TokyoDrift (Gast)]

for (i = 0; i < 4; i++)
{
   Buffer[i] = (Wert & (1 << (3 - i)) ? '1' : '0');
}

Sieht eigentlich gut aus.

Buffer[4] = '\0';

Schreibt auf jeden Fall in einen Speicher in den es nicht schreiben 
soll.


>Es klappt nur bei Zeichen von 0 bis 9...
>Wie kann ich den Code ergänzen um auch A bis F auszugeben.
Was passiert denn bei A bis F?

[P. Dammerow (Gast)]

Hallo.

Bei A-F wird zwar ein binärcode erzeugt, jedoch nicht der Richtige.

Gruß

[Nico S. (Gast)]

Dann schreib doch mal bitte ein Beispiel, welcher Binärcode bei A-F 
erzeugt wird.

[P. Dammerow (Gast)]

Also.
Die Zeichen werden wie folgt erzeugt :

0   0000
1   0001
2   0010
3   0011
4   0100
5   0101
6   0110
7   0111
8   1000
9   1001

bis dahin alles ok...

A   0001
B   0010
C   0011
D   0100
E   0101
F   0110

ok. Er fängt wieder von vorne an.
Wenn ich das Ergebnis (von der 9) zum Ergebnis (z.B. von A) addiere 
bekomme ich das richtige Ergebnis??

BSP:
1001  ->9
+
0011  ->C
=
1100  ->12

Wie mache ich das?

[Huch (Gast)]

http://de.wikipedia.org/wiki/ASCII

[P. Dammerow (Gast)]

Alles klar.

Habe alles auf 8bit erweitert und es funktioniert nun richtig. ok

Danke für die Hilfe.

[P. Dammerow (Gast)]

Hallo nochmal. Kann leider das Problem immernoch nicht lösen !
Kann mir jemand helfen ?

Nochmal zum Problem :

ich möchte ein Zeichen als Binärcode (4 Bit) darstellen :

Erstes  Bsp: 5 -> 0101
Zweites Bsp: B -> 1011

Leider bekomme ich mit meinem Code nur ein 7 Bit Binärcode heraus.

Ich möchte aber ein 4 Bit Binärcode. Wie mache ich das? Weiß das Jemand?

Liebe Grüße

[Klaus W. (mfgkw)]

versehentlich signed statt unsigned genommen?

PS: Ohne deinen Quelltext kann man lange raten.
Verstecke ihn gut, damit ihn nie jemand sieht!

[Stefan E. (sternst)]

Dass es bei 0 - 9 funktioniert, ist auch eher Zufall.

Du musst erst mal das Zeichen ('0' - 'F') in eine Zahl (0 - 15) 
umwandeln, bevor du anfangen kannst, diese Zahl dann binär auszugeben. 
Und nein, mit einer einfachen Zuweisung ist diese Wandlung nicht zu 
erreichen.

[DirkB (Gast)]

Wie kommst du denn überhaupt an deine 0 bis F?

[smoerre (Gast)]

> Erstes  Bsp: 5 -> 0101
> Zweites Bsp: B -> 1011

> Leider bekomme ich mit meinem Code nur ein 7 Bit Binärcode heraus.
> Ich möchte aber ein 4 Bit Binärcode.

Du meinst wahrscheinlich BCD-Zahlen im 8421-Code ?
A bis F sind dann sogenannte Pseudotetraden.
Soviel zu den Grundlagen.

> Ohne deinen Quelltext kann man lange raten.
> Verstecke ihn gut, damit ihn nie jemand sieht!
nicht ganz im Sinne des GNU Projekts ;-) insofern gibts auch nur vage 
Hinweise.

[P. Dammerow (Gast)]

Hallo . Da bin ich wieder.

P.S. Das was ich vor habe funktioniert immernoch nicht :o(

Zur Erinnerung:
1. Ich bekomme einen String (botschaft) über UART [botschaft[10]]
2. Das 9-te Zeichen botschaft[8] z.B. A möchte ich zu 4-Bit Binärcode
convertieren.
3. Die Funktion hex_to_bin soll mir den Code (z.B. 1010) als String 
liefern...

WAS MACHE ICH FALSCH????

P.S.
Das habe ich bereits gelesen...
http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F


Hier mein Code...

char botschaft[10];   // 9 Zeichen Botschaft

int main(void)
{
         // UART , LCD etc.. initialisieren

  while(1)
  {
         // Botschaft über UART empfangen (z.B. 00000000A)
         uart_gets( botschaft, sizeof( botschaft ) );    

         // 9-tes Zeichen des Strings als 4-Bit Binär convertieren
         set_cursor(0,2);lcd_string(hex_to_bin(botschaft[8]));
    }
  }
}

char* hex_to_bin(char hex)
{
      char temp[5];

    int bin;
    switch (hex)
    {
      case '0' : bin=0000; break;
      case '1' : bin=0001; break;
      case '2' : bin=0010; break;
      case '3' : bin=0011; break;
      case '4' : bin=0100; break;
      case '5' : bin=0101; break;
      case '6' : bin=0110; break;
      case '7' : bin=0111; break;
      case '8' : bin=1000; break;
      case '9' : bin=1001; break;

      case 'A' : bin=1010; break;
      case 'B' : bin=1011; break;
      case 'C' : bin=1100; break;
      case 'D' : bin=1101; break;
      case 'E' : bin=1110; break;
      case 'F' : bin=1111; break;
      default :  break;
    }

      itoa(bin, temp, 10);
      temp[4]='\0';

  return temp;
}

ERROR:
../LCD_v1.c:51: error: conflicting types for 'hex_to_bin'

Vielen Dank

[Peter (Gast)]

P. Dammerow schrieb:
> char* hex_to_bin(char hex)
> {
>   char temp[5];
>   return temp;
> }

das ist nicht zulässig, du darst NIEMALS ein zeiger auf eine lokale 
Variable zurückgeben

[Karl H. (kbuchegg)]

P. Dammerow schrieb:


und das

>     switch (hex)
>     {
>       case '0' : bin=0000; break;
>       case '1' : bin=0001; break;
>       case '2' : bin=0010; break;
>       case '3' : bin=0011; break;
>       case '4' : bin=0100; break;
>       case '5' : bin=0101; break;
>       case '6' : bin=0110; break;
>       case '7' : bin=0111; break;
>       case '8' : bin=1000; break;
>       case '9' : bin=1001; break;
>
>       case 'A' : bin=1010; break;
>       case 'B' : bin=1011; break;
>       case 'C' : bin=1100; break;
>       case 'D' : bin=1101; break;
>       case 'E' : bin=1110; break;
>       case 'F' : bin=1111; break;
>       default :  break;

ist zwar nett gedacht, aber ziemlicher Unsinn.

Kleiner Tipp:
0010
ist nicht das Bitmuster, bei dem das 2.te Bit eine 1 ist.

Das ist eine Oktalzahl. Genau genommen ist das dezimal 8
Aus demselben Grund ist auch 0011 nicht das Bitmuster, bei dem die 
untersten 2 Bit gesetzt sind, sondern wieder eine Oktalzahl, die dezimal 
gesehen den Wert 9 (oder binär 0b1001) aufweist.

Nur 1000 (bzw. alle nachfolgenden) die sind tatsächlich das was dort 
steht. Nämlich Ein-Tausend, Ein-Tausend-Eins, Ein-Tausend-Zehn, 
Ein-Tausend-Elf etc. etc.


Was ist falsch an der Kombination, wie schon weiter oben vorgeschlagen:

Den ASCII Code des Buchstabens hernehmen und daraus die richtige Zahl 
machen ....

uint8_t toBin( char c )
{
  if( c >= '0' && c <= '9' )
    return c - '9';

  return c - 'A' + 10;
}

... und danch itoa zu benutzen um sich dann aus einer Zahl eine 
textuelle Binärrepräsentierung besorgen zu lassen?

  while(1)
  {
         // Botschaft über UART empfangen (z.B. 00000000A)
         uart_gets( botschaft, sizeof( botschaft ) );    

         uint8_t value = toBin( botschaft[8]);

         set_cursor(0,2);
         lcd_string( itoa( value, buffer, 2 ) );
    }

(jetzt mal von fehlenden führenden 0-en abgesehen, was man noch lösen 
müsste)

[P. Dammerow (Gast)]

Danke für die ausführliche Antwort Karl Heinz.

Habe Deine (durchaus elegantere) Lösung eingearbeitet.
Um es zu verstehen, werde ich sicherlich etwas länger brauchen.
Es sieht schon super aus. Was ich leider noch nicht
hinbekomme ist folgendes :

uint8_t toBin( char c )
{
  if( c >= '0' && c <= '9' )
    return c - '9';
  return c - 'A' + 10;
}

Bei den Zeichen von 0 bis 9 bekomme ich immer nur 1111 heraus.
Bei A-F klappts super.

Danke

[DirkB (Gast)]

Es muss c - '0'; (nicht c - '9') heißen.

[Karl H. (kbuchegg)]

P. Dammerow schrieb:

> Bei den Zeichen von 0 bis 9 bekomme ich immer nur 1111 heraus.
> Bei A-F klappts super.


Muss ich mich entschuldigen.
Es bewahrheitet sich eben immer wieder: Egal wie banal ein Codestück 
erscheint. Egal wie oft man diese Funktion in der Vergangenheit schon 
geschrieben hat. Teste ihn vor dem Posten, den es gibt keinen Fehler der 
nicht banal genug wäre ihn noch einmal zu machen :-)

[P. Dammerow (Gast)]

Hallo Karl Heinz, hallo DirkB.
BITTE NICHT LACHEN !

Ich bekomme es leider nicht hin die führende Nullen in die Integer Zahl 
hinzuzufügen. Obwohl Deine (Karl Heinz) Lösung mir persönlich sehr gut 
gefallen hat.

Habe mir daher eine unsinnige Funktion geschrieben, die jedoch zu 
funktionieren scheint.
Ob diese resourcen-schonend ist, das wage sogar ich - als Anfänger - zu 
bezweifeln...

char bin[4];    // Variable für 4 Bit Binär als String

// Konvertiert HEX (Zeichen 0-F) in 4-Bit Binärcode
char* hex_to_bin(char hex)
{
      switch (hex)
    {
      case '0' : strcpy( bin, "0000"); break;
      case '1' : strcpy( bin, "0001"); break;
      case '2' : strcpy( bin, "0010"); break;
      case '3' : strcpy( bin, "0011"); break;
      case '4' : strcpy( bin, "0100"); break;
      case '5' : strcpy( bin, "0101"); break;
      case '6' : strcpy( bin, "0110"); break;
      case '7' : strcpy( bin, "0111"); break;
      case '8' : strcpy( bin, "1000"); break;
      case '9' : strcpy( bin, "1001"); break;
      case 'A' : strcpy( bin, "1010"); break;
      case 'B' : strcpy( bin, "1011"); break;
      case 'C' : strcpy( bin, "1100"); break;
      case 'D' : strcpy( bin, "1101"); break;
      case 'E' : strcpy( bin, "1110"); break;
      case 'F' : strcpy( bin, "1111"); break;
      default :  break;
    }
  return bin;
}

Aufruf...

// botschaft[8] beinhaltet Zeichen 0...F
lcd_string(hex_to_bin(botschaft[8]));

Liebe Grüße

[René H. (Gast)]

char bin[4];

muss sicher mal:

char bin[5];

sein, da ein string mit \0 abgeschlossen wird bei strcpy.

[DirkB (Gast)]

char* hex_to_bin(char *bin, char hex)

 find ich da sinnvoller.

Das itoa hast du aber auch benutzt?