2 8bit in eine 16bit Zahl

Falls das C sein soll:
Ohne Type cast ist das wahrscheinlich falsch. Außerdem kann Schieben je 
nach Prozessor recht ineffizient sein.
Einfacher ist es mit einer union

union _Word
    {
    int Ergebnis;
    struct
         {
         char ECCPR1L;
         char ECCPR1H;
         };
    }Speicher;

int Test;
Speicher WordVariable;
char Var1;
char Var2;

WordVariable.ECCPRIL = Var1;
WordVariable.ECCPRIH = Var2;

Test = WordVariable.Ergebnis;

Christoph Herzog schrieb:
> und | ist ein oder? quasi um den untern teil der 16 bit zubeschreiben?

C-Grundlagen lernen!!

> ECCPR1L
klingt nach Hardware-Register, das geht nicht mit union

Warum muß das hier denn alles so kompliziert gelöst werden ??

Du definierst eine unsigned int-Variable namens Ergebnis und baust diese 
dann aus den beiden 8-Bit Werten wert1 (High-Byte) und wert2 (Low-Byte) 
zusammen:

unsigned int Ergebnis;

Ergebnis = wert1 * 256 + wert 2;    // Fertig !!

Das kann jeder C-Compiler der Welt verarbeiten.

Gute Compiler machen aus dem Teil ´* 256´ dann noch automatisch ein 
Links-Shift, weil das dann schneller geht als die echte Multiplikation, 
also

Ergebnis = (wert1 << 8) + wert2;

Womit wir dann wieder beim Anfang des Threads sind, der doch richtig war 
!!
Nur Ergbnis muß als unsigned int def. werden

Schieber

@Christoph Herzog
Vielleicht ist mein kostenloser Grundlagen-C-Kurs etwas für Dich
http://et-tutorials.de/mikrocontroller/

Moin,
wieso reicht dir das Angebot nicht?

Hier gibt es einen PIC(18) Tutorial:
http://pic-projekte.de/pic_tutorial.html

Und hier eins für PIC Programmierung in C:
http://pic-projekte.de/pic_c.html

Gruß
Andreas

Alles beschrieben funktioniert natürlich nur mit vorzeichenlosen Werten.

Die union Konstruktion funktioniert nicht mit Hardware variablen, da in 
der struct ja nur neue Namen vergeben werden. Sind die schon belegt, 
meckert der Compiler. Schneller ist die union allemal.

Aber auch wenn der Compiler x*256 zu x<<8 optimiert, so wird er doch 
Probleme haben, das + zu optimieren. Je nach CPU ist | bedeutend 
schneller als +, wobei in diesem speziellen Fall beide Operationen zum 
gleichen Ergebnis führen.

Also lieber:

Ergebnis = (((uint16_t) high) << 8) | low;

Es ist ausserdem wichtig, dass "high" zuerst in eine 16 bit Zahle 
gewandelt wird, und dann erst nach links geshiftet wird. Daher nochmal 
zwei Klammern (auch wenn sie nicht unbedingt nötig wären).

Ähm Leute:

1

Ergebnis = ( ECCPR1H << 8 );

2

Ergebnis = Ergebnis + ECCPR1L;

Das H und das L impliziert doch, das ein HIGH und ein LOW Register ist.
Und da gehe ich davon aus, dass es auch ein 16bit-Pondon gibt:

1

Ergebnis = ECCPR1;

Der Compiler kümmert sich dann schon.