binärwert in Hex wert umwandeln

[Marc (Gast)]

Hallo.

ich hab einen Binärwert in einem BYTE stehen, und möchte diesen in ein 
Hex wert umwandeln.

Wie kann ich denn dass realisieren??

[Johannes M. (johnny-m)]

Da ist nichts umzuwandeln. Die Binärdarstellung ist nur eine andere 
Schreibweise...

[spess53 (Gast)]

Hi

Und wo ist das Byte?

MfG Spess

[Peter (Gast)]

für byte < 16
  hex = byte

[Tim R. (mugen)]

Erste Idee wäre:

1 * 2^0 bzw. (001)
1 * 2^1 bzw. (002)
1 * 2^1 bzw. (004)
1 * 2^1 bzw. (008)
1 * 2^1 bzw. (016)
1 * 2^1 bzw. (032)
1 * 2^1 bzw. (064)
1 * 2^1 bzw. (128)

Alles miteinander addieren und fertig müsste das Unterfangen sein. Viel 
Spaß!

[Stefan B. (stefan)]

Im allgemeinen indem du nichts machst.

Binärwert oder Hexwert oder Dezimalwert oder Oktalwert ist alles nur 
eine unterschiedliche Sicht auf den gleichen Zahlenwert im Register oder 
Speicher. Spezielle Zahlensysteme wie BCD mal aussen vor.

Wenn du Werte in Textform AUSGEBEN willst, d.h. eine spezielle Ansicht 
willst, dann musst du dich um das Format kümmern. Und bei der 
technischen Realisierung müsste man die verwendete Programmiersprache 
kennen...

[Johannes M. (johnny-m)]

Ein Byte enthält nur Nullen und Einsen. Wenn in einem Byte die Bitfolge

00101010

steht, dann ist das exakt dasselbe wie

2A (hexadezimal)
42 (dezimal)
52 (oktal)

Der Artikel Zahlensysteme ist leider (noch) ein bisschen dürftig, 
vielleicht mach ich mal was dran, wenn ich Zeit habe...

[Johannes M. (johnny-m)]

Stefan B. wrote:
> Und bei der
> technischen Realisierung müsste man die verwendete Programmiersprache
> kennen...
Hmmm, das "BYTE" oben lässt mich BASCOM erahnen...

[Kartoffel S. (kartoffelsalat)]

der Windoofrechner kann das ganz gut... (wens nur ums umrechnen geht)

[Stefan B. (stefan)]

Johannes M. wrote:

> Hmmm, das "BYTE" oben lässt mich BASCOM erahnen...

Da hast du mehr Glück als ich. Hier regnet es schon stundenlang in 
Strömen und meine Glaskugel ist stark beschlagen.

[Johannes M. (johnny-m)]

Stefan B. wrote:
> Da hast du mehr Glück als ich. Hier regnet es schon stundenlang in
> Strömen und meine Glaskugel ist stark beschlagen.
Wie, Du hast die draußen stehen? Oder ist das so eine verspiegelte, die 
man sich auf nem Stock ins Blumenbeet stellt?

;-)

[Marc (Gast)]

Hallo,

es geht darum, dass ich den Wert über die UART Schnittstelle auslese.
Diese frage ich mit dem Hyperterminal von Windows ab. Zurzeit gibt 
dieses mir sehr tolle Zeichen aus. Aber eigentlich sollte es in Hex 
erscheinen.

Programmiersprache ist C

[Justus S. (jussa)]

> es geht darum, dass ich den Wert über die UART Schnittstelle auslese.
> Diese frage ich mit dem Hyperterminal von Windows ab. Zurzeit gibt
> dieses mir sehr tolle Zeichen aus. Aber eigentlich sollte es in Hex
> erscheinen.

du willst also eine Zahl in einen String umwandeln...dazu gibt es die 
utoa()-Funktion, die kann auch unterschiedliche Zahlensysteme

[Marc (Gast)]

Ok und wie benütze ich diese Funktion?

[Justus S. (jussa)]

http://www.mikrocontroller.net/articles/FAQ#Wie_kann_ich_Zahlen_auf_LCD.2FUART_ausgeben.3F

wobei die aber auch einfach die Suche und/oder google benutzen hättest 
können...

[Andreas V. (tico)]

Marc wrote:
> Ok und wie benütze ich diese Funktion?
Echte Programmierer benutzen keine Funktionen. ;)

Ein Byte in eine ASCII-Darstellung im Hexformat umzurechnen ist ziemlich 
einfach:

