Um 4 nach links schieben

Johann schrieb:
> Hallo @ all
>
> Ich habe einen Wert vom Datentype unsigned int (16Bit)
>
> diesen möchte ich jetzt um zwei stellen nach links schieben (also mit 4
> multiplizieren)
>
> anschließend möchte ich das Ergebnis in 2 Werte vom Datentye unsigned
> char (8Bit) zerlegen.
>
> hier ist mein Code
>
> unsigned int test = 4096;
> unsigned char HIGHBYTE, LOWBYTE;
>
> test = test << 2;
>
> HIGHBYTE = ((unsigned char) ((unsigned int)(neue_spiegelposition)));
> LOWBYTE = ((unsigned char) (((unsigned int)(neue_spiegelposition)) >> 8
> ));
>
> IST DAS SO RICHTIG?

Probiers aus.

PS: WEnn du mit 4 multiplizieren willst, dann multiplizier auch mit 4.

   test = test * 4;

Wenn es einfacher ist, das durch eine Schiebeoperation zu ersetzen, dann 
macht das der Compiler für dich.

Johann schrieb:
> Ich kann es schlecht testen. Wird durch die Schiebeoperation das Bit 0
> und 1 mit 0 azfgefüllt?

Ja. Aber wie gesagt. Darum brauchst du dich nicht kümmern. Wenn du mit 4 
multiplizieren willst, dann schreib das auch so hin und überlass die 
Details dem Compiler.

Kümmere dich lieber darum, warum das High-Byte wohl High-Byte heisst und 
wie man es daher kriegen wird.

Da (m.W. bei AVR zumindest) die Laufzeit beim Schieben mit der Anzahl
der Stellen steigt, um die geschoben wird, wäre es geschickter,
nur den ersten Wert (zwei nach links) so zu gewinnen, den zweiten (2
nach links und wieder 8 nach rechts) aber besser durch den Originalwert
um 6 nach rechts nur geschoben.

Abgesehen davon, daß du test initialisierst und shiftest, aber
dann neue_spiegelposition verwendest...

Klaus Wachtler schrieb:
> Da (m.W. bei AVR zumindest) die Laufzeit beim Schieben mit der Anzahl
> der Stellen steigt, um die geschoben wird, wäre es geschickter,
> nur den ersten Wert (zwei nach links) so zu gewinnen, den zweiten (2
> nach links und wieder 8 nach rechts) aber besser durch den Originalwert
> um 6 nach rechts nur geschoben.

Das wäre ziemlich kontraproduktiv.
Dein Compiler kennt nämlich einen Trick, wie er Schieben um 8 Stellen 
nach rechts realisiert: Er verwirft einfach das Low-Byte und greift 
direkt auf das High Byte zu.

@z8:
Anstatt für LOWBYTE den bereits um 2 nach links geshifteten Wert
um 8 nach rechts zu schieben, schlug ich vor, den Originalwert
zu nehmen und nur um 6 nach rechts zu schieben, was auf den
gleichen Wert herauskäme.

@kbuchegg:
Natürlich auch wieder wahr.
Wenn es nach dem Optimieren nicht vielleicht ohnehin aufs
selbe rausläuft...

ja