2Bytes in einem vereinen --> Binärcode

[Flo (tuxianer)]

Hallo,
und zwar brauche ich für ein Projekt diese Umwandlung. Ich habe in einem 
Array 2 Zahlen. Byte1 ist die erste Stelle einer Zahl Byte2 die 2. und 
3.. Diese sind als Hexcode eingegeben, das dürfte ja aber kein Problem 
sein. Nun möchte ich die Zahl im Gesamten in Binärcode umwandeln. Dafür 
habe ich ein Array von 8 Feldern. Das ganze soll nur für zahlen bis 256 
funktionieren, dass wäre ausreichend. In einem weiteren Byte steht der 
Exponent.Hier mal ein Beispiel

Byte1: 2
Byte2: 46
Zahl: 246

Byte1:2
Byte2:4
Zahl=24

Ich dachte mir das so ich unterscheide zwischen Byte2<10 und dem Rest. 
Bei kleiner als 10 wird Byte1 mal 10 genommen und Byte2 addiert.

(2*10)+4=24

bei Zahlen größer gleich 10:
(2*100)+46=246. Das müsste ja so klappen. Nun möchte ich diese Zahlen 
nur noch in Binärcode umwandeln, und dann bitweise in ein Array 
schreiben.

Das ich dann folgendes Array habe bei 246: {1,1,1,1,0,1,1,0}. Bietet 
dafür GCC schon eine fertige Funktion?

Nun weis ich noch nicht, wie ich am besten die Sonderfälle der 10er 
Reihe behandle. Da muss ich den Exponent noch in meine Rechnung 
einfließen lassen.

Viele Grüße Florentin.

[Johannes M. (johnny-m)]

> Byte1:2
> Byte2:4
> Zahl=24
Wie willst Du denn da zwischen 24 und 240 unterscheiden? Das kann so 
nicht funktionieren.

Wenn ich das erste Beispiel richtig interpretiere, dann stellen jeweils 
4 Bit eine Dezimalstelle dar. Das ganze nennt sich gepackter BCD-Code. 
Wenn das ganze "rechtsbündig" dargestellt ist, wie im ersten Beispiel 
oben mit der 246, dann ist es ziemlich simpel:
- letzte Stelle (Einer) 1:1 übernehmen
- vorletzte Stelle mit 10 multiplizieren (Ursprungswert um 4 Bitstellen 
nach rechts schieben und dann multiplizieren, wenn Ausgangswert signed, 
dann vor dem Multiplizieren noch die 4 MSB ausmaskieren)
- erste Stelle mit 100 multiplizieren
- alles zusammenaddieren und fertig.

include <stdint.h>
uint8_t high, low;
uint8_t result;

result = (high & 0x0f)*100 + (low >> 4)*10 + (low & 0x0f);

[Flo (tuxianer)]

also ich hatte im ersten post geschrieben ich habe 3 Bytes
Byte1 ist die erste Stelle
Byte2 die 2. und 3. Stelle
Byte3 den Exponenten

http://www.frangenberg.info/zeug/GTRprotokoll hier das Protokoll, um 
welches es geht. Ich brauche nur Zahlen zwischen 0 und 256 und nur mit 
positiven Vorzeichen, also alles, was in ein byte reinpasst.
Deine Lösung war ja ohne Berücksichtigung des Exponenten.

Also die 24 wird gespeichert als 2,4e+01
die 240 als 2,4e+02

[Detlev T. (detlevt)]

Von so einem bescheuerten Protokoll habe ich vorher noch nie gehört. Ich 
sehe da eigentlich nur die Möglichkeit, die ganzen Ausnahmen einzeln 
abzuarbeiten.

char ergebnis;
char i, mask;
char array[8];

switch(byte3)
  {
    case 0: ergebnis = byte1;
            break;
    case 1: if(byte2 > 9) byte2 /=10;
            ergebnis = byte1 * 10 + byte2;
            break;
    case 2: if(byte2 < 10) byte2 *=10;
            ergebnis = byte1 * 100 + byte2;
  }

mask = 0x80;
for(i=0; i<8; i++)
  {
    array[i] = (mask & ergebnis)?1:0;
    mask >>=1; 
  }