void puthexbyte(uint8_t bt)
{
  uint8_t btnibble = (bt >> 4) & 0x0f;
  if (btnibble > 9)
    btnibble += 'a'-10;
  else
    btnibble += '0';
  sendchar(btnibble);

  btnibble = bt & 0x0f;
  if (btnibble > 9)
    btnibble += 'a'-10;
  else
    btnibble += '0';
  sendchar(btnibble);
}

Gruss
Andreas

[MichiB (Gast)]

oder einfach H-Term statt des Windows Terminal verweden, der kann alles 
darstellen.

[Matthias L. (Gast)]

>oder einfach H-Term statt des Windows Terminal verweden, der kann alles
>darstellen.

Das würde ich auch sagen. Das Hyperterminal ist Murks. Das stellt nur 
sichtbare Zeichen (ASCII) dar.

HTerm, der Terminal kann alles.

[Karl H. (kbuchegg)]

Matthias Lipinsky wrote:
>>oder einfach H-Term statt des Windows Terminal verweden, der kann alles
>>darstellen.
>
> Das würde ich auch sagen. Das Hyperterminal ist Murks. Das stellt nur
> sichtbare Zeichen (ASCII) dar.

Kommt immer drauf an, was das Ziel ist.
Wenn es um Debuggen von Kommunikation geht, ist HTerm sicher nicht zu 
schlagen. Wenn es darum geht, das ganze tatsächlich wie ein Terminal 
einzusetzen (also als Ausgabemedium für ein Programm), ist IMHO HTerm zu 
technisch angehaucht.

[Marc (Gast)]

@Andreas

Wenn ich das so in mein Programm einfüge, kommt ein Fehler beim 
Compaillieren.
In Welche "Variable" muss ich meinen zu wandelnden Wert schreiben??

Fehler:
 identifier "uint8_t" is undefined

[Karl H. (kbuchegg)]

Marc wrote:
> @Andreas
>
> Wenn ich das so in mein Programm einfüge, kommt ein Fehler beim
> Compaillieren.
>
> Fehler:
>  identifier "uint8_t" is undefined

du musst nach inttypes.h inkludieren

#include <inttypes.h>


> In Welche "Variable" muss ich meinen zu wandelnden Wert schreiben??

Gar nicht. Andreas hat sich selbst ein Ei gelegt. Er wollte eigentlich 
sagen: Echte Programmierer benutzen keine Funktion, die sie nicht selbst 
geschrieben haben (was zumindest eine fragwürdige Aussage ist).

Das ist nach wie vor eine Funktion, und wird auch als solche benutzt.

int main()
{
  ...
  puthexbyte( 23 );
  puthexbyte( 0x56 );
}

[Andreas V. (tico)]

Karl heinz Buchegger wrote:
> Gar nicht. Andreas hat sich selbst ein Ei gelegt. Er wollte eigentlich
> sagen: Echte Programmierer benutzen keine Funktion, die sie nicht selbst
> geschrieben haben (was zumindest eine fragwürdige Aussage ist).

Das ist völlig richtig. Deshalb hatte ich auch ein ;) hinter die Aussage 
geschrieben, was soviel heißen sollte wie "Nicht ernst gemeint".

Gruss
Andreas

[Marc (Gast)]

Hallo,

also ich habs nun doch ganz anderst gemacht.

Programm:


else if (UARTRXBuff[3] == (ModuleNr+'0') && UARTRXBuff[4] == '.' && 
UARTRXBuff[5] == '2' && !IO)
                {
                  NewDataD = FALSE;
                  UARTTXLen = 0;
                  UARTTXBuff[0] = 'E';
                  UARTTXBuff[1] = 'W';
                  UARTTXBuff[2] = ModuleNr+'0';
                  UARTTXBuff[3] = '.';
                  UARTTXBuff[4] = '2';
                  UARTTXBuff[5] = '=';

                  if( DataADCHighHigh <= 9)
                    UARTTXBuff[6] = DataADCHighHigh +'0';
                  else if ( DataADCHighHigh > 9 && DataADCHighHigh <= 
16)
                    UARTTXBuff[6] = DataADCHighHigh + '7';        // 
DataADCLow + '7' ergibt z.B bei DataInLow =10 den Wert 10+55=65 Dez wert 
für A

                   if( DataADCHighLow <= 9)
                    UARTTXBuff[7] = DataADCHighLow +'0';
                  else if ( DataADCHighLow > 9 && DataADCHighLow <= 16)
                    UARTTXBuff[7] = DataADCHighLow + '7';

                  if( DataADCLowHigh <= 9)
                    UARTTXBuff[8] = DataADCLowHigh +'0';
                  else if ( DataADCLowHigh > 9 && DataADCLowHigh <= 16)
                    UARTTXBuff[8] = DataADCLowHigh + '7';

                  if( DataADCLowLow <= 9)
                    UARTTXBuff[9] = DataADCLowLow +'0';
                  else if ( DataADCLowLow > 9 && DataADCLowLow <= 16)
                    UARTTXBuff[9] = DataADCLowLow + '7';        // 
DataADCLow + '7' ergibt z.B bei DataInLow =10 den Wert 10+55=65 Dez wert 
für A

                  UARTTXLen = 10;
                  UARTSendPacket();
                }

