vier 8bit-zahlen (char) in eine 32bit-zahl wandeln

[Stefan H. (stefan0985)]

Hallo zusammen.
ich habe ein problem, bei dem ich dringend hilfe brauche, da ich sonst 
mit meinem projekt nicht weiter kommme.
(Ich programmiere einen Atmega128 in C mit AVR Studio)
und zwar: ich habe ein array[4]
z.b.
char array[4];

array[0]=0xA1;
array[1]=0xB2;
array[2]=0xC3;
array[3]=0xD4;

welches eine Zahl darstellt.

Zahl=0xA1B2C3D4;

Mit dieser Zahl muss ich einiges rechnen.
Meine Fragen:
Wie muss ich die Variable Zahl definieren? ich denke: long int Zahl;
Was hat es mit uint32_t uint16_t auf sich?
wie wandel ich das array in eine zusammenhängende Zahl um?
ich habe dazu schon einiges versucht. z.b. die zahl einfach direkt 
zusammen zufügen:
Zahl=(unsigned 
long)((array[0]<<24)|(array[1]<<16)|(arrayr[2]<<8)|(array[3]));

dabei bekomm ich aber folgende warining:
warning: left shift count >= width of type

für 2byte funktioniert es.

auch mit der funktion "strtoul" hab ich kein ergebniss bekommen

Zahl=strtoul(array,(void *) 0,16);

es muss doch eine möglichkeit geben im atmega128 mit einer 32bit großen 
zahl rechnen zu können oder?

vielen vielen dank für etwaige hilfe

stefan

[Justus S. (jussa)]

Stefan Haller schrieb:

> dabei bekomm ich aber folgende warining:
> warning: left shift count >= width of type

ist jetzt nur geraten: vielleicht solltest du die einzelnen Zahlen erst 
in long ints umwandeln und dann shiften...

[Rufus Τ. F. (rufus)]

So kann man das machen, allerdings ist das nicht portabel, d.h., es 
verhält sich von Prozessorarchitektur zu Prozessorarchitektur 
unterschiedlich:

uint8_t array[4];
uint32_t Zahl;

array[0]=0xA1;
array[1]=0xB2;
array[2]=0xC3;
array[3]=0xD4;


Zahl = *((uint32_t *) array);

Das Problem hierbei ist die endianness, die darüber bestimmt, in 
welcher Reihenfolge die vier einen 32-Bit-Wert ausmachenden Bytes im 
Speicher abgelegt werden. Auf einer "big-endian"-Architektur wie z.b. 
68000 ist das Ergebnis obiger Aktion 0xA1B2C3D4, auf einer 
"little-endian"-Architektur wie z.B. x86 ist das Ergbnis hingegen 
0xD4C3B2A1.

Wie es auf einem 8-Bit-System wie dem AVR implementiert wird, hängt rein 
vom verwendeten Compiler ab; dem Controller selbst ist es vollkommen 
wurscht, da der sowieso nur 8-Bit-Zahlen kennt.

[Karl H. (kbuchegg)]

Stefan Haller schrieb:

> char array[4];

schon falsch.
Du willst hier auf keinen Fall 'char'
Du willst entweder 'unsigned char' oder 'signed char'. Aber auf keinen 
Fall 'char'

> array[0]=0xA1;
> array[1]=0xB2;
> array[2]=0xC3;
> array[3]=0xD4;
>

  uint32_t zahl = *(uint32_t*)array;

aber pass auf die Endianess auf. (kurz gesagt: die Reihenfolge der Bytes 
im Array)

> es muss doch eine möglichkeit geben im atmega128 mit einer 32bit großen
> zahl rechnen zu können oder?

Klar gibt es die.