Aus 2 char ein unsigned int erzeugen

[Sebastian (Gast)]

Hallo @ all

Ich möchte Daten von den Ports einlesen. Der Datenbus ist 8 Bit breit. 
Zuerst übertrage ich das Low-Byte und anschließend das High-Byte. Danach 
möchte ich das Low-Byte und High-Byte zusammenfassen zu einem unsigned 
int. Hier mein Quellcode:

bit status;
char low_byte, high_byte;


if(status == LOW_BYTE)
{
   low_byte = PINC;
   status = HIGH_BYTE;
}
else
{
   high_byte = PINC;

   ptr_datenpuffer[i] = high_byte;
   ptr_datenpuffer[i] = ptr_datenpuffer[i] << 8;
   ptr_datenpuffer[i] = low_byte;

   status = LOW_BYTE;
}

Ich dachte das durch die Wertzuweisung die unteren 8 Bits des unsigned 
int beschrieben werden. Anschließend wollte ich das ganze um 8 Stellen 
nach links schieben und dann das Low-Byte zuweisen. Dies scheint so aber 
nicht zu funktionieren

Grüsse

Sebastian

[Obelix (Gast)]

Du überschreibst den wert damit.
x=(hi << 8) + lo;

[Sebastian (Gast)]

Ist x=(hi << 8) + lo; denn die Lösung?

[Rahul D. (rahul)]

>   ptr_datenpuffer[i] = high_byte;
>   ptr_datenpuffer[i] = ptr_datenpuffer[i] << 8;
>   ptr_datenpuffer[i] = low_byte;

Oder einfacher und kürzer:

ptr_datenpuffer[i] = ((int) high_byte )<<8) | low_byte;

[Obelix X. (obelix)]

@Sebastian : ja, aber schau dir noch mal das Beispiel von Rahul an. 
(Typenumwandlung)


x=((unsigned int)hi << 8) + lo;

[Tobias R. (tobiasrohde)]

oder so:

union{ unsigned short u_s;
       char u_c[2];
     }convert_var;

convert_var.u_c[0]=byte_1;
convert_var.u_c[1]=byte_2;

Ergebniss:

convert_var.u_s;

[Andreas S. (andreas) (Admin)]

Die Lösung mit der Union ist kein sauberes C, weil man je nach 
Compiler/Prozessor verschiedene Ergebnisse bekommen kann (Stichwort 
Endianness), deshalb sollte man lieber Shifts verwenden.

[Sebastian (Gast)]

ptr_datenpuffer[i] = (((int) high_byte )<<8) | low_byte;

Wieso muss der Datentyp vom low_byte nicht verändert werden? Schließlich 
führe ich doch eine Veroderung von zwei unterschiedlichen Datentypen 
durch.

Grüsse

Sebastian

[Lötnagel (Gast)]

Vorschlag: ausschießlich unsigned verwenden, zb so:

bit status;
unsigned char low_byte, high_byte;

// unsigned short ptr_datenpuffer[300];

if(status == LOW_BYTE)
{
   low_byte = PINC;
   status = HIGH_BYTE;
}
else
{
   high_byte = PINC;
   ptr_datenpuffer[i] = (high_byte<<8)+low_byte;
   status = LOW_BYTE;
}

[Sebastian (Gast)]

Wieso braucht man denn mit einmal keine Typenumwandlung mehr?

[Lötnagel (Gast)]

>Wieso braucht man denn mit einmal keine Typenumwandlung mehr?

Das erledigt der Compiler. Unsigned char und unsigned short haben
ja schon den gleichen Typ, nur unterschiedliche Größe.

[Random .. (thorstendb)]

Hi,

wie wärs mit


int intvalue=0;
char *low_byte = (char*) &intvalue;
char *high_byte = (char*) (&intvalue)+1;

Schneller gehts nicht, weil hier nicht gerechnet werden muss. Die ARMs 
haben idR. nen Barrelshifter drin, so dass man da in einem Takt bis zu 
32Bit shiften kann. Die AVRs glaub ich nicht...


Greetz,
/th.

[Sebastian (Gast)]

Ich habe mich jetzt für diese Lösung entschieden

(((int) high_byte )<<8) | low_byte;

Vielen Dank für die Antworten. Es war sehr Aufschlußreich

Grüsse

Sebastian

[Johannes M. (johnny-m)]

Sebastian wrote:
> Ich habe mich jetzt für diese Lösung entschieden
>
> (((int) high_byte )<<8) | low_byte;
Das kann aber auch nach hinten losgehen. Schiebeoperationen sollte man 
möglichst nur mit vorzeichenlosen Datentypen machen.

[Willi W. (williwacker)]

wieso castest Du nach int, Du wolltest doch eigentlich unsigned?

[Sebastian (Gast)]

Mein Fehler im Quellcode habe ich natürlich

ptr_datenpuffer[i] = (((unsigned int) high_byte )<<8) | low_byte;

benutzt

[Andreas S. (andreas) (Admin)]

Thorsten De buhr wrote:
> int intvalue=0;
> char *low_byte = (char*) &intvalue;
> char *high_byte = (char*) (&intvalue)+1;

Auch das ist nicht portabel. Je nach Prozessor kann es sein dass das 
low_byte hier gar nicht das low byte ist, sondern das high byte.

> Schneller gehts nicht, weil hier nicht gerechnet werden muss. Die ARMs
> haben idR. nen Barrelshifter drin, so dass man da in einem Takt bis zu
> 32Bit shiften kann. Die AVRs glaub ich nicht...

Der Compiler setzt das beim AVR in zwei Byte-Zugriffe um, geschoben wird 
da gar nicht.

[STK500-Besitzer (Gast)]

>> int intvalue=0;
>> char *low_byte = (char*) &intvalue;
>> char *high_byte = (char*) (&intvalue)+1;

>Auch das ist nicht portabel. Je nach Prozessor kann es sein dass das
>low_byte hier gar nicht das low byte ist, sondern das high byte.

Das was Thorsten vorgeschlagen hat, macht doch eigentlich der Compiler, 
wobei dieser dann auch die richtige Zuordnung (Position der Bytes) 
trifft, oder?

[Random .. (thorstendb)]

shiftet denn der avr 8x in einem takt?

[Andreas S. (andreas) (Admin)]

Der AVR shiftet überhaupt nicht, weil der Compiler schlau genug ist 
einen 8-Bit-Shift durch einen entsprechenden Bytezugriff zu ersetzen.