3 hex werte in dezimalwert umwandeln

[holgie (Gast)]

Hallo zusammen,
ich habe 3 hexwerte in einem Array.
dat[0]=0x71
dat[1]=0x10
dat[2]=0x95 und möchte diese in einen Dezimalwert umwandeln. Es müsste 
also 7409813 ergeben. Ich erhalte jedoch 4245.
Ich hätte gedacht dass ich jeweils die Bits um 8 Stellen shiften muss. 
Im Internet habe ich aber etwas anderes gefunden was ich aber leider 
nicht verstehe und wohl auch nicht richtig umgesetzt bekomme. Vielleicht 
kann mir jemand weiterhelfen. Die wichtigen Stellen im Code habe ich mit 
Bemerkungen versehen. Ich hoffe die Infos sind ausreichend.
Gruß
Holger

Mein Code

 

unsigned char data[100],dat[6], a=0,b=0,c=0,d=0;
unsigned char wert[50];

while(1)
{ 
   a++;
   data[a] = uart_getchar();

if (data[a] == 0xFF && data[a-1] ==0x00 && data[a-2] ==0x08 && data[a-3]==0x01) 
  {
   b=1;
   a=5;
  }
if (b ==1 && data[a] == 0x69)
  {
   c=1;
  }
if (c ==1 && data[a] != 0x00 && data[a] != 0x01 && data[a] != 0x69)
  {
  //uart_putchar(data[a]);
    dat[d]=data[a];  //*****HEX WERT WIRD IN ARRAY übergeben*****
  uart_putchar(dat[d]);//**** die einzelnen Werte sind in Ordnung****
  uart_putchar(d);
    d++;
  }
if (c ==1 && data[a]==0x01)
  {
    uint32_t zahl = *(uint32_t*)dat;//*****HEX Array in uint32 umwandeln****
    itoa(zahl,wert,10);//*****zahl in wert konvertieren*****
    uart_putstring(wert);// *****Wert an uart übergeben******
    c=0;
    b=0;
    a=5;
    d=0;
  }

if (a >98)
  {
    a = 0;
  }

}

[Stefan (Gast)]

Hallo,

leider sagst du nichts darüber welche "Maschine" du verwendest.
Es gibt halt "big-endian" und "little-endian" Prozessoren und auch 
welche bei denen ist ein Integer 16 Bit lang und bei anderen 32 Bit.

Wenn du also einen 32-Bit Wert zusammen bastelst genügt es nicht 4 Bytes 
in ein Array zu schreiben und zu hoffen "das geht schon".

Wenn du es nicht weisst oder darum kümmern willst dann schreib

>>uint8_t  a,b,c,d;
>>uint32_t zahl;

>>zahl = (a<<24) | (b<<16) | (c<<8) | d;


dann macht es der Compiler für dich !!!

Spätestens bei itoa oder ltoa musst du wissen was Sache ist!!!

[MWS (Gast)]

Du musst die Chars erst casten, sonst können die Shifts darauf nicht 
richtig ausgeführt werden.

rslt = ((uint32_t) dat[0] << 16) + ((uint16_t) dat[1] << 8) + dat[2];

[Ralf G. (ralg)]

Günstig wäre, dat[0] mit einzulesen! ;-)

Stefan schrieb:
> Es gibt halt "big-endian" und "little-endian" Prozessoren

= ganz wichtig. Sauber wäre es die einzelnen Bytes entsprechend 
aufzuaddieren und nicht nur einen Zeiger draufzusetzen.
(siehe MWS (Gast))

[Olek (Gast)]

für sowas gibts den Datentyp "union"

union X
{
 byte A;
 byte B;
 int AB;
}

X.A = 0;
X.B = 1;


cout<<AB;

[Karl H. (kbuchegg)]

Olek schrieb:
> für sowas gibts den Datentyp "union"
>
> union X
> {
>  byte A;
>  byte B;
>  int AB;
> }

fast

union X
{
  struct {
    byte A;
    byte B;
  }
  int AB;
}

Du musst schon dafür sorgen, dass A und B auch hintereinander im 
Speicher angeordnet werden. So wie du das hast, werden alle 3 Member 
übereinander gelegt.

[Rolf Magnus (Gast)]

Olek schrieb:
> für sowas gibts den Datentyp "union"

Nein. Genau für sowas ist der nicht gedacht.