leichte c-frage

[Dieter (Gast)]

ich hab zwei 8bit-register (low und high). da drin steht ein 16 bit
wert.
wie bekomm ich den in eine integervariable?

und zwar in C?

bestimmt leicht, hab ich aber noch nie gemacht, und ich lern doch durch
doing und probiering. :)

danke im voraus.
gruß
dieter

[crazy horse (Gast)]

der "offizielle" Weg: ergebnis=256*high_byte + low_byte.
Allerdings gilt es dabei aufzupassen, meiner Erfahrung nach arbeiten
Compiler da verschieden, da die Operanden 8-Bit-Variablen sind, kann es
sein, dass erst mit nur 8bit gerechnet wird, anschliessend der
16bit-Variable zugewiesen wird, das Ergebnis ist dann natürlich falsch.
Abhilfe schafft dann der int-operator, dann wird auf jeden Fall mit
16bit gerechnet.
Statt der Multiplikation mit 256 kann natürlich auch 8faches schieben
nach links benutzt werden (high_byte<<8), ist auf jeden Fall viel
schneller.
Mit pointern gehts noch eleganter, aber das mach mal später :-)

[Matthias (Gast)]

Hi

x*256 wird vom Compiler eh als <<8 ausgeführt.

intvar=(unsigned int)highc<<8|lowc;

Die Addition kann man sich an dieser Stelle sparen und auf ein
logisched oder zurückführen. Das ganze sollte vom Compiler auf wenige
Befehle (idealerweise 2, sofern alle Werte in Registern stehen)
reduzieren.

Matthias

[crazy horse (Gast)]

ob ich addiere oder ein "oder" durchführe, dürfte kaum einen
Unterschied machen.
Aber ob der Compiler *256 automatisch durch <<8 ersetzt? Werde ich
gleich mal probieren, glaube ich eigentlich nicht.

[Andreas Haimberger (Gast)]

//Zwei 8bit-Werte zu einem 16bit-Wert kombinieren:

void main(void)
  {
    union kombi
    {
      unsigned char byte[2];
      unsigned int word;
    } i;

    unsigned int zahl;
    unsigned char lowbyte = 100;
    unsigned char highbyte = 50;

    i.byte[0] = lowbyte;
    i.byte[1] = highbyte;
    zahl = i.word; //Zahl hat den Wert 12900
  }

//Grüße, Andy

[crazy horse (Gast)]

@andi: der ist gut!
ich habs sonst in der Art:
word=byte_low;
*(ptr+1)=byte_high;
Deine Lösung gefällt mir aber besser.

@matthias
Der Compiler ersetzt *256 tatsächlich.
Addition/Oder ist Jacke wie Hose, zwar anderer Code (logisch), aber
gleiche Grösse und gleich Taktzahl.

[Peter (Gast)]

ich würde einfach high*256+low nehmen.
Andys Lösung sieht zwar toll und schnell aus, aber das täuscht.
Die geht immer über das SRAM (wie die tricks mit Zeigern auch) und der
Compiler kann das nicht optimieren selbst wenn genug register frei
sind.

Peter

[Dieter (Gast)]

danke jungs. ich werds mit high*256+low probieren.