X. Y. schrieb:
> Karl H. schrieb:
>> Du scheinst mit Bitoperationen und wie und warum man sie einsetzt auf
>> Kriegsfuss zu stehen. Stell das ab! Bitoperationen sind in der
>> µC-Programmierung täglich Brot. Da darf es keine Unsicherheiten geben.
>
> habs mir schon gedacht, das ich so auf die fresse falle. :(
>
> ich stehe mit bitmanipulation wirklich noch auf dem kriegsfuß
>
> kennt ihr nen gutes tut. dafür? das auf dieser seite finde ich nicht so
> gut erklärend
was brauchst du?
Grundlage sind die Bitoperationen UND und ODER (und NICHT). In C
SChreibweise & (für UND) bzw. | (für ODER)
Wie sieht deren Funktionstabelle (für 2 einzelne Bits) aus?
Hast du 2 Bits A und B, dann
1 | ODER:
|
2 |
|
3 | A B Ergebnis
|
4 | ------------------------
|
5 | 0 0 0
|
6 | 0 1 1
|
7 | 1 0 1
|
8 | 1 1 1
|
9 |
|
10 | UND:
|
11 |
|
12 | A B Ergebnis
|
13 | ------------------------
|
14 | 0 0 0
|
15 | 0 1 0
|
16 | 1 0 0
|
17 | 1 1 1
|
was fällt uns auf?
In der Oder Operation. Wenn wir einmal das Bit A als eine vorgegebenen
Wert ansehen, dann
* ist das Bit A auf 0, dann ist das Ergebnis dasselbe wie das Bit B
ist Bit B auf 0, dann ist auch das Ergebnis 0. Ist das Bit B auf 1, dann
ist auch das Ergebnis 1. D.h. das Ergebnis spiegelt den Zustand von Bit
B wieder
* ist das Bit A auf 1, dann ist das Ergebnis auf jeden Fall auf 1
D.h. wenn ich das Bit A auf 1 habe, dann kann ich im Ergebnis auf jeden
Fall ein 1 Bit erzwingen. Ist das Bit A aber auf 0, dann ändert sich
nichts. Das Ergebnis hat denselben Wert wie das Bit B
1 | ODER:
|
2 |
|
3 | A B Ergebnis
|
4 | ------------------------
|
5 | 0 0 0 <- Ergebnis ist identisch zu Bit B
|
6 | 0 1 1
|
7 |
|
8 | 1 0 1 <- Ergebnis ist auf jeden Fall 1
|
9 | 1 1 1
|
Was fällt in der Und Operation auf?
Wieder sei das Bit A dasjenige Bit, dessen Wert (0 oder 1) ich
kontrolliere. Wie ist der Zusammenhang zwischen dem Ergebnis und dem Bit
B?
Nun ganz offensichtlich ist, dass das Ergebnis den Zustand vom Bit B
wiederspiegelt, wenn Bit A auf 1 ist. Ist das Bit A hingegen auf 0, dann
kommt im Ergebnis immer 0 raus, egal welchen Wert Bit B hat.
D.h. mit dieser Operation kann ich ein Bit auf 0 zwingen, indem ich
dafür sorge, dass (wenn ich dieses erreichen will) das Bit A den Wert 0
hat.
1 | UND:
|
2 |
|
3 | A B Ergebnis
|
4 | ------------------------
|
5 | 0 0 0 <- Ergebnis ist auf jeden Fall 0
|
6 | 0 1 0
|
7 |
|
8 | 1 0 0 <- Ergebnis ist identisch zu Bit B
|
9 | 1 1 1
|
In C ist es jetzt so, dass diese Bitoperationen UND bzw. ODER für alle 8
Bits eines Bytes gleichzeitig gemacht werden. Habe ich also 2 Operanden
dann werden die 8 Bits von Wert mit dem jeweils stellenmässig
korrespondierendem Bit in der angegebenen Konstante (dem 2.ten
Operanden, muss keine Konstante sein) jeweils einzeln bitmässig verundet
1 | +--+--+--+--+--+--+--+--+
|
2 | Wert | | | | | | | | | <--- hier die 8 Bits von 'Wert'
|
3 | +--+--+--+--+--+--+--+--+ was immer die auch für Bitwerte (0 oder 1) haben
|
4 |
|
5 | die 'Maske' 0 0 0 0 1 1 1 1
|
jede Spalte der 8 Bit wird für sich betrachtet. Die obere Zeile ist das
'Bit B' von oben, die untere das 'Bit A'.
Was hatten wir bzgl. der UND Operation gelernt. Mit dem Bit A kann ich
das Ergebnis auf 0 zwingen, wenn das Bit A auf 0 ist. Genau das haben
wir hier aber
1 | +--+--+--+--+--+--+--+--+
|
2 | Wert | | | | | | | | | <--- hier die 8 Bits von 'Wert'
|
3 | +--+--+--+--+--+--+--+--+ was immer die auch für Bitwerte (0 oder 1) haben
|
4 |
|
5 | die 'Maske' 0 0 0 0 1 1 1 1
|
6 |
|
7 | ^ ^ ^ ^
|
8 | +--+--+--+------ diese 'Bit A' sind alle auf 0
|
d.h. mit dem Wissen über die UND Operation, können wir daher
vorhersagen, dass die ersten 4 Bit-Spalten im Ergebnis alle mit
Sicherheit ein 0 Bit haben werden.
Was wissen wir noch? Dort wo in den Bit A ein 1 Bit auftaucht, dort wird
das Ergebnis dasselbe sein, wie das Bit B war.
Auch den Fall haben wir hier. Die rechten 4 Spalten haben alle eine 1 im
Bit A
1 | +--+--+--+--+--+--+--+--+
|
2 | Wert | | | | | | | | | <--- hier die 8 Bits von 'Wert'
|
3 | +--+--+--+--+--+--+--+--+ was immer die auch für Bitwerte (0 oder 1) haben
|
4 |
|
5 | die 'Maske' 0 0 0 0 1 1 1 1
|
6 |
|
7 | ^ ^ ^ ^
|
8 | +--+--+--+------ die hier
|
d.h. an dieser Stelle wird im Ergebnis derselbe Bitwert wieder
auftauchen, der schon an dieser Bitposition in 'Wert' gestanden hat.
Alles zusammen genommen, ergibt sich also
1 | +--+--+--+--+--+--+--+--+
|
2 | Wert |a |b |c |d |e |f |g |h | a, b, c, d, ... seien stellvertretend
|
3 | +--+--+--+--+--+--+--+--+ für irgendwelche 0 bzw. 1 Werte
|
4 |
|
5 | die 'Maske' 0 0 0 0 1 1 1 1
|
6 |
|
7 | &-Operation =============================
|
8 |
|
9 | 0 0 0 0 e f g h
|
Mit dieser Operation wurden also die ersten 4 Bits auf 0 gezwungen,
während die restlichen 4 Bits erhalten blieben. Egal ob e, f, g, h auf 0
oder auf 1 gestanden sind, diese Werte tauchen im Ergebnis genau gleich
auf. Lediglich die ersten 4 Bits sind definitiv auf 0. Und zwar deshalb
weil hier
1 | die 'Maske' 0 0 0 0 1 1 1 1
|
2 |
|
3 | ==========
|
entsprechende Bits auf 0 waren.
D.h. mit einer UND Operation kann man Bits in einem Byte auf 0 zwingen.
Alles was es dazu braucht, ist eine Byte-Maske, die an den bewussten
Stellen ein 0 Bit hat und überall anders ein 1 Bit.
So, und jetzt überlegst du dir, was man wohl mit der Oder-Operation
anstellen kann und wie das funktioniert.
Thread beobachten
Seitenaufteilung abschalten