Bit Manipulationene

Mal angenommen...

unsigned int uInteger;
unsigned char ucChar1, ucChar2;

dann ...

uInteger = 0xFFFF;

ucChar1 = (unsigned char)(uInteger>>8);
ucChar2 = (unsigned char)uInteger;

Wo ist das Problem?

kurze c einführung:
-also "int" hat 2 Bytes, "char" hat 1 Byte.
-"unsigned" sagt dass es eine vorzeichenlose variable ist
-ein cast "interpretiert" den wert nicht, sondern nimmt den inhalt,
der an der adresse steht und "denkt" es sei der typ, der bei mcast
angegeben wurde.
- x >> n bedeutet, dass x um n stellen nach rechts geschoben (nicht
rotiert!) wird.

nun zum Beispiel oben:

uInteger scheint ein unsigned int zu sein.
zu ucChar1 (von innen nach außen): uInteger um 8 Stellen nach rechts
schieben (also das letzte Byte/letzten beiden Hex-Stellen streichen)
und dann als ein byte behandeln
zu ucChar2: den wert von uInteger als ein byte (unsigned char)
betrachten (das vordere byte streichen).

Für die Bit-Manipulation kannst du dir einfach folgendes merken:
x |=  (1 << n)    "oder ist": setze bit n in variable x
x &= ~(1 << n)    "und ist" mit komplement ("~"): lösche bit n in
variable x
x ^=  (1 << n)    "xor ist": schalte bit n in variable x um (in den
entgegengesetzten zustand)
x & (1 << n)     test, ob bit n in variable x gesetzt


also nun ein beispiel:
~(   0101 1010)   (0x5A)
=    1010 0101   (0xA5)

     0101 1010   (0x5A)
|=   0010 0000   (1 << 5) = (0x20)
---------------
     0111 1010

     0101 1010   (0x5A)
&=   0000 1000   (1 << 3) = (0x04)
--------------
     0000 1000

     0101 1010   (0x5A)
&=   1110 1111   ~(1 << 4) = (0xef)
--------------
     0100 1010

     0101 1010   (0x5A)
^=   1000 0000   (1 << 7) = (0x80)
--------------
     1101 1010

     1101 1010
^=   1000 0000   (1 << 7) = (0x80)
--------------
     0101 1010

Daß ein integer (int) zwei Bytes hat, ist aber nicht C-Spezifisch,
sondern Architekturbedingt! Auf 32-Bit-Prozessoren ist

    sizeof(int) == 4!

Danke!

Wie dieses Verfahren funktioniert ist mir jetzt klar geworden.

das ist mir schon klar, aber ein 4 byte oder 8 byte (wie es mal für die
64bit prozessoren angedacht war - aber nicht gemacht wurde) int auf
einem microcontroller ist recht unwahrscheinlich...

Oder hier ist einer Selbstmordgefährtet und fängt gleich mit 32 bit
microcontrollern an... ;)

Man nehme zum Beispiel einen ARM7 (zb LPC2106)...

Aber das spielt ja auch keine Rolle, ich wollte auf Deine "fehlerhafte
Einführung in C" hinweisen ;-)

ok, danke.
hinweis zur kenntnis genommen... .)