[Karl H. (kbuchegg)]

Dein Code lässt mich schaudern.
Man muss 40 Sekunden konzentriert hinschauen um sich zu vergewissern, 
dass du keinen CopyPaste Fehler mit all den ...HighLow ...LowHigh etc 
gemacht hast.

An dieser Stelle ist doch eine Funktion eine perfekte Waffe, das Chaos 
einzudämmen.

char toHexDigit( unsigned char Value )
{
  if( Value <= 9 )
    return Value + '0';

  return Value + '7';
}


...

                  UARTTXBuff[4] = '2';
                  UARTTXBuff[5] = '=';

                  UARTTXBuff[6] = toHexDigit( DataADCHighHigh );
                  UARTTXBuff[7] = toHexDigit( DataADCHighLow );
                  UARTTXBuff[8] = toHexDigit( DataADCLowHigh );
                  UARTTXBuff[9] = toHexDigit( DataADCLowLow );

                  UARTTXLen = 10;
                  UARTSendPacket();
...

Das ist nicht nur kürzer, es ist auch leichter sich davon zu überzeugen 
das er korrekt ist. Man sieht besser in welcher Reihenfolge die 
einzelnen Bytes gesendet werden und falls mal umgestellt werden muss ist 
das auch einfacher.

Solch wiederkehrende Muster, wie du sie im Original hattest, lohnen sich 
immer in Funktionen ausgelagert zu werden! Alleine dadurch, dass der 
Code kürzer und damit besser überblickbar ist, hat man schon an Qualität 
gewonnen!

[Karl H. (kbuchegg)]

Falls du übrigens genug Platz in deinem µC hast, kann man hier auch 
sprintf sinnvoll ins Spiel bringen (für nicht benutzten Flash kriegt man 
kein Geld zurück. Es lohnt also nicht, sich selbst ne Menge Arbeit zu 
machen, wenn dann ohnehin 50% des Flash brach liegen. Da kann man dann 
auch getrost solch eierlegende Wollmilchsäue wie sprintf zum Einsatz 
bringen)

   else if (UARTRXBuff[3] == (ModuleNr+'0') &&
            UARTRXBuff[4] == '.' &&
            UARTRXBuff[5] == '2' &&
            !IO)
  {
    NewDataD = FALSE;
    sprintf( UARTTXBuff, "EW%1d.2=%04x", ModuleNr, DataADC );
    UARTTXLen = 10;
    UARTSendPacket();
  }

[Gast (Gast)]

>In Welche "Variable" muss ich meinen zu wandelnden Wert schreiben??

Da fehlen gravierende C Kenntnisse. Erstmal ein C Tutorial durch 
arbeiten. Wenn man Funktionen nicht kennt kann man sie auch nicht 
einsetzen.

[Marc (Gast)]

Das stimmt ich hab bisher immer assembler programmiert und Denke für C 
noch viel zu detailliert und kompliziert.

[Karl H. (kbuchegg)]

Marc wrote:
> Das stimmt ich hab bisher immer assembler programmiert und Denke für C
> noch viel zu detailliert und kompliziert.

Dann wirds Zeit für Literatur.
Die C-Library ist nicht sehr umfangreich, aber die 10 oder 20 
wichtigsten Funktionen sollte man schon kennen um sie bei Bedarf richtig 
einzusetzen zu können.

Auch der ganze Bereich rund um String-Verarbeitung ist etwas, das man 
mit Versuch&Irrtum nicht richtig lernen kann.

Dann noch die Devise "Das ist mir jetzt an dieser Stelle zu kompliziert, 
dafür schreib ich mir eine eigene Funktion". Hochsprachen machen es 
einem Programmierer leicht, sich Funktionen für alles Mögliche zu 
schreiben. Dadurch, dass man sich um deutlich weniger kümmern muss als 
in Assembler (Register sichern, Argumente auf den Stack packen oder 
irgendwo im Speicher parken) ist es sehr viel einfacher ein Programm in 
kleinere, überschaubare Codeteile zu zerlegen. Der Codequalität, im 
Sinne eines lesbaren wartbaren Programms, kommt sowas immer zugute. Wenn 
dann doch mal der Fall eintritt, dass die Funktionsaufrufe zu 
kostspielig sind, gibt es immer noch Mittel und Wege, wie man das 
vermeiden kann.